anchor.diff:  %%  LFE-EXPAND-EXPORTED-MACRO function. In this version we expand the
   %%  macros are compile time.
   
  -build_user_macro(#umac{expm=[]}) ->             %No macros to export
  -    empty_leum();
  -build_user_macro(#umac{env=Env}=Mst) ->
  +build_user_macro(#umac{leem=true}) -> [];       %Already have LEEM
  +build_user_macro(#umac{mline=L,expm=[]}) ->     %No macros to export
  +    [{empty_leum(),L}];
  +build_user_macro(#umac{mline=ModLine,env=Env}=Mst) ->
       Vfun = fun (N, V, Acc) -> [[N,V]|Acc] end,
       Sets = lfe_env:fold_vars(Vfun, [], Env),
       %% Collect the local functions.
  
positive.code: 
  add_huf(L, [{['define-function','$handle_undefined_function',Doc,Def],Lf}=F|Fs]) ->
      case function_arity(Def) of
          2 -> [{make_huf(Def, Doc),Lf}|Fs];      %Found the right $huf
          _ -> [F|add_huf(L, Fs)]
      end;
  add_huf(L, [F|Fs]) ->
  
negative.code:                    end
             end,
      %% Get the macros to export as case clauses.
      LEEM = case lfe_env:fold_macros(Mfun, [], Env) of
                 [] -> empty_leum();              %No macros to export
                 Macs ->
                     %% Build case, flet and let.
                     Case = ['case',?NAMEVAR|Macs ++ [['_',?Q(no)]]],
                     Flr = ['letrec-function',Funs,Case],
                     Fl = ['let',Sets,Flr],
                     ['define-function','LFE-EXPAND-EXPORTED-MACRO',?NODOC,
                      [lambda,[?NAMEVAR,?ARGSVAR,'$ENV'],Fl]]
             end,
      [{LEEM,ModLine}].
  
  empty_leum() ->
      ['define-function','LFE-EXPAND-EXPORTED-MACRO',?NODOC,
       [lambda,['_','_','_'],?Q(no)]].
  
  %% macro_case_clause(Name, Def) -> CaseClause.
  %%  Build a case clause for expanding macr Name.
  
  macro_case_clause(Name, Def) ->
      Cls = get_macro_cls(Def),
      Ccls = [ macro_clause(Args, B) || {Args,B} <- Cls ],
      [?Q(Name),['case',?ARGSVAR|Ccls]].          %Don't catch errors
  
  %% get_macro_cls(MacroDef) -> [{ArgPat,Body}].
  %%  Build a list of arg pattern and body for each clause. In the
  %%  definition arguments the first is the argument pattern, the second
  %%  is the environment variable $ENV. Be nice.
  
  get_macro_cls(['lambda',[Arg|_]|B]) ->
      [{Arg,B}];                                  %Only one clause here
  get_macro_cls(['match-lambda'|Cls]) ->
      [ {Arg,B} || [[Arg|_]|B] <- Cls ];
  get_macro_cls(_) -> [].                         %Ignore bad formed macros
  
  macro_clause(Args, [['when'|_]=W|Body]) ->
      [Args,W,[tuple,?Q(yes),[progn|Body]]];
  macro_clause(Args, Body) ->
      [Args,[tuple,?Q(yes),[progn|Body]]].
  
  %% add_huf(ModLine, Forms) -> Forms.
  %%  Add the $handle_undefined_function/2 function to catch run-time
  