anchor.diff:  
   -record(slurp, {mod,imps=[]}).			%For slurping
   
  -slurp([File], Eenv, Benv) ->
  -    Name = lfe_eval:expr(File, Eenv),		%Get file name
  +slurp([File], #state{env=Ee,base=Be}=St0) ->
  +    Name = lfe_eval:expr(File, Ee),		%Get file name
       case slurp_file(Name) of			%Parse, expand and lint file
   	{ok,Fs,Fenv0,_} ->
  -	    St0 = #slurp{mod='-no-mod-',imps=[]},
  -	    {Fbs,St1} = lfe_lib:proc_forms(fun collect_form/3, Fs, St0),
  +	    Sl0 = #slurp{mod='-no-mod-',imps=[]},
  +	    {Fbs,Sl1} = lfe_lib:proc_forms(fun collect_form/3, Fs, Sl0),
   	    %% Add imports to environment.
   	    Fenv1 = foldl(fun ({M,Is}, Env) ->
   				  foldl(fun ({{F,A},R}, E) ->
   						add_ibinding(M, F, A, R, E)
   					end, Env, Is)
  -			  end, Fenv0, St1#slurp.imps),
  +			  end, Fenv0, Sl1#slurp.imps),
   	    %% Get a new environment with all functions defined.
   	    Fenv2 = lfe_eval:make_letrec_env(Fbs, Fenv1),
  -	    {yes,{ok,St1#slurp.mod},add_env(Fenv2, Benv)};
  +	    St1 = St0#state{env=add_env(Fenv2, Be)},
  +	    {yes,{ok,Sl1#slurp.mod},St1};
   	{error,Es,_} ->
   	    slurp_errors(Name, Es),
  -	    {yes,error,Benv}
  +	    {yes,error,St0#state{env=Be}}
       end;
  -slurp(_, _, _) -> no.
  +slurp(_, _) -> no.
   
   slurp_file(Name) ->
       %% Parse, expand macros and lint file.
  
positive.code: 	false -> "> "
      end.
  
  %% eval_form(Form, EvalEnv, BaseEnv) -> {Value,Env}.
  
  eval_form(Form, Env, Benv) ->
      eval_exp_form(lfe_macro:expand_expr_all(Form, Env), Env, Benv).
  
  eval_exp_form([set,Pat,Expr], Env0, Benv) ->
      %% Special case to lint pattern.
      case lfe_lint:pattern(Pat, Env0) of
  	{ok,Ws} -> list_warnings(Ws);
  	{error,Es,Ws} ->
  	    list_errors(Es),
  	    list_warnings(Ws)
      end,
      {yes,Value,Env1} = set([Pat,Expr], Env0, Benv),
      {Value,Env1};
  eval_exp_form(Eform, Env0, Benv) ->
      case eval_internal(Eform, Env0, Benv) of
  	{yes,Value,Env1} -> {Value,Env1};
  	no ->
  	    %% Normal evaluation of form.
  	    {lfe_eval:expr(Eform, Env0),Env0}
      end.
  
  list_errors(Es) ->
  
negative.code: 		    lfe_io:format("~w: Warning: ~s\n", [L,Cs])
  	    end, Ws).
  
  %% eval_internal(Form, State) -> {yes,Value,State} | no.
  %%  Check for and evaluate internal functions. These all evaluate
  %%  their arguments.
  
  eval_internal([p|Args], St) ->			%Print out a value
      p(Args, St);
  eval_internal([pp|Args], St) ->			%Prettyprint out a value
      pp(Args, St);
  eval_internal([slurp|Args], St) ->		%Slurp in a file
      slurp(Args, St);
  eval_internal([unslurp|_], St) ->		%Forget everything
      Be = St#state.base,
      {yes,ok,St#state{env=Be}};
  eval_internal([c|Args], St) ->			%Compile an LFE file
      c(Args, St);
  eval_internal([ec|Args], St) ->			%Compile an Erlang file
      ec(Args, St);
  eval_internal([l|Args], St) ->			%Load modules
      l(Args, St);
  eval_internal([m|Args], St) ->			%Module info
      m(Args, St);
  eval_internal([set|Args], St) ->		%Set variables in shell
      set(Args, St);
  eval_internal(_, _) -> no.			%Not an internal function
  
  %% p([Arg], State) -> {yes,Res,State} | no.
  %% pp([Arg], State) -> {yes,Res,State} | no.
  
  p([A], St) ->
      E = lfe_eval:expr(A, St#state.env),
      Cs = lfe_io:print1(E),
      {yes,io:put_chars([Cs,$\n]),St};
  p(_, _) -> no.
  
  pp([A], St) ->
      E = lfe_eval:expr(A, St#state.env),
      Cs = lfe_io:prettyprint1(E),
      {yes,io:put_chars([Cs,$\n]),St};
  pp(_, _) -> no.
  
  %% c(Args, State) -> {yes,Res,State}.
  %%  Compile and load an LFE file.
  
  c([F], St) -> c([F,[]], St);
  c([F,Os], #state{env=Ee}=St) ->
      Name = lfe_eval:expr(F, Ee),		%Evaluate arguments
      Opts = lfe_eval:expr(Os, Ee),
      Loadm = fun ([]) -> {yes,{module,[]},St};
  		(Mod) ->
  		    Base = filename:basename(Name, ".lfe"),
  		    code:purge(Mod),
  		    R = code:load_abs(Base),
  		    {yes,R,St}
  	    end,
      case lfe_comp:file(Name, [report,verbose|Opts]) of
  	{ok,Mod,_} -> Loadm(Mod);
  	{ok,Mod} -> Loadm(Mod);
  	Other -> {yes,Other,St}
      end;
  c(_, _) -> no.					%Unknown function,
  
  %% ec(Args, State) -> {yes,Res,State}.
  %%  Compile and load an Erlang file.
  
  ec([F], St) -> ec([F,[]], St);
  ec([F,Os], #state{env=Ee}=St) ->
      Name = lfe_eval:expr(F, Ee),		%Evaluate arguments
      Opts = lfe_eval:expr(Os, Ee),
      {yes,c:c(Name, Opts),St};
  ec(_, _) -> no.					%Unknown function
  
  %% l(Args, State) -> {yes,Res,State}.
  %%  Load the modules in Args.
  
  l(Args, #state{env=Ee}=St) ->
      {yes,map(fun (M) -> c:l(lfe_eval:expr(M, Ee)) end, Args), St}.
  
  %% m(Args, State) -> {yes,Res,State}.
  %%  Module info.
  
  m([], St) -> {yes,c:m(),St};
  m(Args, #state{env=Ee}=St) ->
      {yes,map(fun (M) -> c:m(lfe_eval:expr(M, Ee)) end, Args), St}.
  
  %% set(Args, State) -> {yes,Result,State} | no.
  
  set([Pat,Exp], #state{env=Ee0}=St0) ->
      Val = lfe_eval:expr(Exp, Ee0),		%Evaluate expression
      case lfe_eval:match(Pat, Val, Ee0) of
  	{yes,Bs} ->
  	    Ee1 = foldl(fun ({N,V}, E) -> add_upd_vbinding(N, V, E) end,
  			Ee0, Bs),
  	    {yes,Val,St0#state{env=Ee1}};
  	no -> erlang:error({badmatch,Val})
      end;
  %% set([Pat,['when',G],Exp], St) ->
  set(_, _) -> no.
  
  %% slurp(File, State) -> {yes,{ok,Mod},State} | no.
  %%  Load in a file making all functions available. The module is
  %%  loaded in an empty environment and that environment is finally
  %%  added to the standard base environment. We could not use the
  