anchor.diff:      Status = hipe_result_to_status(Result),
       {reply,Status,S};
   
  -handle_call({ensure_loaded,Mod0}, Caller, St0) ->
  -    Fun = fun (M, St) ->
  -		  case erlang:module_loaded(M) of
  -		      true ->
  -			  {reply,{module,M},St};
  -		      false when St#state.mode =:= interactive ->
  -			  load_file(M, Caller, St);
  -		      false -> 
  -			  {reply,{error,embedded},St}
  -		  end
  -	  end,
  -    do_mod_call(Fun, Mod0, {error,badarg}, St0);
  -
  -handle_call({delete,Mod0}, {_From,_Tag}, S) ->
  -    Fun = fun (M, St) ->
  -		  case catch erlang:delete_module(M) of
  -		      true ->
  -			  ets:delete(St#state.moddb, M),
  -			  {reply,true,St};
  -		      _ -> 
  -			  {reply,false,St}
  -		  end
  -	  end,
  -    do_mod_call(Fun, Mod0, false, S);
  -
  -handle_call({purge,Mod0}, {_From,_Tag}, St0) ->
  -    do_mod_call(fun (M, St) ->
  -			{reply,do_purge(M),St}
  -		end, Mod0, false, St0);
  -
  -handle_call({soft_purge,Mod0}, {_From,_Tag}, St0) ->
  -    do_mod_call(fun (M, St) ->
  -			{reply,do_soft_purge(M),St}
  -		end, Mod0, true, St0);
  -
  -handle_call({is_loaded,Mod0}, {_From,_Tag}, St0) ->
  -    do_mod_call(fun (M, St) ->
  -			{reply,is_loaded(M, St#state.moddb),St}
  -		end, Mod0, false, St0);
  +handle_call({ensure_loaded,Mod}, Caller, St) when is_atom(Mod) ->
  +    case erlang:module_loaded(Mod) of
  +	true ->
  +	    {reply,{module,Mod},St};
  +	false when St#state.mode =:= interactive ->
  +	    load_file(Mod, Caller, St);
  +	false ->
  +	    {reply,{error,embedded},St}
  +    end;
  +
  +handle_call({delete,Mod}, {_From,_Tag}, St) when is_atom(Mod) ->
  +    case catch erlang:delete_module(Mod) of
  +	true ->
  +	    ets:delete(St#state.moddb, Mod),
  +	    {reply,true,St};
  +	_ ->
  +	    {reply,false,St}
  +    end;
  +
  +handle_call({purge,Mod}, {_From,_Tag}, St) when is_atom(Mod) ->
  +    {reply,do_purge(Mod),St};
  +
  +handle_call({soft_purge,Mod}, {_From,_Tag}, St) when is_atom(Mod) ->
  +    {reply,do_soft_purge(Mod),St};
  +
  +handle_call({is_loaded,Mod}, {_From,_Tag}, St) when is_atom(Mod) ->
  +    {reply,is_loaded(Mod, St#state.moddb),St};
   
   handle_call(all_loaded, {_From,_Tag}, S) ->
       Db = S#state.moddb,
       {reply,all_loaded(Db),S};
   
  -handle_call({get_object_code,Mod0}, {_From,_Tag}, St0) ->
  -    Fun = fun(M, St) ->
  -		  Path = St#state.path,
  -		  case mod_to_bin(Path, atom_to_list(M)) of
  -		      {_,Bin,FName} -> {reply,{M,Bin,FName},St};
  -		      Error -> {reply,Error,St}
  -		  end
  -	  end,
  -    do_mod_call(Fun, Mod0, error, St0);
  +handle_call({get_object_code,Mod}, {_From,_Tag}, St) when is_atom(Mod) ->
  +    Path = St#state.path,
  +    case mod_to_bin(Path, Mod) of
  +	{_,Bin,FName} -> {reply,{Mod,Bin,FName},St};
  +	Error -> {reply,Error,St}
  +    end;
   
   handle_call({is_sticky, Mod}, {_From,_Tag}, S) ->
       Db = S#state.moddb,
  
positive.code:     {ok,Path}.
  
  do_load_binary(Module, File, Binary, Caller, St) ->
      case modp(Module) andalso modp(File) andalso is_binary(Binary) of
  	true ->
  	    case erlang:module_loaded(to_atom(Module)) of
  		true -> do_purge(Module);
  		false -> ok
  	    end,
  
negative.code: 
  to_list(X) when is_list(X) -> X;
  to_list(X) when is_atom(X) -> atom_to_list(X).
  