anchor.diff:                   defs=Fbs1,env=Env},
       Exps = make_exports(St2#cg.exps, Fbs1),
       Atts = map(fun ({N,V,L}) ->
  -%%                       Ann = line_file_anno(L, St2),
                          Ann = [L],
                          {ann_c_lit(Ann, N),ann_c_lit(Ann, V)}
                  end, St2#cg.atts),
  
positive.code: 
  comp_guard([], _, _, St) -> {c_atom(true),St};  %The empty guard
  comp_guard(Gts, Env, L, St0) ->
      {Ce,St1} = comp_gtest(Gts, Env, L, St0),    %Guard expression
      %% Can hard code the rest!
      Cv = c_var('Try'),
      Evs = [c_var('T'),c_var('R')],              %Why only two?
      False = c_atom(false),                      %Exception returns false
      {ann_c_try([L], Ce, [Cv], Cv, Evs, False),St1}.
  
  %% comp_gtest(GuardTests, Env, Line, State) -> {CoreTest,State}.
  %%  Compile a guard test, making sure it returns a boolean value. We
  %%  do this in a naive way by always explicitly comparing the result
  %%  to 'true' and letting the optimiser clean this up. Ignore errors.
  
  %% comp_gtest([[quote,Bool]=Test], _, _, St) when is_boolean(Bool) ->
  %%     io:format("We hit it: ~p\n", [Test]),
  %%     {c_atom(Bool),St};
  %% comp_gtest([[Op|As]=Test], Env, L, St0) ->
  %%     Ar = length(As),
  %%     case erl_internal:bool_op(Op, Ar) orelse
  %%     erl_internal:comp_op(Op, Ar) orelse
  %%     erl_internal:type_test(Op, Ar) of
  %%     true ->
  %%         io:format("We hit it: ~p\n", [Test]),
  %%         comp_gexpr(Test, Env, L, St0);
  %%     false ->
  %%         Call = fun (Cas, _, L, St) ->
  %%                Ann = line_file_anno(L, St),
  %%                {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), Cas),St}
  %%            end,
  %%         comp_gargs([Test,?Q(true)], Call, Env, L, St0)
  %%     end;
  comp_gtest(Ts, Env, L, St0) ->            %Not a bool test or boolean
      %% Generate an explicit comparison with 'true' to give boolean.
      {Cg,St1} = comp_gbody(Ts, Env, L, St0),
      True = comp_lit(true),
      Call = fun (Cas, _, Li, St) ->
                     Ann = line_file_anno(Li, St),
                     {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), Cas),St}
             end,
      simple_seq([Cg,True], Call, Env, L, St1).
  
  %% comp_gbody(Body, Env, Line, State) -> {CoreBody,State}.
  %% Compile a guard body into a sequence of logical and tests.
  
  comp_gbody([], _, _, St) -> {c_atom(true),St};
  comp_gbody([T], Env, L, St) -> comp_gexpr(T, Env, L, St);
  comp_gbody([T|Ts], Env, L, St) ->
      comp_gif(T, [progn|Ts], ?Q(false), Env, L, St).
  
  %% comp_gexpr(Expr, Env, Line, State) -> {CoreExpr,State}.
  
  
negative.code: forms(Forms, St0, Core0) ->
      %% Collect the module definition and functions definitions.
      {Fbs0,St1} = lfe_lib:proc_forms(fun collect_form/3, Forms, St0),
      %% Add predefined functions and definitions, these are in line 0.
      Predefs = [{module_info,0},{module_info,1}],
      Mibs = [{module_info,
               [lambda,[],
                [call,?Q(erlang),?Q(get_module_info),?Q(St1#cg.mod)]],0},
              {module_info,
               [lambda,[x],
                [call,?Q(erlang),?Q(get_module_info),?Q(St1#cg.mod),x]],0}],
      %% The sum of all functions.
      Fbs1 = Fbs0 ++ Mibs,
      %% Make initial environment and set state.
  