anchor.diff:  %%     {PreForms,RestForms,Env,State}.
   
   collect_forms(Fs, Ci) ->
  -    St0 = lfe_macro:macro_form_init(Ci),
  -    Env0 = lfe_env:new(),
  -    collect_mod_forms(Fs, Env0, St0).
  +    Env = lfe_env:new(),
  +    St = lfe_macro:macro_form_init(Ci),
  +    collect_mod_forms(Fs, Env, St).
   
   %% collect_modules(Forms, PreForms, PreEnv, State) ->
   %%     {Modules,State}.
  
positive.code:     Ms1 = lists:map(Umac, Ms0),
      {ok,St#comp{code=Ms1}}.
  
  do_expand_macros(#comp{cinfo=Ci,code=Ms0}=St) ->
      Emac = fun ({ok,Name,Fs0,Ws}) ->
  		   Env0 = lfe_env:new(),
  		   St0 = lfe_macro:expand_form_init(Ci),
  		   {Fs1,_} = lfe_lib:proc_forms(fun expand_form/3,
  						Fs0, {Env0,St0}),
  		   {ok,Name,Fs1,Ws}
  	   end,
      Ms1 = lists:map(Emac, Ms0),
      {ok,St#comp{code=Ms1}}.
  
  expand_form(F0, L, {Env0,St0}) ->
      case lfe_macro:expand_form(F0, L, Env0, St0) of
  	{[progn|Pfs],Env1,St1} ->
  	    lfe_lib:proc_forms(fun expand_form/3, Pfs, L, {Env1,St1});
  	{['eval-when-compile'|_],Env1,St1} ->
  	    {[],{Env1,St1}};
  	{F1,Env1,St1} ->
  	    {[{F1,L}],{Env1,St1}}
      end.
  
  %% do_lfe_pmod(State) -> {ok,State} | {error,State}.
  
negative.code: 
  collect_modules([{['define-module',Name|_],_}=Mdef|Fs0], Ms, PreFs, PreEnv, St0) ->
      %% Expand and collect all forms upto next define-module or end.
      case collect_mod_forms(Fs0, PreEnv, St0) of
          {Mfs0,Fs1,_,St1} ->
              M = {ok,Name,[Mdef] ++ PreFs ++ Mfs0,[]},
              collect_modules(Fs1, [M|Ms], PreFs, PreEnv, St1);
          Error -> Error
      end;
  collect_modules([], Ms, _PreFs, _PreEnv, St) ->
      {ok,lists:reverse(Ms),St}.
  
  %% collect_mod_forms(Forms, Env, State) ->
  %% collect_mod_forms(Forms, Acc, Env, State) ->
  