anchor.diff:  int_list([_|_])                    -> false;
   int_list([])                       -> true.
   
  -load_file(Mod0, {From,_}=Caller, St0) ->
  -    Mod = to_atom(Mod0),
  +load_file(Mod, {From,_}=Caller, St0) ->
       case pending_on_load(Mod, From, St0) of
   	no -> load_file_1(Mod, Caller, St0);
   	{yes,St} -> {noreply,St}
  
positive.code:     end.
  
  mod_to_bin([Dir|Tail], Mod) ->
      File = filename:append(Dir, to_list(Mod) ++ objfile_extension()),
      case erl_prim_loader:get_file(File) of
  	error -> 
  	    mod_to_bin(Tail, Mod);
  
negative.code:     Status = hipe_result_to_status(Result),
      {reply,Status,S};
  
  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,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,
  