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: 
  collect_modules([{['define-module',Name|_],_}=Mdef|Fs0], Ms, PreFs, PreEnv, St0) ->
      %% Expand and collect all forms upto next define-module or end.
      {Mfs0,Fs1,_,St1} = collect_mod_forms(Fs0, PreEnv, St0),
      M = {ok,Name,[Mdef] ++ PreFs ++ Mfs0,[]},
      collect_modules(Fs1, [M|Ms], PreFs, PreEnv, St1);
  collect_modules([], Ms, _PreFs, _PreEnv, St) ->
      {lists:reverse(Ms),St}.
  
  %% collect_mod_forms(Forms, Env, State) ->
  %% collect_mod_forms(Forms, Acc, Env, State) ->
  
negative.code: %%  each module (with define-module form).
  
  do_split_file(#comp{cinfo=Ci,code=Code}=St) ->
      case collect_forms(Code, Ci) of             %Expand pre module forms
          {Pfs,Fs,Env0,Mst0} ->
              %% Expand the modules using the pre forms and environment.
              case collect_modules(Fs, Pfs, Env0, Mst0) of
                  {ok,Ms,_Mst1} ->
                      {ok,St#comp{code=Ms,
                                  warnings=St#comp.warnings}};
                  {error,Es,Ws} ->
                      {error,St#comp{code=[],     %Pseudo module list.
                                     errors=St#comp.errors ++ Es,
                                     warnings=St#comp.warnings ++ Ws}}
              end;
          {error,Es,Ws} ->
              {error,St#comp{code=[],             %Pseudo module list.
                             errors=St#comp.errors ++ Es,
                             warnings=St#comp.warnings ++ Ws}}
  