anchor.diff:  exp_predef([cadr,E], _, St) -> {yes,[car,[cdr,E]],St};
   exp_predef([cdar,E], _, St) -> {yes,[cdr,[car,E]],St};
   exp_predef([cddr,E], _, St) -> {yes,[cdr,[cdr,E]],St};
  -%% Arithmetic operations.
  -exp_predef(['+'|Es], _, St) ->
  -    Exp = case Es of
  -	      [A] -> exp_bif('+', [A]);
  -	      [A|As] -> foldl(fun (E, Acc) -> exp_bif('+', [Acc,E]) end, A, As);
  -	      [] -> 0				%Identity
  -	  end,
  -    {yes,Exp,St};
  -exp_predef(['-'|Es], _, St) ->
  -    Exp = case Es of
  -	      [A] -> exp_bif('-', [A]);
  -	      [A|As] -> foldl(fun (E, Acc) -> exp_bif('-', [Acc,E]) end, A, As)
  -	  end,
  -    {yes,Exp,St};
  -exp_predef(['*'|Es], _, St) ->
  -    Exp = case Es of
  -	      [A] -> exp_bif('*', [1,A]);	%Check if number
  -	      [A|As] -> foldl(fun (E, Acc) -> exp_bif('*', [Acc,E]) end, A, As);
  -	      [] -> 1				%Identity
  -	  end,
  -    {yes,Exp,St};
  -exp_predef(['/'|Es], _, St) ->
  -    Exp = case Es of
  -	      [A] -> exp_bif('/', [1,A]);
  -	      [A|As] -> foldl(fun (E, Acc) -> exp_bif('/', [Acc,E]) end, A, As)
  -	  end,
  -    {yes,Exp,St};
  +%% Arithmetic operations and comparison operations.
  +%% Be careful to make these behave as if they were a function and
  +%% strictly evalated all their arguments.
  +exp_predef(['+'|Es], _, St0) ->
  +    case Es of
  +	[] -> {yes,0,St0};			%Identity
  +	_ ->
  +	    {Exp,St1} = expand_arith(Es, '+', St0),
  +	    {yes,Exp,St1}
  +    end;
  +exp_predef(['-'|Es], _, St0) ->
  +    case Es of
  +	[_|_] ->				%Non-empty argument list
  +	    {Exp,St1} = expand_arith(Es, '-', St0),
  +	    {yes,Exp,St1}
  +    end;
  +exp_predef(['*'|Es], _, St0) ->
  +    case Es of
  +	[] -> {yes,1,St0};			%Identity
  +	[_] -> {yes,exp_bif('*', [1|Es]),St0};	%Check if number
  +	_ ->
  +	    {Exp,St1} = expand_arith(Es, '*', St0),
  +	    {yes,Exp,St1}
  +    end;
  +exp_predef(['/'|Es], _, St0) ->
  +    case Es of
  +	[_] -> {yes,exp_bif('/', [1|Es]),St0};	%According to definition
  +	_ ->
  +	    {Exp,St1} = expand_arith(Es, '/', St0),
  +	    {yes,Exp,St1}
  +    end;
  +exp_predef([Op|Es], _, St0)			%Logical operators
  +  when Op == '>'; Op == '>='; Op == '<'; Op == '=<';
  +       Op == '=='; Op == '/='; Op == '=:='; Op == '=/=' ->
  +    case Es of
  +	[_|_] ->
  +	    {Exp,St1} = expand_comp(Es, Op, St0),
  +	    {yes,Exp,St1}
  +    end;
   exp_predef([backquote,Bq], _, St) ->		%We do this here.
       {yes,bq_expand(Bq),St};
   exp_predef(['++'|Abody], _, St) ->
  
positive.code: 			   end, B0, Env, St1),
      {['try',E1|B1],St2}.
  
  %% exp_macro(Call, Def, Env, State) -> {Exp,State}.
  %%  Evaluate the macro definition by applying it to the call args. The
  %%  definition is either a lambda or match-lambda, expand it and apply
  %%  it to argument list.
  
  exp_macro([Mac|Args], Def0, Env, St0) ->
      %% lfe_io:format("macro: ~p\n", [Def0]),
  %%	Exp = lfe_eval:apply(Def1, [Args], Env),
  %%	{Exp,St1}.
  
negative.code:     case lfe_lib:is_core_form(Name) of
  	true -> no;				%Don't expand core forms
  	false ->
  	    St = #mac{expand=false},		%Default state
  	    case get_mbinding(Name, Env) of
  		{yes,Def} ->
  		    %% User macro bindings.
  		    {Exp,_} = exp_userdef_macro(Call, Def, Env, St),
  		    {yes,Exp};
  		no ->
  		    %% Default macro bindings.
  		    case exp_predef_macro(Call, Env, St) of
  			{yes,Exp,_} -> {yes,Exp};
  			no -> no
  		    end
  