anchor.diff:  %%  NOTE: Don't yet generate code to macros with *only* no arg case to
   %%  be used as functions. So -define(foo, bar) won't work for foo(42).
   
  -trans_macro_defs([{none,Ds}|Defs]) ->		%Put the no arg version last
  -    trans_macro_defs_1(Defs ++ [{none,Ds}]);
  -trans_macro_defs(Defs) ->
  -    trans_macro_defs_1(Defs).
  -
  -trans_macro_defs_1([{none,{none,Ts}}|Defs]) ->
  -    case catch {ok,trans_macro_body([], Ts)} of
  -	{ok,Ld} ->
  -	    AnyArgs = ['_'|Ld],
  -	    [AnyArgs|trans_macro_defs_1(Defs)];
  -	_ -> trans_macro_defs_1(Defs)		%Skip errors
  -    end;
  -trans_macro_defs_1([{N,{As,Ts}}|Defs]) when is_integer(N) ->
  -    case {ok,trans_macro_body(As, Ts)} of
  -	{ok,Ld} -> [[[list|As]|Ld]|trans_macro_defs_1(Defs)];
  -	_ -> trans_macro_defs_1(Defs)		%Skip errors
  -    end;
  -trans_macro_defs_1([]) -> [].
  +trans_macro_defs([{none,{none,Ts}}|Defs]) ->
  +    Ld = trans_macro_body([], Ts),
  +    AnyArgs = ['_'|Ld],
  +    [AnyArgs|trans_macro_defs(Defs)];
  +trans_macro_defs([{N,{As,Ts}}|Defs]) when is_integer(N) ->
  +    Ld = trans_macro_body(As, Ts),
  +    ListArgs = [[list|As]|Ld],
  +    [ListArgs|trans_macro_defs(Defs)];
  +trans_macro_defs([]) -> [].
   
   trans_macro_body(As, Ts0) ->
       Ts1 = trans_qm(Ts0),
       %% Wrap variables in arg list with an (unquote ...) call.
  -    Ts2 = lists:foldr(fun ({var,L,V}=T, Ts) ->
  -			      case lists:member(V, As) of
  -				  true ->
  -				      [{atom,L,unquote},{'(',L},T,{')',L}|Ts];
  -				  false -> [T|Ts]
  -			      end;
  -			  (T, Ts) -> [T|Ts]
  -		      end, [], Ts1),
  +    Wrap = fun ({var,L,V}=T, Ts) ->
  +		   case lists:member(V, As) of
  +		       true ->
  +			   [{atom,L,unquote},{'(',L},T,{')',L}|Ts];
  +		       false -> [T|Ts]
  +		   end;
  +	       (T, Ts) -> [T|Ts]
  +	   end,
  +    Ts2 = lists:foldr(Wrap, [], Ts1),
       %% Only allow single expressions, otherwise screws up backquoting.
  -    case erl_parse:parse_exprs(Ts2 ++ [{dot,0}]) of
  -	{ok,[E]} ->
  -	    [?BQ(lfe_trans:from_expr(E))];
  -	Other -> io:format("~p\n", [Other]),
  -		 []
  -    end.
  +    {ok,[E]} = erl_parse:parse_exprs(Ts2 ++ [{dot,0}]),
  +    [?BQ(lfe_trans:from_expr(E))].
  +
  +    %% case erl_parse:parse_exprs(Ts2 ++ [{dot,0}]) of
  +    %% 	{ok,[E]} ->
  +    %% 	    io:format("~p\n", [E]),
  +    %% 	    [?BQ(lfe_trans:from_expr(E))];
  +    %% 	Other -> io:format("~p\n~w\n", [Other,Ts2]),
  +    %% 		 []
  +    %% end.
   
       %% {ok,[_]=F} = erl_parse:parse_exprs(Ts1 ++ [{dot,0}]),
       %% backquote_last(lfe_trans:from_body(F)).
  
positive.code: 
  %% parse_hrl_file(Forms, Macros, State) -> {ok,Forms,State} | {error,Error}.
  
  parse_hrl_file(Fs0, Ms0, St) ->
      Fs1 = trans_forms(Fs0),
      Ms1 = trans_macros(Ms0),
      {ok,Fs1 ++ Ms1,St}.
  
  %% trans_forms(Forms) -> Forms.
  %%  Translate the record defintions in the forms to LFE record
  %%  definitions. Ignore all type declarations and other forms.
  
  trans_forms([{attribute,_,record,{Name,Fields}}|Fs]) ->
      Rs = record_fields(Fields),
      [[defrecord,Name|Rs]|trans_forms(Fs)];
  trans_forms([{error,_}|Fs]) -> trans_forms(Fs);	%What should we do with these?
  trans_forms([_|Fs]) -> trans_forms(Fs);		%Ignore everything else
  trans_forms([]) -> [].
  
  record_fields(Fs) ->
      [ record_field(F) || F <- Fs ].
  
negative.code: 
  -module(lfe_macro_include).
  
  -export([file/3,lib/3,format_error/1,stringify/1]).
  
  -compile([export_all]).
  
  