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:             error
      end.
  
  slurp_file(Name) ->
      case lfe_comp:file(Name, [binary,to_split,return]) of
          {ok,[{ok,Mod,Fs0,_}|_],Ws} ->           %Only do first module
              case lfe_macro:expand_forms(Fs0, lfe_env:new()) of
                  {ok,Fs1,Env,_} ->
                      %% Flatten and trim away any eval-when-compile.
                      {Fs2,42} = lfe_lib:proc_forms(fun slurp_form/3, Fs1, 42),
                      case lfe_lint:module(Fs2) of
                          {ok,_,Lws} -> {ok,Mod,Fs2,Env,Ws ++ Lws};
                          {error,Les,Lws} ->
                              slurp_error_ret(Name, Les, Ws ++ Lws)
                      end;
                  {error,Ees,Ews} ->
                      slurp_error_ret(Name, Ees, Ws ++ Ews)
              end;
          Error -> Error
      end.
  
  slurp_error_ret(Name, Es, Ws) ->
      {error,[],[{Name,Es}],[{Name,Ws}]}.
  
  slurp_form(['eval-when-compile'|_], _, D) -> {[],D};
  slurp_form(F, L, D) -> {[{F,L}],D}.
  
  collect_module({['define-module',Mod|Mdef],_}, Sl0) ->
      Sl1 = collect_mdef(Mdef, Sl0),
      Sl1#slurp{mod=Mod};
  collect_module({['extend-module'|Mdef],_}, Sl) ->
      collect_mdef(Mdef, Sl);
  collect_module({['define-function',F,Def],_}, #slurp{funs=Fs}=Sl) ->
      Ar = function_arity(Def),
      Sl#slurp{funs=[{F,Ar,Def}|Fs]}.
  
  collect_mdef([[import|Is]|Mdef], St) ->
      collect_mdef(Mdef, collect_imps(Is, St));
  