anchor.diff:  
   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);
  +    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) ->
  -    {lists:reverse(Ms),St}.
  +    {ok,lists:reverse(Ms),St}.
   
   %% collect_mod_forms(Forms, Env, State) ->
   %% collect_mod_forms(Forms, Acc, Env, State) ->
  
positive.code: %%  also flatten top-level nested progn code.
  
  collect_mod_forms(Fs, Env0, St0) ->
      {Acc,Rest,Env1,St1} = collect_mod_forms(Fs, [], Env0, St0),
      {lists:reverse(Acc),Rest,Env1,St1}.
  
  collect_mod_forms([F0|Fs0], Acc, Env0, St0) ->
      case lfe_macro:macro_fileform(F0, Env0, St0) of
  	{{['define-module'|_],_}=F1,Env1,St1} ->
  	    {Acc,[F1|Fs0],Env1,St1};
  	{{['progn'|Pfs],L},Env1,St1} ->		%Flatten progn's
  	    Fs1 = [ {F,L} || F <- Pfs ] ++ Fs0,
  	    collect_mod_forms(Fs1, Acc, Env1, St1);
  	{F1,Env1,St1} ->
  	    collect_mod_forms(Fs0, [F1|Acc], Env1, St1)
      end;
  collect_mod_forms([], Acc, Env, St) -> {Acc,[],Env,St}.
  
  
negative.code: %%     {PreForms,RestForms,Env,State}.
  
  collect_forms(Fs, Ci) ->
      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}.
  