anchor.diff:      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
  
positive.code: 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
          {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_warnings(Ws),
              slurp_warnings(Mws),
              Sl0 = #slurp{mod=Mod,imps=[]},
              {Fbs,Sl1} = lfe_lib:proc_forms(fun collect_form/3, Fs, Sl0),
              %% 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),
              %% 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};
          {error,Mews,Es,Ws} ->
              slurp_errors(Es),
              slurp_warnings(Ws),
  
negative.code: 
  %% unslurp(State) -> {ok,State}.
  %% slurp(File, State) -> {{ok,Mod},State}.
  %%  Load in a file making all the functions and macros available.
  %%  There is a bit of trickery to get hold of the compile environment
  %%  to get hold of the macros. We call the compiler directly but don't
  %%  make the LFE-EXPAND-EXPORTED-MACRO/3 function.
  
  -record(slurp, {mod,funs=[],imps=[]}).          %For slurping
  
  unslurp(St0) ->
      St1 = case St0#state.slurp of
  