anchor.diff:  slurp([File], St0) ->
       {ok,#state{curr=Ce0}=St1} = unslurp(St0),   %Reset the environment
       Name = lfe_eval:expr(File, Ce0),            %Get file name
  -    case slurp_file(Name, Ce0) of
  +    case slurp_1(Name, Ce0) of
           {ok,Mod,Ce1} ->                         %Set the new environment
               {{ok,Mod},St1#state{save=Ce0,curr=Ce1,slurp=true}};
           error ->
               {error,St1}
       end.
   
  -slurp_file(Name, Ce0) ->
  -    case lfe_comp:file(Name, [binary,to_lint,return]) of
  -        {ok,[{ok,Mod,Fs,Mws}|_],Ws} ->          %Only do first module
  +slurp_1(Name, Ce) ->
  +    case slurp_file(Name) of
  +        {ok,Mod,Fs,Env0,Ws} ->
               slurp_warnings(Ws),
  -            slurp_warnings(Mws),
  -            Sl0 = #slurp{mod=Mod,imps=[]},
  -            {Fbs,Sl1} = lfe_lib:proc_forms(fun collect_form/3, Fs, Sl0),
  +	    %% Collect functions and imports.
  +            Sl0 = #slurp{mod=Mod,funs=[],imps=[]},
  +            Sl1 = lists:foldl(fun collect_module/2, Sl0, Fs),
               %% Add imports to environment.
  -            Ce1 = foldl(fun ({M,Is}, Env) ->
  -                                foldl(fun ({{F,A},R}, E) ->
  -                                              add_ibinding(M, F, A, R, E)
  -                                      end, Env, Is)
  -                        end, Ce0, Sl1#slurp.imps),
  +            Env1 = foldl(fun ({M,Is}, Env) ->
  +                                 foldl(fun ({{F,A},R}, E) ->
  +                                               add_ibinding(M, F, A, R, E)
  +                                       end, Env, Is)
  +                         end, Env0, Sl1#slurp.imps),
               %% Add functions to environment.
  -            Ce2 = foldl(fun ({N,Ar,Def}, Env) ->
  -                                lfe_eval:add_dynamic_func(N, Ar, Def, Env)
  -                        end, Ce1, Fbs),
  -            {ok,Mod,Ce2};
  +            Env2 = foldl(fun ({N,Ar,Def}, Env) ->
  +                                 lfe_eval:add_dynamic_func(N, Ar, Def, Env)
  +                         end, Env1, Sl1#slurp.funs),
  +            {ok,Mod,add_env(Env2, Ce)};
           {error,Mews,Es,Ws} ->
               slurp_errors(Es),
               slurp_warnings(Ws),
  
positive.code: 
  %% unslurp(State) -> {ok,State}.
  %% slurp(File, State) -> {{ok,Mod},State}.
  %%  Load in a file making all functions available. We call the
  %%  compiler directly and only add defined functions, macros are
  %%  lost. Any exported macros will be available in the
  %%  LFE-EXPAND-EXPORTED-MACRO/3 function.
  
  -record(slurp, {mod,imps=[]}).                  %For slurping
  
  unslurp(St0) ->
      St1 = case St0#state.slurp of
  
negative.code:     Imps0 = safe_fetch(Mod, St#slurp.imps, []),
      Imps1 = foldl(Fun, Imps0, Fs),
      St#slurp{imps=store(Mod, Imps1, St#slurp.imps)}.
  
  %% slurp_errors([File, ]Errors) -> ok.
  %% slurp_warnings([File, ]Warnings) -> ok.
  %%  Print errors and warnings.
  
  slurp_errors(Errors) ->
      foreach(fun ({File,Es}) -> slurp_errors(File, Es) end, Errors).
  
  slurp_errors(File, Es) -> slurp_ews(File, "~s:~w: ~s\n", Es).
  
  slurp_warnings(Warnings) ->
      foreach(fun ({File,Ws}) -> slurp_warnings(File, Ws) end, Warnings).
  
  slurp_warnings(File, Es) -> slurp_ews(File, "~s:~w: Warning: ~s\n", Es).
  
  slurp_ews(File, Format, Ews) ->
      foreach(fun ({Line,Mod,Error}) ->
                      Cs = Mod:format_error(Error),
                      lfe_io:format(Format, [File,Line,Cs])
              end, Ews).
  
  %% run(Args, State) -> {Value,State}.
  %%  Run the shell expressions in a file. Abort on errors and only
  