anchor.diff:  
   -module(lfe_macro_include).
   
  --export([file/3,lib/3,format_error/1]).
  -
  --export([trans_forms/1]).
  +-export([file/3,lib/3,format_error/1,stringify/1]).
   
   -compile([export_all]).
   
  
positive.code:     Ld = lfe_trans:from_expr(Def),
      [Fd,Ld].
  
  %% trans_macros(MacroDefs) -> Forms.
  %%  Translate macro definitions to LFE macro definitions. Ignore
  %%  undefined and predefined macros.
  
  trans_macros([{{atom,Mac},Defs}|Ms]) ->
      case trans_macro(Mac, Defs) of
  	[] -> trans_macros(Ms);			%No definition, ignore
  	Mdef -> [Mdef|trans_macros(Ms)]
      end;
  trans_macros([]) -> [].
  
  trans_macro(_, undefined) -> [];		%Undefined macros
  trans_macro(_, {none,_}) -> [];			%Predefined macros
  trans_macro(Mac, Defs) ->
      case trans_macro_defs(Defs) of
  	[] -> [];				%No definition
  	Lcls -> [defmacro,Mac|Lcls]
      end.
  
  %% trans_macro_defs(MacroDef) -> [] | [Clause].
  
  %%  Translate macro definition to a list of clauses. Put the no arg
  %%  version last as a catch all. Clash if macro has no arg definition
  %%  *and* function definition with no args:
  
negative.code: %%  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,{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.
      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.
      {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)).
  