anchor.diff:  %% (let-syntax ...) should never be seen here!
   %% Handle the Core control special forms.
   comp_gexpr(['progn'|Body], Env, L, St) ->
  -    comp_gbody(Body, Env, L, St);
  +    comp_guard_tests(Body, Env, L, St);
   comp_gexpr(['if'|Body], Env, L, St) ->
       comp_gif(Body, Env, L, St);
   comp_gexpr([call,[quote,erlang],[quote,Fun]|As], Env, L, St) ->
  
positive.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.
      Predefs = [{module_info,0},{module_info,1}],
      Mibs = [{module_info,
               [lambda,[],
                [call,?Q(erlang),?Q(get_module_info),?Q(St1#cg.mod)]],1},
              {module_info,
               [lambda,[x],
                [call,?Q(erlang),?Q(get_module_info),?Q(St1#cg.mod),x]],1}],
      %% The sum of all functions.
      Fbs1 = Fbs0 ++ Mibs,
      %% Make initial environment and set state.
  
negative.code: 
  comp_guard([], _, _, St) -> {c_atom(true),St};  %The empty guard
  comp_guard(Gts, Env, L, St0) ->
      {Ce,St1} = comp_guard_tests(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_guard_tests(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_guard_tests(Gts, Env, Line, St0) ->
      {Gas,St1} = mapfoldl(fun (Gt, St) -> comp_guard_test(Gt, Env, Line, St) end,
                           St0, Gts),
      Ands = fun guard_ands/4,
      simple_seq(Gas, Ands, Env, Line, St1).
  
  guard_ands([Ga], _, _, St) -> {Ga,St};
  guard_ands([G1,G2], _, Line, St) ->
      {ann_c_call([Line], c_atom(erlang), c_atom('and') , [G1,G2]), St};
  guard_ands([G1,G2|Gas], Env, Line, St0) ->
      {Cv,St1} = new_c_var(Line, St0),
      {Gr,St2} = guard_ands([Cv|Gas], Env, Line, St1),
      And = ann_c_call([Line], c_atom(erlang), c_atom('and'), [G1,G2]),
      {ann_c_let([Line], [Cv], And, Gr),St2}.
  
  %% comp_guard_test(Test, Env, Line, State) -> {CoreTest,State}.
  %%  Compile one test. We try to avoid generating an unnecessary true
  %%  test by checking the test and only adding one when we know the
  %%  test won't automatically return a boolean value.
  
  comp_guard_test([call,[quote,erlang],[quote,Op]|Args]=Test, Env, L, St) ->
      comp_guard_test_1(Test, Op, Args, Env, L, St);
  comp_guard_test([Op|Args]=Test, Env, L, St) ->
      comp_guard_test_1(Test, Op, Args, Env, L, St).
  
  comp_guard_test_1(Test, Op, Args, Env, L, St0) ->
      Ar = length(Args),
      %% Check if this is a boolean test, else add a boolean test.
      case erl_internal:bool_op(Op, Ar) orelse
          erl_internal:comp_op(Op, Ar) orelse
          erl_internal:type_test(Op, Ar) of
          true ->                                 %It's already boolean
              comp_gexpr(Test, Env, L, St0);
          false ->                                %No it's not, then make it one
              Call = fun (Cas, _, Li, St) ->
                             Ann = [Li,compiler_generated],
                             {ann_c_call(Ann, c_atom(erlang), c_atom('=:='), Cas),
                              St}
                     end,
              comp_gargs([Test,?Q(true)], Call, Env, L, St0)
      end.
  
  %% comp_gexpr(Expr, Env, Line, State) -> {CoreExpr,State}.
  
  