anchor.diff:      do_forms(Fs, Env, St).
   
   do_forms(Fs0, Env0, St0) ->
  -    {Fs1,Env1,St1} = pass(Fs0, Env0, St0),
  +    {Fs1,Env1,St1} = pass_fileforms(Fs0, Env0, St0),
       case St1#mac.errors of
           [] -> {ok,Fs1,Env1,St1#mac.warnings};    %No errors
           Es -> {error,Es,St1#mac.warnings}
  
positive.code:     Mdefs = map(fun ([Name|Rules]) -> exp_rules(Name, [], Rules) end, Defs),
      {yes,['let-macro',Mdefs|Body],St};
  exp_predef([prog1|Body], _, St0) ->
      [First|Rest] = Body,                        %Catch bad form here
      {V,St1} = new_symb(St0),
      {yes,['let',[[V,First]]|Rest ++ [V]],St1};
  exp_predef([prog2|Body], _, St0) ->
      [First,Second|Rest] = Body,                 %Catch bad form here
      {V,St1} = new_symb(St0),
      {yes,['let',[[V,[progn,First,Second]]]|Rest ++ [V]],St1};
  %% This has to go here for the time being so as to be able to macro
  %% expand body.
  exp_predef(['match-spec'|Body], Env, St0) ->
  
negative.code: default_state(Expand) ->
      #mac{expand=Expand,line=1,file="-nofile-",opts=[],ipath=["."]}.
  
  %% pass_fileforms(FileForms, Env, State) -> {FileForms,Env,State}.
  %% pass_forms(Forms, Env, State) -> {Forms,Env,State}.
  %%  Pass over a list of fileforms/forms collecting and removing all macro
  %%  defintions. All forms must be expanded at top-level to check form,
  %%  but all can be expanded to full depth. Nesting of forms by progn
  %%  is preserved.
  
  pass_fileforms(Ffs, Env, St) ->
      mapfoldl2(fun ({F0,L}, E0, S0) ->
                        {F1,E1,S1} = pass_form(F0, E0, S0#mac{line=L}),
                        %%io:format("p: ~p\n" ,[{F0,F1,L}]),
                        {{F1,L},E1,S1}
                end, Env, St, Ffs).
  
  pass_forms(Fs, Env, St) ->
      mapfoldl2(fun (F0, E0, S0) -> pass_form(F0, E0, S0) end, Env, St, Fs).
  
  %% pass_form(Form, Env, State) -> {Form,Env,State}.
  %%  Do a form collecting and removing all macro defintions. The form
  %%  must be expanded at top-level to check it, but it can be expanded
  %%  to full depth. Nesting of forms by progn is preserved.
  
  pass_form(['progn'|Pfs0], Env0, St0) ->
      {Pfs1,Env1,St1} = pass_forms(Pfs0, Env0, St0),
      {['progn'|Pfs1],Env1,St1};
  pass_form(['eval-when-compile'|Ewcs0], Env0, St0) ->
      {Ecws1,Env1,St1} = pass_ewc(Ewcs0, Env0, St0),
      {['progn'|Ecws1],Env1,St1};
  pass_form(['define-macro'|Def]=F, Env0, St0) ->
      case pass_define_macro(Def, Env0, St0) of
          {yes,Env1,St1} ->
              {['progn'],Env1,St1};               %Must return a valid form
          {no,St1} ->
              %% Ignore it and pass it on to generate error later.
              {F,Env0,St1}
      end;
  pass_form(F, Env, St0) ->
      %% First expand enough to test top form, if so process again.
      case pass_expand_expr(F, Env, St0, St0#mac.expand) of
          {yes,Exp,St1} ->                        %Top form expanded
              pass_form(Exp, Env, St1);
          {no,F1,St1} ->                          %Expanded all if flag set
              {F1,Env,St1}
      end.
  
  %% pass_ewc(Forms, Env, State) -> {Forms,Env,State}.
  %%  Pass over a list of forms collecting and removing all function
  