The R13B03 release.OTP_R13B03

1 files changed, 2566 insertions, 0 deletions

diff --git a/lib/observer/src/crashdump_viewer.erl b/lib/observer/src/crashdump_viewer.erl
new file mode 100644
index 0000000000..b323d86ea4
--- /dev/null
+++ b/lib/observer/src/crashdump_viewer.erl
@@ -0,0 +1,2566 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(crashdump_viewer).
+
+%% 
+%% This module is the main module in the crashdump viewer. It implements
+%% the server started by webtool and the API for the crashdump viewer tool.
+%% 
+%% All functions in the API except configData/0 and start_link/0 are 
+%% called from HTML pages via erl_scheme.
+%% 
+%% Tables
+%% ------
+%% cdv_menu_table: This table holds the menu which is presented in the left
+%% frame of the crashdump viewer page. Each element in the table represents
+%% one meny item, and the state of the item indicates if it is presently 
+%% visible or not.
+%% 
+%% cdv_dump_index_table: This table holds all tags read from the crashdump.
+%% Each tag indicates where the information about a specific item starts.
+%% The table entry for a tag includes the start and end positions for
+%% this item-information. All tags start with a "=" at the beginning of
+%% a line.
+%%
+%% Process state
+%% -------------
+%% file: The name of the crashdump currently viewed.
+%% procs_summary: Process summary represented by a list of 
+%% #proc records. This is used for efficiency reasons when sorting
+%% the process summary table instead of reading all processes from
+%% the dump again.
+%% sorted: atom(), indicated what item was last sorted in process summary.
+%% This is needed so reverse sorting can be done.
+%% shared_heap: 'true' if crashdump comes from a system running shared heap,
+%% else 'false'.
+%% wordsize: 4 | 8, the number of bytes in a word.
+%% binaries: a gb_tree containing binaries or links to binaries in the dump
+%%
+
+%% User API
+-export([start/0,stop/0]).
+
+%% Webtool API
+-export([configData/0,
+	 start_link/0]).
+-export([start_page/2,
+	 read_file_frame/2,
+	 read_file/2,
+	 redirect/2,
+	 filename_frame/2,
+	 menu_frame/2,
+	 initial_info_frame/2,
+	 toggle/2,
+	 general_info/2,
+	 processes/2,
+	 proc_details/2,
+	 ports/2,
+	 ets_tables/2,
+	 timers/2,
+	 fun_table/2,
+	 atoms/2,
+	 dist_info/2,
+	 loaded_modules/2,
+	 loaded_mod_details/2,
+	 memory/2,
+	 allocated_areas/2,
+	 allocator_info/2,
+	 hash_tables/2,
+	 index_tables/2,
+	 sort_procs/2,
+	 expand/2,
+	 expand_binary/2,
+	 expand_memory/2,
+	 next/2]).
+
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, 
+	 terminate/2, code_change/3]).
+
+%% Debug support
+-export([debug/1,stop_debug/0]).
+
+-include("crashdump_viewer.hrl").
+-include_lib("kernel/include/file.hrl").
+-include_lib("stdlib/include/ms_transform.hrl").
+
+-define(START_PAGE,"/cdv_erl/crashdump_viewer/start_page").
+-define(READ_FILE_PAGE,"/cdv_erl/crashdump_viewer/read_file?path=").
+-define(SERVER, crashdump_viewer_server).
+-define(call_timeout,3600000).
+-define(chunk_size,1000). % number of bytes read from crashdump at a time
+-define(max_line_size,100). % max number of bytes (i.e. characters) the
+			    % line_head/1 function can return
+-define(max_display_size,500). % max number of bytes that will be directly
+				% displayed. If e.g. msg_q is longer than
+				% this, it must be explicitly expanded.
+-define(max_display_binary_size,50). % max size of a binary that will be
+				      % directly displayed.
+
+-define(initial_proc_record(Pid),
+	#proc{pid=Pid,
+	      %% msg_q_len, reds and stack_heap are integers because it must 
+	      %% be possible to sort on them. All other fields are strings
+	      msg_q_len=0,reds=0,stack_heap=0,
+	      %% for old dumps start_time, parent and number of heap frament
+	      %% does not exist
+	      start_time="unknown",
+	      parent="unknown",
+	      num_heap_frag="unknown", 
+	      %% current_func can be both "current function" and
+	      %% "last scheduled in for"
+	      current_func={"Current Function",?space},
+	      %% stack_dump, message queue and dictionaries should only be 
+	      %% displayed as a link to "Expand" (if dump is from OTP R9B 
+	      %% or newer)
+	      _=?space}).
+
+-record(state,{file,procs_summary,sorted,shared_heap=false,
+	       wordsize=4,num_atoms="unknown",binaries,bg_status}).
+
+%%%-----------------------------------------------------------------
+%%% Debugging
+%% Start tracing with
+%% debug(Functions).
+%% Functions = local | global | FunctionList
+%% FunctionList = [Function]
+%% Function = {FunctionName,Arity} | FunctionName
+debug(F) -> 
+    ttb:tracer(all,[{file,"cdv"}]), % tracing all nodes
+    ttb:p(all,[call,timestamp]),
+    MS = [{'_',[],[{return_trace},{message,{caller}}]}],
+    tp(F,MS),
+    ttb:ctp(?MODULE,stop_debug), % don't want tracing of the stop_debug func
+    ok.
+tp([{M,F,A}|T],MS) -> % mod:func/arity
+    ttb:tpl(M,F,A,MS),
+    tp(T,MS);
+tp([{M,F}|T],MS) -> % mod:func
+    ttb:tpl(M,F,MS),
+    tp(T,MS);
+tp([M|T],MS) -> % mod
+    ttb:tp(M,MS), % only exported
+    tp(T,MS);
+tp([],_MS) ->
+    ok.
+stop_debug() ->
+    ttb:stop([format]).
+
+%%%-----------------------------------------------------------------
+%%% User API
+start() ->
+    webtool:start(),
+    receive after 1000 -> ok end,
+    webtool:start_tools([],"app=crashdump_viewer"),
+    receive after 1000 -> ok end,
+    ok.
+
+stop() ->
+    webtool:stop_tools([],"app=crashdump_viewer"),
+    webtool:stop().
+
+%%%-----------------------------------------------------------------
+%%% Return config data used by webtool
+configData() ->
+    Dir = filename:join(code:priv_dir(observer),"crashdump_viewer"),
+    {crashdump_viewer,
+     [{web_data,{"CrashDumpViewer",?START_PAGE}},
+      {alias,{"/crashdump_viewer",Dir}},
+      {alias,{"/crashdump_erts_doc",erts_docdir()}},
+      {alias,{"/crashdump_doc",cdv_docdir()}},
+      {alias,{erl_alias,"/cdv_erl",[?MODULE]}},
+      {start,{child,{{local,?SERVER},
+		     {?MODULE,start_link,[]},
+		     permanent,100,worker,[?MODULE]}}}
+	      ]}.
+
+erts_docdir() ->
+    ErtsVsn = erlang:system_info(version),
+    RootDir = code:root_dir(),
+    VsnErtsDir = filename:join(RootDir,"erts-"++ErtsVsn),
+    DocDir = filename:join(["doc","html"]),
+    case filelib:is_dir(VsnErtsDir) of
+	true ->
+	    filename:join(VsnErtsDir,DocDir);
+	false ->
+	    %% So this can be run in clearcase
+	    filename:join([RootDir,"erts",DocDir])
+    end.
+
+cdv_docdir() ->
+    ObserverDir = code:lib_dir(observer),
+    filename:join([ObserverDir,"doc","html"]).
+
+%%====================================================================
+%% External functions
+%%====================================================================
+%%%--------------------------------------------------------------------
+%%% Start the server
+start_link() ->
+    case whereis(?SERVER) of
+	undefined ->
+	    gen_server:start_link({local, ?SERVER}, ?MODULE, [], []);
+	Pid ->
+	    {ok,Pid}
+    end.
+
+%%%-----------------------------------------------------------------
+%%% If crashdump_viewer is just started, show welcome frame. Else
+%%% show menu and general_info
+start_page(_Env,_Input) ->
+    call(start_page).
+
+%%%-----------------------------------------------------------------
+%%% Display the form for entering the file name for the crashdump
+%%% to view.
+read_file_frame(_Env,_Input) ->
+    crashdump_viewer_html:read_file_frame().
+
+%%%-----------------------------------------------------------------
+%%% Called when the 'ok' button is clicked after entering the dump
+%%% file name.
+read_file(_Env,Input) ->
+    call({read_file,Input}).
+
+%%%-----------------------------------------------------------------
+%%% The topmost frame of the main page. Called when a crashdump is
+%%% loaded.
+filename_frame(_Env,_Input) ->
+    call(filename_frame).
+
+%%%-----------------------------------------------------------------
+%%% The initial information frame. Called when a crashdump is loaded.
+initial_info_frame(_Env,_Input) ->
+    call(initial_info_frame).
+
+%%%-----------------------------------------------------------------
+%%% The left frame of the main page. Called when a crashdump is
+%%% loaded.
+menu_frame(_Env,_Input) ->
+    crashdump_viewer_html:menu_frame().
+
+%%%-----------------------------------------------------------------
+%%% Called when the collapsed or exploded picture in the menu is 
+%%% clicked.
+toggle(_Env,Input) ->
+    call({toggle,Input}).
+
+%%%-----------------------------------------------------------------
+%%% The following functions are called when menu items are clicked.
+general_info(_Env,_Input) ->
+    call(general_info).
+processes(_Env,_Input) ->
+    call(procs_summary).
+ports(_Env,Input) -> % this is also called when a link to a port is clicked
+    call({ports,Input}).
+ets_tables(_Env,Input) ->
+    call({ets_tables,Input}).
+timers(_Env,Input) ->
+    call({timers,Input}).
+fun_table(_Env,_Input) ->
+    call(funs).
+atoms(_Env,_Input) ->
+    call(atoms).
+dist_info(_Env,_Input) ->
+    call(dist_info).
+loaded_modules(_Env,_Input) ->
+    call(loaded_mods).
+loaded_mod_details(_Env,Input) ->
+    call({loaded_mod_details,Input}).
+memory(_Env,_Input) ->
+    call(memory).
+allocated_areas(_Env,_Input) ->
+    call(allocated_areas).
+allocator_info(_Env,_Input) ->
+    call(allocator_info).
+hash_tables(_Env,_Input) ->
+    call(hash_tables).
+index_tables(_Env,_Input) ->
+    call(index_tables).
+
+%%%-----------------------------------------------------------------
+%%% Called when a link to a process (Pid) is clicked.
+proc_details(_Env,Input) ->
+    call({proc_details,Input}).
+
+%%%-----------------------------------------------------------------
+%%% Called when one of the headings in the process summary table are
+%%% clicked. It sorts the processes by the clicked heading.
+sort_procs(_Env,Input) ->
+    call({sort_procs,Input}).
+
+%%%-----------------------------------------------------------------
+%%% Called when the "Expand" link in a call stack (Last Calls) is
+%%% clicked.
+expand(_Env,Input) ->
+    call({expand,Input}).
+
+%%%-----------------------------------------------------------------
+%%% Called when the "Expand" link in a stack dump, message queue or 
+%%% dictionary is clicked.
+expand_memory(_Env,Input) ->
+    call({expand_memory,Input}).
+
+%%%-----------------------------------------------------------------
+%%% Called when "<< xxx bytes>>" link in a stack dump, message queue or 
+%%% dictionary is clicked.
+expand_binary(_Env,Input) ->
+    call({expand_binary,Input}).
+
+%%%-----------------------------------------------------------------
+%%% Called when the "Next" link under atoms is clicked.
+next(_Env,Input) ->
+    call({next,Input}).
+
+%%%-----------------------------------------------------------------
+%%% Called on regular intervals while waiting for a dump to be read
+redirect(_Env,_Input) ->
+    call(redirect).
+
+%%====================================================================
+%% Server functions
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init/1
+%% Description: Initiates the server
+%% Returns: {ok, State}          |
+%%          {ok, State, Timeout} |
+%%          ignore               |
+%%          {stop, Reason}
+%%--------------------------------------------------------------------
+init([]) ->
+    ets:new(cdv_menu_table,[set,named_table,{keypos,#menu_item.index},public]),
+    ets:new(cdv_dump_index_table,[bag,named_table,public]),
+    {ok, #state{}}.
+
+%%--------------------------------------------------------------------
+%% Function: handle_call/3
+%% Description: Handling call messages
+%% Returns: {reply, Reply, State}          |
+%%          {reply, Reply, State, Timeout} |
+%%          {noreply, State}               |
+%%          {noreply, State, Timeout}      |
+%%          {stop, Reason, Reply, State}   | (terminate/2 is called)
+%%          {stop, Reason, State}            (terminate/2 is called)
+%%--------------------------------------------------------------------
+handle_call(start_page,_From,State=#state{file=undefined,bg_status=undefined})->
+    Reply = crashdump_viewer_html:welcome(),
+    {reply,Reply,State};
+handle_call(start_page, _From, State=#state{file=undefined,bg_status={done,Page}}) ->
+    {reply,Page,State};
+handle_call(start_page, _From, State=#state{file=undefined,bg_status=Status}) ->
+    Reply = crashdump_viewer_html:redirect(Status),
+    {reply,Reply,State};
+handle_call(start_page, _From, State) ->
+    Reply = crashdump_viewer_html:start_page(),
+    {reply,Reply,State};
+handle_call({read_file,Input}, _From, _State) ->
+    {ok,File0} = get_value("path",httpd:parse_query(Input)),
+    File = 
+	case File0 of
+	    [$"|FileAndSome] ->
+		%% Opera adds \"\" around the filename!
+		[$"|Elif] = lists:reverse(FileAndSome),
+		lists:reverse(Elif);
+	    _ ->
+		File0
+	end,
+    spawn_link(fun() -> read_file(File) end),
+    Status = background_status(reading,File),
+    Reply = crashdump_viewer_html:redirect(Status),
+    {reply, Reply, #state{bg_status=Status}};
+handle_call(redirect,_From, State=#state{bg_status={done,Page}}) ->
+    {reply, Page, State#state{bg_status=undefined}};   
+handle_call(redirect,_From, State=#state{bg_status=Status}) ->
+    Reply = crashdump_viewer_html:redirect(Status),
+    {reply, Reply, State};
+handle_call(filename_frame,_From,State=#state{file=File}) ->
+    Reply = crashdump_viewer_html:filename_frame(File),
+    {reply,Reply,State};
+handle_call(initial_info_frame,_From,State=#state{file=File}) ->
+    GenInfo = general_info(File),
+    NumAtoms = GenInfo#general_info.num_atoms,
+    {WS,SH} = parse_vsn_str(GenInfo#general_info.system_vsn,4,false),
+    Reply = crashdump_viewer_html:general_info(GenInfo),
+    {reply,Reply,State#state{shared_heap=SH,wordsize=WS,num_atoms=NumAtoms}};
+handle_call({toggle,Input},_From,State) ->
+    {ok,Index} = get_value("index",httpd:parse_query(Input)),
+    do_toggle(list_to_integer(Index)),
+    Reply = crashdump_viewer_html:menu_frame(),
+    {reply,Reply,State};
+handle_call({expand,Input},_From,State=#state{file=File}) ->
+    [{"pos",Pos},{"size",Size},{"what",What},{"truncated",Truncated}] = 
+	httpd:parse_query(Input),
+    Expanded = get_expanded(File,list_to_integer(Pos),list_to_integer(Size)),
+    TruncText = if Truncated=="true" -> "WARNING: This term is truncated!\n\n";
+		   true -> ""
+		end,
+    Reply = 
+	case {Truncated,What} of
+	    {_,"LastCalls"} ->
+		LastCalls = replace_all($ ,$\n,Expanded,[]),
+		crashdump_viewer_html:info_page(What,[TruncText,LastCalls]);
+	    {_,"StackDump"} ->
+		crashdump_viewer_html:info_page(What,[TruncText,Expanded]);
+	    {"false",_} ->
+		crashdump_viewer_html:pretty_info_page(What,Expanded);
+	    {"true",_} ->
+		crashdump_viewer_html:info_page(What,[TruncText,Expanded])
+	end,
+    {reply,Reply,State};
+handle_call({expand_memory,Input},_From,State=#state{file=File,binaries=B}) ->
+    [{"pid",Pid},{"what",What}] = httpd:parse_query(Input),
+    Reply = 
+	case truncated_warning([{"=proc",Pid}]) of
+	    [] ->
+		Expanded = expand_memory(File,What,Pid,B),
+		crashdump_viewer_html:expanded_memory(What,Expanded);
+	    _TW ->
+		Info = 
+		    "The crashdump is truncated in the middle of this "
+		    "process' memory information, so this information "
+		    "can not be extracted.",
+		crashdump_viewer_html:info_page(What,Info)
+	end,
+    {reply,Reply,State};
+handle_call({expand_binary,Input},_From,State=#state{file=File}) ->
+    [{"pos",Pos0}] = httpd:parse_query(Input),
+    Pos = list_to_integer(Pos0),
+    Fd = open(File),
+    pos_bof(Fd,Pos),
+    {Bin,_Line} = get_binary(val(Fd)),
+    close(Fd),
+    Reply=crashdump_viewer_html:expanded_binary(io_lib:format("~p",[Bin])),
+    {reply,Reply,State};
+handle_call({next,Input},_From,State=#state{file=File}) ->
+    [{"pos",Pos},{"num",N},{"start",Start},{"what",What}] =
+	httpd:parse_query(Input),
+    Tags = related_tags(What),
+    TW = truncated_warning(Tags),
+    Next = get_next(File,list_to_integer(Pos),list_to_integer(N),
+		    list_to_integer(Start),What),
+    Reply = crashdump_viewer_html:next(Next,TW),
+    {reply,Reply,State};
+handle_call(general_info,_From,State=#state{file=File}) ->
+    GenInfo=general_info(File),
+    Reply = crashdump_viewer_html:general_info(GenInfo),
+    {reply,Reply,State};
+handle_call(procs_summary,_From,State=#state{file=File,shared_heap=SH}) ->
+    ProcsSummary =
+	case State#state.procs_summary of
+	    undefined -> procs_summary(File);
+	    PS -> PS
+	end,
+    TW = truncated_warning(["=proc"]),
+    Reply = crashdump_viewer_html:procs_summary("pid",ProcsSummary,TW,SH),
+    {reply,Reply,State#state{procs_summary=ProcsSummary,sorted="pid"}};
+handle_call({sort_procs,Input}, _From, State=#state{shared_heap=SH}) ->
+    {ok,Sort} = get_value("sort",httpd:parse_query(Input)),
+    {ProcsSummary,Sorted} = do_sort_procs(Sort,
+					  State#state.procs_summary,
+					  State#state.sorted),
+    TW = truncated_warning(["=proc"]),
+    Reply = crashdump_viewer_html:procs_summary(Sort,ProcsSummary,TW,SH),
+    {reply,Reply,State#state{sorted=Sorted}};
+handle_call({proc_details,Input},_From,State=#state{file=File,shared_heap=SH}) ->
+    {ok,Pid} = get_value("pid",httpd:parse_query(Input)),
+    Reply = 
+	case get_proc_details(File,Pid) of
+	    {ok,Proc} -> 
+		TW = truncated_warning([{"=proc",Pid}]),
+		crashdump_viewer_html:proc_details(Pid,Proc,TW,SH);
+	    {other_node,Node} -> 
+		TW = truncated_warning(["=visible_node",
+					"=hidden_node",
+					"=not_connected"]),
+		crashdump_viewer_html:nods(Node,TW);
+	    not_found -> 
+		crashdump_viewer_html:info_page(["Could not find process: ",
+						 Pid],?space)
+	end,
+    {reply, Reply, State};
+handle_call({ports,Input},_From,State=#state{file=File}) ->
+    Reply = 
+	case get_value("port",httpd:parse_query(Input)) of
+	    {ok,P} -> 
+		Id = [$#|P],
+		case get_port(File,Id) of
+		    {ok,PortInfo} ->
+			TW = truncated_warning([{"=port",Id}]),
+			crashdump_viewer_html:ports(Id,[PortInfo],TW);
+		    {other_node,Node} ->
+			TW = truncated_warning(["=visible_node",
+						"=hidden_node",
+						"=not_connected"]),
+			crashdump_viewer_html:nods(Node,TW);
+		    not_found -> 
+			crashdump_viewer_html:info_page(
+			  ["Could not find port: ",Id],?space)
+		end;
+	    error -> % no port identity in Input - get all ports
+		Ports=get_ports(File),
+		TW = truncated_warning(["=port"]),
+		crashdump_viewer_html:ports("Port Information",Ports,TW)
+	end,
+    {reply,Reply,State};
+handle_call({ets_tables,Input},_From,State=#state{file=File,wordsize=WS}) ->
+    {Pid,Heading,InternalEts} = 
+	case get_value("pid",httpd:parse_query(Input)) of
+	    {ok,P} -> 
+		{P,["ETS Tables for Process ",P],[]};
+	    error -> 
+		I = get_internal_ets_tables(File,WS),
+		{'_',"ETS Table Information",I}
+	end,
+    EtsTables = get_ets_tables(File,Pid,WS),
+    TW = truncated_warning(["=ets"]),
+    Reply = crashdump_viewer_html:ets_tables(Heading,EtsTables,InternalEts,TW),
+    {reply,Reply,State};
+handle_call({timers,Input},_From,State=#state{file=File}) ->
+    {Pid,Heading} = 
+	case get_value("pid",httpd:parse_query(Input)) of
+	    {ok,P} -> {P,["Timers for Process ",P]};
+	    error -> {'_',"Timer Information"}
+	end,
+    Timers=get_timers(File,Pid),
+    TW = truncated_warning(["=timer"]),
+    Reply = crashdump_viewer_html:timers(Heading,Timers,TW),
+    {reply,Reply,State};
+handle_call(dist_info,_From,State=#state{file=File}) ->
+    Nods=nods(File),
+    TW = truncated_warning(["=visible_node","=hidden_node","=not_connected"]),
+    Reply = crashdump_viewer_html:nods(Nods,TW),
+    {reply,Reply,State};
+handle_call(loaded_mods,_From,State=#state{file=File}) ->
+    LoadedMods=loaded_mods(File),
+    TW = truncated_warning(["=mod"]),
+    Reply = crashdump_viewer_html:loaded_mods(LoadedMods,TW),
+    {reply,Reply,State};
+handle_call({loaded_mod_details,Input},_From,State=#state{file=File}) ->
+    {ok,Mod} = get_value("mod",httpd:parse_query(Input)),
+    ModInfo = get_loaded_mod_details(File,Mod),
+    TW = truncated_warning([{"=mod",Mod}]),
+    Reply = crashdump_viewer_html:loaded_mod_details(ModInfo,TW),
+    {reply,Reply,State};
+handle_call(funs,_From,State=#state{file=File}) ->
+    Funs=funs(File),
+    TW = truncated_warning(["=fun"]),
+    Reply = crashdump_viewer_html:funs(Funs,TW),
+    {reply,Reply,State};
+handle_call(atoms,_From,State=#state{file=File,num_atoms=Num}) ->
+    Atoms=atoms(File),
+    TW = truncated_warning(["=atoms","=num_atoms"]),
+    Reply = crashdump_viewer_html:atoms(Atoms,Num,TW),
+    {reply,Reply,State};
+handle_call(memory,_From,State=#state{file=File}) ->
+    Memory=memory(File),
+    TW = truncated_warning(["=memory"]),
+    Reply = crashdump_viewer_html:memory(Memory,TW),
+    {reply,Reply,State};
+handle_call(allocated_areas,_From,State=#state{file=File}) ->
+    AllocatedAreas=allocated_areas(File),
+    TW = truncated_warning(["=allocated_areas"]),
+    Reply = crashdump_viewer_html:allocated_areas(AllocatedAreas,TW),
+    {reply,Reply,State};
+handle_call(allocator_info,_From,State=#state{file=File}) ->
+    SlAlloc=allocator_info(File),
+    TW = truncated_warning(["=allocator"]),
+    Reply = crashdump_viewer_html:allocator_info(SlAlloc,TW),
+    {reply,Reply,State};
+handle_call(hash_tables,_From,State=#state{file=File}) ->
+    HashTables=hash_tables(File),
+    TW = truncated_warning(["=hash_table","=index_table"]),
+    Reply = crashdump_viewer_html:hash_tables(HashTables,TW),
+    {reply,Reply,State};
+handle_call(index_tables,_From,State=#state{file=File}) ->
+    IndexTables=index_tables(File),
+    TW = truncated_warning(["=hash_table","=index_table"]),
+    Reply = crashdump_viewer_html:index_tables(IndexTables,TW),
+    {reply,Reply,State}.
+
+
+
+%%--------------------------------------------------------------------
+%% Function: handle_cast/2
+%% Description: Handling cast messages
+%% Returns: {noreply, State}          |
+%%          {noreply, State, Timeout} |
+%%          {stop, Reason, State}            (terminate/2 is called)
+%%--------------------------------------------------------------------
+handle_cast({background_done,{Page,File,Binaries},Dict}, State) ->
+    lists:foreach(fun({Key,Val}) -> put(Key,Val) end, Dict),
+    {noreply, State#state{file=File,binaries=Binaries,bg_status={done,Page}}};
+handle_cast({background_status,Status}, State) ->
+    {noreply, State#state{bg_status=Status}}.
+
+%%--------------------------------------------------------------------
+%% Function: handle_info/2
+%% Description: Handling all non call/cast messages
+%% Returns: {noreply, State}          |
+%%          {noreply, State, Timeout} |
+%%          {stop, Reason, State}            (terminate/2 is called)
+%%--------------------------------------------------------------------
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+%%--------------------------------------------------------------------
+%% Function: terminate/2
+%% Description: Shutdown the server
+%% Returns: any (ignored by gen_server)
+%%--------------------------------------------------------------------
+terminate(_Reason, _State) ->
+    ok.
+
+%%--------------------------------------------------------------------
+%% Func: code_change/3
+%% Purpose: Convert process state when code is changed
+%% Returns: {ok, NewState}
+%%--------------------------------------------------------------------
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%--------------------------------------------------------------------
+%%% Internal functions
+%%--------------------------------------------------------------------    
+call(Request) ->
+     gen_server:call(?SERVER,Request,?call_timeout).
+
+cast(Msg) ->
+    gen_server:cast(?SERVER,Msg).
+
+unexpected(_Fd,{eof,_LastLine},_Where) ->
+    ok; % truncated file
+unexpected(Fd,{part,What},Where) ->
+    skip_rest_of_line(Fd),
+    io:format("WARNING: Found unexpected line in ~s:~n~s ...~n",[Where,What]);
+unexpected(_Fd,What,Where) ->
+    io:format("WARNING: Found unexpected line in ~s:~n~s~n",[Where,What]).
+
+truncated_warning([]) ->
+    [];
+truncated_warning([Tag|Tags]) ->
+    case truncated_here(Tag) of
+	true -> truncated_warning();
+	false -> truncated_warning(Tags)
+    end.
+truncated_warning() ->
+    ["WARNING: The crash dump is truncated here. "
+     "Some information might be missing."].
+
+truncated_here(Tag) ->
+    case get(truncated) of
+	true ->
+	    case get(last_tag) of
+		Tag -> % Tag == {TagType,Id}
+		    true;
+		{Tag,_Id} ->
+		    true;
+		_LastTag ->
+		    truncated_earlier(Tag)
+	    end;
+	false ->
+	    false
+    end.
+		    
+
+%% Check if the dump was truncated with the same tag, but earlier id.
+%% Eg if this is {"=proc","<0.30.0>"}, we should warn if the dump was
+%% truncated in {"=proc","<0.29.0>"} or earlier
+truncated_earlier({"=proc",Pid}) ->
+    compare_pid(Pid,get(truncated_proc));
+truncated_earlier(_Tag) ->
+    false.
+
+compare_pid("<"++Id,"<"++OtherId) ->
+    Id>=OtherId;
+compare_pid(_,_) ->
+    false.
+
+background_status(Action,File) ->
+    SizeInfo = filesizeinfo(File), 
+    background_status(Action,File,SizeInfo).
+
+background_status(processing,File,SizeInfo) ->
+    "Processing " ++ File ++ SizeInfo;
+background_status(reading,File,SizeInfo) ->
+    "Reading file " ++ File ++ SizeInfo.
+
+filesizeinfo(File) ->
+    case file:read_file_info(File) of
+	{ok,#file_info{size=Size}} -> 
+	    " (" ++ integer_to_list(Size) ++ " bytes)";
+	_X ->
+	    ""
+    end.
+
+
+open(File) ->
+    {ok,Fd} = file:open(File,[read,read_ahead,raw,binary]),
+    Fd.
+close(Fd) ->
+    erase(chunk),
+    file:close(Fd).
+pos_bof(Fd,Pos) ->
+    reset_chunk(),
+    file:position(Fd,{bof,Pos}). 
+
+get_chunk(Fd) ->
+    case erase(chunk) of
+	undefined ->
+	    case read(Fd) of
+		eof -> 
+		    put_pos(Fd),
+		    eof;
+		Other ->
+		    Other
+	    end;
+	Bin ->
+	    {ok,Bin}
+    end.
+
+read(Fd) ->
+    file:read(Fd,?chunk_size).
+
+put_chunk(Fd,Bin) ->
+    {ok,Pos0} = file:position(Fd,cur),
+    Pos = Pos0 - byte_size(Bin),
+    put(chunk,Bin),
+    put(pos,Pos).
+
+put_pos(Fd) ->
+    {ok,Pos} = file:position(Fd,cur),
+    put(pos,Pos).    
+
+reset_chunk() ->
+    erase(chunk),
+    erase(pos).
+
+line_head(Fd) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> line_head(Fd,Bin,[],0);
+	eof -> {eof,[]}
+    end.
+line_head(Fd,Bin,Acc,?max_line_size) ->
+    put_chunk(Fd,Bin),
+    {part,lists:reverse(Acc)};
+line_head(Fd,<<$\n:8,Bin/binary>>,Acc,_N) ->
+    put_chunk(Fd,Bin),
+    lists:reverse(Acc);
+line_head(Fd,<<$::8,$\r:8,$\n:8,Bin/binary>>,Acc,_N) ->
+    put_chunk(Fd,Bin),
+    lists:reverse(Acc);
+line_head(Fd,<<$::8,$\r:8>>,Acc,N) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> line_head(Fd,<<$:,Bin/binary>>,Acc,N);
+	eof -> {eof,lists:reverse(Acc)}
+    end;
+line_head(Fd,<<$::8>>,Acc,N) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> line_head(Fd,<<$:,Bin/binary>>,Acc,N);
+	eof -> {eof,lists:reverse(Acc)}
+    end;
+line_head(Fd,<<$::8,Space:8,Bin/binary>>,Acc,_N) when Space=:=$ ;Space=:=$\n ->
+    put_chunk(Fd,Bin),
+    lists:reverse(Acc);
+line_head(Fd,<<$::8,Bin/binary>>,Acc,_N) ->
+    put_chunk(Fd,Bin),
+    lists:reverse(Acc);
+line_head(Fd,<<$\r:8,Bin/binary>>,Acc,N) ->
+    line_head(Fd,Bin,Acc,N+1);
+line_head(Fd,<<Char:8,Bin/binary>>,Acc,N) ->
+    line_head(Fd,Bin,[Char|Acc],N+1);
+line_head(Fd,<<>>,Acc,N) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> line_head(Fd,Bin,Acc,N);
+	eof -> {eof,lists:reverse(Acc)}
+    end.
+
+skip_rest_of_line(Fd) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> skip(Fd,Bin);
+	eof -> ok
+    end.
+skip(Fd,<<$\n:8,Bin/binary>>) ->
+    put_chunk(Fd,Bin),
+    ok;
+skip(Fd,<<_Char:8,Bin/binary>>) ->
+    skip(Fd,Bin);
+skip(Fd,<<>>) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> skip(Fd,Bin);
+	eof -> ok
+    end.
+
+
+val(Fd) ->
+    case get_rest_of_line(Fd) of
+	{eof,[]} -> "-1";
+	[] -> "-1";
+	{eof,Val} -> Val;
+	Val -> Val
+    end.
+
+get_rest_of_line(Fd) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> get_rest_of_line_1(Fd, Bin, []);
+	eof -> {eof,[]}
+    end.
+
+get_rest_of_line_1(Fd, <<$\n:8,Bin/binary>>, Acc) ->
+    put_chunk(Fd, Bin),
+    lists:reverse(Acc);
+get_rest_of_line_1(Fd, <<$\r:8,Rest/binary>>, Acc) ->
+    get_rest_of_line_1(Fd, Rest, Acc);
+get_rest_of_line_1(Fd, <<Char:8,Rest/binary>>, Acc) ->
+    get_rest_of_line_1(Fd, Rest, [Char|Acc]);
+get_rest_of_line_1(Fd, <<>>, Acc) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> get_rest_of_line_1(Fd, Bin, Acc);
+	eof -> {eof,lists:reverse(Acc)}
+    end.
+
+count_rest_of_line(Fd) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> count_rest_of_line(Fd,Bin,0);
+	eof -> {eof,0}
+    end.
+count_rest_of_line(Fd,<<$\n:8,Bin/binary>>,N) ->
+    put_chunk(Fd,Bin),
+    N;
+count_rest_of_line(Fd,<<$\r:8,Bin/binary>>,N) ->
+    count_rest_of_line(Fd,Bin,N);
+count_rest_of_line(Fd,<<_Char:8,Bin/binary>>,N) ->
+    count_rest_of_line(Fd,Bin,N+1);
+count_rest_of_line(Fd,<<>>,N) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> count_rest_of_line(Fd,Bin,N);
+	eof -> {eof,N}
+    end.
+
+get_n_lines_of_tag(Fd,N) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> 
+	    {AllOrPart,Rest,Lines} = get_n_lines_of_tag(Fd,N,Bin,[]),
+	    {AllOrPart,N-Rest,Lines};
+	eof ->
+	    empty
+    end.
+get_n_lines_of_tag(Fd,N,<<"\n=",_/binary>>=Bin,Acc) ->
+    put_chunk(Fd,Bin),
+    {all,N-1,lists:reverse(Acc)};
+get_n_lines_of_tag(Fd,0,Bin,Acc) ->
+    put_chunk(Fd,Bin),
+    {part,0,lists:reverse(Acc)};
+get_n_lines_of_tag(Fd,N,<<$\n:8,Bin/binary>>,Acc) ->
+    get_n_lines_of_tag(Fd,N-1,Bin,[$\n|Acc]);
+get_n_lines_of_tag(Fd,N,<<$\r:8,Bin/binary>>,Acc) ->
+    get_n_lines_of_tag(Fd,N,Bin,Acc);
+get_n_lines_of_tag(Fd,N,<<Char:8,Bin/binary>>,Acc) ->
+    get_n_lines_of_tag(Fd,N,Bin,[Char|Acc]);
+get_n_lines_of_tag(Fd,N,<<>>,Acc) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> 
+	    get_n_lines_of_tag(Fd,N,Bin,Acc);
+	eof -> 
+	    case Acc of
+		[$\n|_] ->
+		    {all,N,lists:reverse(Acc)};
+		_ ->
+		    {all,N-1,lists:reverse(Acc)}
+	    end
+    end.
+
+count_rest_of_tag(Fd) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> count_rest_of_tag(Fd,Bin,0);
+	eof -> 0
+    end.
+count_rest_of_tag(Fd,<<"\n=",Bin/binary>>,N) ->
+    put_chunk(Fd,Bin),
+    N;
+count_rest_of_tag(Fd,<<$\r:8,Bin/binary>>,N) ->
+    count_rest_of_tag(Fd,Bin,N);
+count_rest_of_tag(Fd,<<_Char:8,Bin/binary>>,N) ->
+    count_rest_of_tag(Fd,Bin,N+1);
+count_rest_of_tag(Fd,<<>>,N) ->
+    case get_chunk(Fd) of
+	{ok,Bin} -> count_rest_of_tag(Fd,Bin,N);
+	eof -> N
+    end.
+
+split(Str) ->
+    split($ ,Str,[]).    
+split(Char,Str) ->
+    split(Char,Str,[]).
+split(Char,[Char|Str],Acc) -> % match Char
+    {lists:reverse(Acc),Str};
+split(_Char,[$\r,$\n|Str],Acc) -> % new line
+    {lists:reverse(Acc),Str};
+split(_Char,[$\n|Str],Acc) -> % new line
+    {lists:reverse(Acc),Str};
+split(Char,[H|T],Acc) ->
+    split(Char,T,[H|Acc]);
+split(_Char,[],Acc) ->
+    {lists:reverse(Acc),[]}.
+
+size_or_term(Fd) ->
+    size_or_term(Fd,get(pos)).
+size_or_term(Fd,Pos) ->
+    case count_rest_of_line(Fd) of
+	{eof,Size} ->
+	    {size,true,Size,Pos};
+	Size when Size > ?max_display_size ->
+	    {size,false,Size,Pos};
+	_Size ->
+	    {ok,Pos} = pos_bof(Fd,Pos),
+	    val(Fd)
+    end.
+
+%%%-----------------------------------------------------------------
+%%% 
+get_value(Key,List) ->
+    case lists:keysearch(Key,1,List) of
+	{value,{Key,Value}} -> {ok,Value};
+	false -> error
+    end.
+
+parse_vsn_str([],WS,false) ->
+    %% If the log is translated, crashdump_translate might have written
+    %% shared_heap=true in dictionary.
+    case erase(shared_heap) of
+	true -> {WS,true};
+	_ -> {WS,false}
+    end;
+parse_vsn_str([],WS,SH) ->
+    {WS,SH};
+parse_vsn_str(Str,WS,SH) ->
+    case Str of
+	"[64-bit]" ++ Rest ->
+	    case SH of
+		false ->
+		    parse_vsn_str(Rest,8,false);
+		_ ->
+		    {8,SH}
+	    end;
+	"[shared heap]" ++ Rest ->
+	    case WS of
+		4 -> 
+		    parse_vsn_str(Rest,WS,true);
+		_ ->
+		    {WS,true}
+	    end;
+	[_Char|Rest] ->
+	    parse_vsn_str(Rest,WS,SH)
+    end.
+
+
+%%%-----------------------------------------------------------------
+%%% 
+initial_menu() ->
+    insert_items(
+      [menu_item(0, {"./general_info","General information"},0),
+       menu_item(0, {"./processes","Processes"}, 0),
+       menu_item(0, {"./ports","Ports"}, 0),
+       menu_item(0, {"./ets_tables","ETS tables"}, 0),
+       menu_item(0, {"./timers","Timers"}, 0),
+       menu_item(0, {"./fun_table","Fun table"}, 0),
+       menu_item(0, {"./atoms","Atoms"}, 0),
+       menu_item(0, {"./dist_info","Distribution information"}, 0),
+       menu_item(0, {"./loaded_modules","Loaded modules"}, 0),
+       menu_item(2, "Internal Tables", 0),
+       menu_item(0, {"./hash_tables","Hash tables"}, 1),
+       menu_item(0, {"./index_tables","Index tables"}, 1),
+       menu_item(3, "Memory information", 0),
+       menu_item(0, {"./memory","Memory"}, 1),
+       menu_item(0, {"./allocated_areas","Allocated areas"}, 1),
+       menu_item(0, {"./allocator_info","Allocator information"}, 1),
+       menu_item(2, "Documentation", 0),
+       menu_item(0, {"/crashdump_doc/crashdump_help.html",
+		     "Crashdump Viewer help"}, 1,"doc"),
+       menu_item(0, {"/crashdump_erts_doc/crash_dump.html",
+		     "How to interpret Erlang crashdumps"}, 1,"doc")]).
+    
+menu_item(Children,Text,Depth) ->
+    menu_item(Children,Text,Depth,"main").
+menu_item(Children,Text,Depth,Target) ->
+    #menu_item{picture=get_pic(Children),
+	       text=Text,
+	       depth=Depth,
+	       children=Children,
+	       state=if Depth==0 -> true; true -> false end,
+	       target=Target}.
+
+insert_items(Items) ->
+    insert_items(Items,1).
+insert_items([Item|Items],Index) ->
+    ets:insert(cdv_menu_table,Item#menu_item{index=Index}),
+    insert_items(Items,Index+1);
+insert_items([],_) ->
+    ok.
+
+get_pic(0) ->
+    "";
+get_pic(_) ->
+     "/crashdump_viewer/collapsd.gif".
+
+do_toggle(Index) ->
+    [Item]= ets:lookup(cdv_menu_table,Index),
+    case toggle_children(Index,Index+Item#menu_item.children,
+			 Item#menu_item.depth+1,undefined) of
+	true ->
+	    ets:insert(cdv_menu_table,
+		       Item#menu_item{picture=
+				      "/crashdump_viewer/exploded.gif"});
+	false ->
+	    ets:insert(cdv_menu_table,
+		       Item#menu_item{picture=
+				      "/crashdump_viewer/collapsd.gif"})
+    end.
+
+toggle_children(Index,Max,_Depth,ToggleState) when Index>Max->
+    ToggleState;
+toggle_children(Index,Max,Depth,ToggleState) ->
+    case ets:lookup(cdv_menu_table,Index+1) of
+	[#menu_item{depth=Depth}=Child] ->
+	    NewState =  not Child#menu_item.state,
+	    ets:insert(cdv_menu_table,Child#menu_item{state=NewState}),
+	    toggle_children(Index+1,Max,Depth,NewState);
+	_ ->
+	    toggle_children(Index+1,Max,Depth,ToggleState)
+    end.
+
+%%%-----------------------------------------------------------------
+%%% Traverse crash dump and insert index in table for each heading
+%%% 
+%%% This function is executed in a background process in order to
+%%% avoid a timeout in the web browser. The browser displays "Please
+%%% wait..." while this is going on.
+%%%
+%%% Variable written to process dictionary in this function are copied
+%%% to the crashdump_viewer_server when the function is completed (see
+%%% background_done/1).
+read_file(File) ->
+    case file:read_file_info(File) of
+	{ok,#file_info{type=regular,access=FileA}} when FileA=:=read;
+							FileA=:=read_write ->
+	    Fd = open(File),
+	    case read(Fd) of
+		{ok,<<$=:8,TagAndRest/binary>>} ->
+		    {Tag,Id,Rest,N1} = tag(Fd,TagAndRest,1),
+		    case Tag of
+			"=erl_crash_dump" ->
+			    ets:delete_all_objects(cdv_dump_index_table),
+			    ets:insert(cdv_dump_index_table,{Tag,Id,N1+1}),
+			    put(last_tag,{Tag,""}),
+			    Status = background_status(processing,File),
+			    background_status(Status),
+			    indexify(Fd,Rest,N1),
+			    check_if_truncated(),
+			    initial_menu(),
+			    Binaries = read_binaries(Fd),
+			    R = crashdump_viewer_html:start_page(),
+			    close(Fd),
+			    background_done({R,File,Binaries});
+			_Other ->
+			    R = crashdump_viewer_html:error(
+				  "~s is not an Erlang crash dump~n",
+				  [File]),
+			    close(Fd),
+			    background_done({R,undefined,undefined})
+		    end;
+		{ok,<<"<Erlang crash dump>",_Rest/binary>>} -> 
+		    %% old version - no longer supported
+		    R = crashdump_viewer_html:error(
+			  "The crashdump ~s is in the pre-R10B format, "
+			  "which is no longer supported.~n",
+			  [File]),
+		    close(Fd),
+		    background_done({R,undefined,undefined});
+		_Other ->
+		    R = crashdump_viewer_html:error(
+			  "~s is not an Erlang crash dump~n",
+			  [File]),
+		    close(Fd),
+		    background_done({R,undefined,undefined})
+	    end;
+	_other ->
+	    R = crashdump_viewer_html:error("~s is not an Erlang crash dump~n",
+					    [File]),
+	    background_done({R,undefined,undefined})
+    end.
+
+indexify(Fd,<<"\n=",TagAndRest/binary>>,N) ->
+    {Tag,Id,Rest,N1} = tag(Fd,TagAndRest,N+2),
+    ets:insert(cdv_dump_index_table,{Tag,Id,N1+1}), % +1 to get past newline
+    put(last_tag,{Tag,Id}),
+    indexify(Fd,Rest,N1);
+indexify(Fd,<<>>,N) ->
+    case read(Fd) of
+	{ok,Chunk} when is_binary(Chunk) ->
+	    indexify(Fd,Chunk,N);
+        eof ->
+	    eof
+    end;
+indexify(Fd,<<$\n>>,N) ->
+    %% This clause is needed in case the chunk ends with a newline and
+    %% the next chunk starts with a tag (i.e. "\n=....")
+    case read(Fd) of
+	{ok,Chunk} when is_binary(Chunk) ->
+	    indexify(Fd,<<$\n,Chunk/binary>>,N);
+        eof ->
+	    eof
+    end;
+indexify(Fd,<<_Char:8,Rest/binary>>,N) ->
+    indexify(Fd,Rest,N+1).
+
+tag(Fd,Bin,N) ->
+    tag(Fd,Bin,N,[],[],tag).
+tag(_Fd,<<$\n:8,_/binary>>=Rest,N,Gat,Di,_Now) ->
+    {[$=|lists:reverse(Gat)],lists:reverse(Di),Rest,N};
+tag(Fd,<<$\r:8,Rest/binary>>,N,Gat,Di,Now) ->
+    tag(Fd,Rest,N+1,Gat,Di,Now);
+tag(Fd,<<$::8,IdAndRest/binary>>,N,Gat,Di,tag) ->
+    tag(Fd,IdAndRest,N+1,Gat,Di,id);
+tag(Fd,<<Char:8,Rest/binary>>,N,Gat,Di,tag) ->
+    tag(Fd,Rest,N+1,[Char|Gat],Di,tag);
+tag(Fd,<<Char:8,Rest/binary>>,N,Gat,Di,id) ->
+    tag(Fd,Rest,N+1,Gat,[Char|Di],id);
+tag(Fd,<<>>,N,Gat,Di,Now) ->
+    case read(Fd) of
+	{ok,Chunk} when is_binary(Chunk) ->
+	    tag(Fd,Chunk,N,Gat,Di,Now);
+        eof ->
+	    {[$=|lists:reverse(Gat)],lists:reverse(Di),<<>>,N}
+    end.
+
+check_if_truncated() ->
+    case get(last_tag) of
+	{"=end",_} ->
+	    put(truncated,false),
+	    put(truncated_proc,false);
+	TruncatedTag ->
+	    put(truncated,true),
+	    find_truncated_proc(TruncatedTag)
+    end.
+	    
+find_truncated_proc({"=atom",_Id}) ->
+    put(truncated_proc,false);
+find_truncated_proc({Tag,Pid}) ->
+    case is_proc_tag(Tag) of
+	true -> 
+	    put(truncated_proc,Pid);
+	false -> 
+	    %% This means that the dump is truncated between "=proc" and
+	    %% "=proc_heap" => memory info is missing for all procs.
+	    put(truncated_proc,"<0.0.0>")
+    end.
+
+is_proc_tag(Tag)  when Tag=="=proc";
+		       Tag=="=proc_dictionary";
+		       Tag=="=proc_messages";
+		       Tag=="=proc_dictionary";
+		       Tag=="=debug_proc_dictionary";
+		       Tag=="=proc_stack";
+		       Tag=="=proc_heap" ->
+    true;
+is_proc_tag(_) ->
+    false.
+
+related_tags("Atoms") ->
+    ["=atoms","=num_atoms"].
+
+%%% Inform the crashdump_viewer_server that a background job is completed.
+background_done(Result) ->
+    Dict = get(),
+    cast({background_done,Result,Dict}).    
+
+background_status(Status) ->
+    cast({background_status,Status}).
+
+%%%-----------------------------------------------------------------
+%%% Functions for reading information from the dump
+general_info(File) ->
+    [{"=erl_crash_dump",_Id,Start}] = 
+	ets:lookup(cdv_dump_index_table,"=erl_crash_dump"),
+    Fd = open(File),
+    pos_bof(Fd,Start),
+    Created = case get_rest_of_line(Fd) of
+		  {eof,SomeOfLine} -> SomeOfLine;
+		  WholeLine -> WholeLine
+	      end,
+
+    GI0 = get_general_info(Fd,#general_info{created=Created,_=?space}),
+    GI = case GI0#general_info.num_atoms of
+	    ?space -> GI0#general_info{num_atoms=get_num_atoms(Fd)};
+	    _ -> GI0
+	end,
+
+    {MemTot,MemMax} = 
+	case ets:lookup(cdv_dump_index_table,"=memory") of
+	    [{"=memory",_,MemStart}] ->
+		pos_bof(Fd,MemStart),
+		Memory = get_meminfo(Fd,[]),
+		Tot = case lists:keysearch("total",1,Memory) of
+			  {value,{_,T}} -> T;
+			  false -> ""
+		      end,
+		Max = case lists:keysearch("maximum",1,Memory) of
+			  {value,{_,M}} -> M;
+			  false -> ""
+		      end,
+		{Tot,Max};
+	    _ ->
+		{"",""}
+	end,
+
+    close(Fd),
+    {NumProcs,NumEts,NumFuns} = count(),
+    NodeName = 
+	case ets:lookup(cdv_dump_index_table,"=node") of
+	    [{"=node",N,_Start}] ->
+		N;
+	    [] ->
+		case ets:lookup(cdv_dump_index_table,"=no_distribution") of
+		    [_] -> "nonode@nohost";
+		    [] -> "unknown"
+		end
+	end,
+
+    InstrInfo =
+	case ets:member(cdv_dump_index_table,"=old_instr_data") of
+	    true ->
+		old_instr_data;
+	    false ->
+		case ets:member(cdv_dump_index_table,"=instr_data") of
+		    true ->
+			instr_data;
+		    false ->
+			false
+		end
+	end,
+    GI#general_info{node_name=NodeName,
+		    num_procs=integer_to_list(NumProcs),
+		    num_ets=integer_to_list(NumEts),
+		    num_fun=integer_to_list(NumFuns),
+		    mem_tot=MemTot,
+		    mem_max=MemMax,
+		    instr_info=InstrInfo}.
+
+get_general_info(Fd,GenInfo) ->
+    case line_head(Fd) of
+	"Slogan" ->
+	    get_general_info(Fd,GenInfo#general_info{slogan=val(Fd)});
+	"System version" ->
+	    get_general_info(Fd,GenInfo#general_info{system_vsn=val(Fd)});
+	"Compiled" ->
+	    get_general_info(Fd,GenInfo#general_info{compile_time=val(Fd)});
+	"Atoms" ->
+	    get_general_info(Fd,GenInfo#general_info{num_atoms=val(Fd)});
+	"=" ++ _next_tag ->
+	    GenInfo;
+	Other ->
+	    unexpected(Fd,Other,"general information"),
+	    GenInfo
+    end.
+
+get_num_atoms(Fd) ->
+    case ets:match(cdv_dump_index_table,{"=hash_table","atom_tab",'$1'}) of
+	[[Pos]] -> 
+	    pos_bof(Fd,Pos),
+	    skip_rest_of_line(Fd), % size
+	    skip_rest_of_line(Fd), % used
+	    case line_head(Fd) of
+		"objs" ->
+		    val(Fd);
+		_1 ->
+		    get_num_atoms2()
+	    end;
+	[] ->
+	    get_num_atoms2()
+    end.
+get_num_atoms2() ->
+    case ets:lookup(cdv_dump_index_table,"=num_atoms") of
+	[] -> 
+	    ?space;
+	[{"=num_atoms",NA,_Pos}] -> 
+	    %% If dump is translated this will exist
+	    case get(truncated) of
+		true ->
+		    [NA," (visible in dump)"]; % might be more
+		false ->
+		    NA
+	    end
+    end.
+
+count() ->
+    {ets:select_count(cdv_dump_index_table,count_ms("=proc")),
+     ets:select_count(cdv_dump_index_table,count_ms("=ets")),
+     ets:select_count(cdv_dump_index_table,count_ms("=fun"))}.
+
+count_ms(Tag) ->
+    [{{Tag,'_','_'},[],[true]}].
+
+
+procs_summary(File) ->
+    AllProcs = ets:lookup(cdv_dump_index_table,"=proc"),
+    Fd = open(File),
+    R = lists:map(fun({"=proc",Pid,Start}) -> 
+			  pos_bof(Fd,Start),
+			  get_procinfo(Fd,fun main_procinfo/4,
+				       ?initial_proc_record(Pid))
+		  end, 
+		  AllProcs),
+    close(Fd),
+    R.
+
+get_proc_details(File,Pid) ->
+    DumpVsn = ets:lookup_element(cdv_dump_index_table,"=erl_crash_dump",2),
+    case ets:match(cdv_dump_index_table,{"=proc",Pid,'$1'}) of
+	[[Start]] ->
+	    Fd = open(File),
+	    pos_bof(Fd,Start),
+	    Proc0 = 
+		case DumpVsn of
+		    "0.0" -> 
+			%% Old version (translated)
+			?initial_proc_record(Pid);
+		    _ ->
+			(?initial_proc_record(Pid))#proc{
+			  stack_dump=if_exist("=proc_stack",Pid),
+			  msg_q=if_exist("=proc_messages",Pid),
+			  dict=if_exist("=proc_dictionary",Pid),
+			  debug_dict=if_exist("=debug_proc_dictionary",Pid)}
+		end,
+	    Proc = get_procinfo(Fd,fun all_procinfo/4,Proc0),
+	    close(Fd),
+	    {ok,Proc};
+	_ ->
+	    case maybe_other_node(File,Pid) of
+		{other_node,Type,Node} -> 
+		    Info = "The process you are searching for was residing on "
+			"a remote node. No process information is available. "
+			"Information about the remote node is show below.",
+		    {other_node,{Type,Info,Node}};
+		not_found ->
+		    not_found
+	    end
+    end.
+
+if_exist(Tag,Key) ->
+    case ets:select_count(cdv_dump_index_table,[{{Tag,Key,'_'},[],[true]}]) of
+	0 -> 
+	    Tag1 = 
+		case is_proc_tag(Tag) of
+		    true -> "=proc";
+		    false -> Tag
+		end,
+	    case truncated_here({Tag1,Key}) of
+		true -> truncated;
+		false -> ?space
+	    end;
+	_ -> 
+	    expand
+    end.
+
+get_procinfo(Fd,Fun,Proc) ->
+    case line_head(Fd) of
+	"State" ->
+	    State = case val(Fd) of
+			"Garbing" -> "Garbing\n(limited info)";
+			State0 -> State0
+		    end,
+	    get_procinfo(Fd,Fun,Proc#proc{state=State});
+	"Name" ->
+	    get_procinfo(Fd,Fun,Proc#proc{name=val(Fd)});
+	"Spawned as" ->
+	    IF = val(Fd),
+	    case Proc#proc.name of
+		?space ->
+		    get_procinfo(Fd,Fun,Proc#proc{name=IF,init_func=IF});
+		_ ->
+		    get_procinfo(Fd,Fun,Proc#proc{init_func=IF})
+	    end;
+	"Spawned by" ->
+	    case val(Fd) of
+		"[]" ->
+		    get_procinfo(Fd,Fun,Proc);
+		Parent ->
+		    get_procinfo(Fd,Fun,Proc#proc{parent=Parent})
+	    end;
+	"Started" ->
+	    get_procinfo(Fd,Fun,Proc#proc{start_time=val(Fd)});
+	"Last scheduled in for" ->
+	    get_procinfo(Fd,Fun,Proc#proc{current_func=
+					  {"Last scheduled in for",
+					   val(Fd)}});
+	"Current call" ->
+	    get_procinfo(Fd,Fun,Proc#proc{current_func={"Current call",
+							val(Fd)}});
+	"Message queue length" -> 
+	    %% stored as integer so we can sort on it
+	    get_procinfo(Fd,Fun,Proc#proc{msg_q_len=list_to_integer(val(Fd))});
+	"Reductions" ->
+	    %% stored as integer so we can sort on it
+	    get_procinfo(Fd,Fun,Proc#proc{reds=list_to_integer(val(Fd))});
+	"Number of heap fragments" ->
+	    get_procinfo(Fd,Fun,Proc#proc{num_heap_frag=val(Fd)});
+	"Heap fragment data" ->
+	    get_procinfo(Fd,Fun,Proc#proc{heap_frag_data=val(Fd)});
+	Stack when Stack=:="Stack+heap"; Stack=:="Stack" ->
+	    %% stored as integer so we can sort on it
+	    get_procinfo(Fd,Fun,Proc#proc{stack_heap=
+					  list_to_integer(val(Fd))});
+	"OldHeap" ->
+	    get_procinfo(Fd,Fun,Proc#proc{old_heap=val(Fd)});
+	"Heap unused" ->
+	    get_procinfo(Fd,Fun,Proc#proc{heap_unused=val(Fd)});
+	"OldHeap unused" ->
+	    get_procinfo(Fd,Fun,Proc#proc{old_heap_unused=val(Fd)});
+	"New heap start" ->
+	    get_procinfo(Fd,Fun,Proc#proc{new_heap_start=val(Fd)});
+	"New heap top" ->
+	    get_procinfo(Fd,Fun,Proc#proc{new_heap_top=val(Fd)});
+	"Stack top" ->
+	    get_procinfo(Fd,Fun,Proc#proc{stack_top=val(Fd)});
+	"Stack end" ->
+	    get_procinfo(Fd,Fun,Proc#proc{stack_end=val(Fd)});
+	"Old heap start" ->
+	    get_procinfo(Fd,Fun,Proc#proc{old_heap_start=val(Fd)});
+	"Old heap top" ->
+	    get_procinfo(Fd,Fun,Proc#proc{old_heap_top=val(Fd)});
+	"Old heap end" ->
+	    get_procinfo(Fd,Fun,Proc#proc{old_heap_end=val(Fd)});
+	{eof,_} ->
+	    Proc; % truncated file
+	Other ->
+	    Fun(Fd,Fun,Proc,Other)
+    end.
+
+main_procinfo(Fd,Fun,Proc,LineHead) ->
+    case LineHead of
+	"Stack dump" ->
+	    %% This is the last element in older dumps (DumpVsn=0.0)
+	    Proc;
+	"=" ++ _next_tag ->
+	    %% DumpVsn=0.1 or newer: No stack dump here
+	    Proc;
+	"arity = " ++ _ ->
+	    %%! Temporary workaround
+	    get_procinfo(Fd,Fun,Proc);	
+	_Other ->
+	    skip_rest_of_line(Fd),
+	    get_procinfo(Fd,Fun,Proc)
+    end.
+all_procinfo(Fd,Fun,Proc,LineHead) ->
+    case LineHead of
+	"Message queue" -> 
+	    get_procinfo(Fd,Fun,Proc#proc{msg_q=size_or_term(Fd)});
+	"Last calls" ->
+	    R = case size_or_term(Fd) of
+		    SizeThing when is_tuple(SizeThing) ->
+			Proc#proc{last_calls=SizeThing};
+		    Term ->
+			Proc#proc{last_calls=replace_all($ ,$\n,Term,[])}
+		end,
+	    get_procinfo(Fd,Fun,R);
+	"Link list" ->
+	    get_procinfo(Fd,Fun,Proc#proc{links=val(Fd)});
+	"Program counter" ->
+	    get_procinfo(Fd,Fun,Proc#proc{prog_count=val(Fd)});
+	"CP" ->
+	    get_procinfo(Fd,Fun,Proc#proc{cp=val(Fd)});
+	"arity = " ++ Arity ->
+	    %%! Temporary workaround
+	    get_procinfo(Fd,Fun,Proc#proc{arity=Arity--"\r\n"});
+	"Dictionary" ->
+	    get_procinfo(Fd,Fun,Proc#proc{dict=size_or_term(Fd)});
+	"$Dictionary" ->
+	    get_procinfo(Fd,Fun,Proc#proc{debug_dict=size_or_term(Fd)});
+	"Stack dump" ->
+	    %% This is the last element in older dumps (DumpVsn=0.0)
+	    get_stack_dump(Fd,Proc);
+	"=" ++ _next_tag ->
+	    %% DumpVsn=0.1 or newer: No stack dump here
+	    Proc;
+	Other ->
+	    unexpected(Fd,Other,"process info"),
+	    get_procinfo(Fd,Fun,Proc)
+    end.
+
+get_stack_dump(Fd,Proc) ->
+    %% Always show stackdump as "Expand" link
+    Pos = get(pos),
+    Size = count_rest_of_tag(Fd),
+    Proc#proc{stack_dump={size,true,Size,Pos}}.
+
+maybe_other_node(File,Id) ->
+    Channel = 
+	case split($.,Id) of
+	    {"<" ++ N, _Rest} ->
+		N;
+	    {"#Port<" ++ N, _Rest} ->
+		N
+	end,
+    Ms = ets:fun2ms(
+	   fun({Tag,Id,Start}) when Tag=:="=visible_node", Id=:=Channel -> 
+		   {"Visible Node",Start};
+	      ({Tag,Id,Start}) when Tag=:="=hidden_node", Id=:=Channel ->
+		   {"Hidden Node",Start};
+	      ({Tag,Id,Start}) when Tag=:="=not_connected", Id=:=Channel -> 
+		   {"Not Connected Node",Start}
+	   end),
+    case ets:select(cdv_dump_index_table,Ms) of
+	[] -> 
+	    not_found;
+	[{Type,Pos}] -> 
+	    Fd = open(File),
+	    NodeInfo = get_nodeinfo(Fd,Channel,Pos),
+	    close(Fd),
+	    {other_node,Type,NodeInfo}
+    end.
+
+expand_memory(File,What,Pid,Binaries) ->
+    Fd = open(File),
+    put(fd,Fd),
+    Dict = read_heap(Fd,Pid,Binaries),
+    Expanded = 
+	case What of
+	    "StackDump" -> read_stack_dump(Fd,Pid,Dict);
+	    "MsgQueue" -> read_messages(Fd,Pid,Dict);
+	    "Dictionary" -> read_dictionary(Fd,"=proc_dictionary",Pid,Dict);
+	    "DebugDictionary" -> read_dictionary(Fd,"=debug_proc_dictionary",Pid,Dict)
+	end,
+    erase(fd),
+    close(Fd),
+    Expanded.
+    
+%%%
+%%% Read binaries.
+%%%
+read_binaries(Fd) ->
+    AllBinaries = ets:match(cdv_dump_index_table,{"=binary",'$1','$2'}),
+    read_binaries(Fd,AllBinaries, gb_trees:empty()).
+
+read_binaries(Fd,[[Addr0,Pos]|Bins],Dict0) ->
+    pos_bof(Fd,Pos),
+    {Addr,_} = get_hex(Addr0),
+    Dict = 
+	case line_head(Fd) of
+	    {eof,_} ->
+		gb_trees:enter(Addr,'#CDVTruncatedBinary',Dict0);
+	    Size0 ->
+		{Size,_} = get_hex(Size0),
+		if Size > ?max_display_binary_size ->
+			gb_trees:enter(Addr,{'#CDVTooBig',binary,Pos},Dict0);
+		   true ->
+			pos_bof(Fd,Pos),
+			Line = val(Fd),
+			parse_binary(Addr,Line,Dict0)
+		end
+	end,
+    read_binaries(Fd,Bins,Dict);
+read_binaries(_Fd,[],Dict) ->
+    Dict.
+
+parse_binary(Addr, Line0, Dict) ->
+    case get_hex(Line0) of
+	{N,":"++Line1} ->
+	    {Bin,Line} = get_binary(N, Line1, []),
+	    [] = skip_blanks(Line),
+	    gb_trees:enter(Addr, Bin, Dict);
+	{_N,[]} ->
+	    %% If the dump is truncated before the ':' in this line, then
+	    %% line_head/1 might not discover it (if a \n has been inserted
+	    %% somehow???)
+	    gb_trees:enter(Addr,'#CDVTruncatedBinary',Dict)
+    end.
+
+
+
+%%%
+%%% Read top level section.
+%%%
+
+read_stack_dump(Fd,Pid,Dict) ->
+    case ets:match(cdv_dump_index_table,{"=proc_stack",Pid,'$1'}) of
+	[[Start]] ->
+	    pos_bof(Fd,Start),
+	    read_stack_dump1(Fd,Dict,[]);
+	[] ->
+	    []
+    end.
+read_stack_dump1(Fd,Dict,Acc) ->
+    %% This function is never called if the dump is truncated in "=proc_heap:Pid"
+    case val(Fd) of
+	"=" ++ _next_tag ->
+	    lists:reverse(Acc);
+	Line ->
+	    Stack = parse_top(Line,Dict),
+	    read_stack_dump1(Fd,Dict,[Stack|Acc])
+    end.
+
+parse_top(Line0, D) ->
+    {Label,Line1} = get_label(Line0),
+    {Term,Line,D} = parse_term(Line1, D),
+    [] = skip_blanks(Line),
+    {Label,Term}.
+
+%%%
+%%% Read message queue.
+%%%
+
+read_messages(Fd,Pid,Dict) ->
+    case ets:match(cdv_dump_index_table,{"=proc_messages",Pid,'$1'}) of
+	[[Start]] ->
+	    pos_bof(Fd,Start),
+	    read_messages1(Fd,Dict,[]);
+	[] ->
+	    []
+    end.
+read_messages1(Fd,Dict,Acc) ->
+    %% This function is never called if the dump is truncated in "=proc_heap:Pid"
+    case val(Fd) of
+	"=" ++ _next_tag ->
+	    lists:reverse(Acc);
+	Line ->
+	    Msg = parse_message(Line,Dict),
+	    read_messages1(Fd,Dict,[Msg|Acc])
+    end.
+    
+parse_message(Line0, D) ->
+    {Msg,":"++Line1,_} = parse_term(Line0, D),
+    {Token,Line,_} = parse_term(Line1, D),
+    [] = skip_blanks(Line),
+    {Msg,Token}.
+    
+%%%
+%%% Read process dictionary
+%%%
+
+read_dictionary(Fd,Tag,Pid,Dict) ->
+    case ets:match(cdv_dump_index_table,{Tag,Pid,'$1'}) of
+	[[Start]] ->
+	    pos_bof(Fd,Start),
+	    read_dictionary1(Fd,Dict,[]);
+	[] ->
+	    []
+    end.
+read_dictionary1(Fd,Dict,Acc) ->
+    %% This function is never called if the dump is truncated in "=proc_heap:Pid"
+    case val(Fd) of
+	"=" ++ _next_tag ->
+	    lists:reverse(Acc);
+	Line ->
+	    Msg = parse_dictionary(Line,Dict),
+	    read_dictionary1(Fd,Dict,[Msg|Acc])
+    end.
+    
+parse_dictionary(Line0, D) ->
+    {Entry,Line,_} = parse_term(Line0, D),
+    [] = skip_blanks(Line),
+    Entry.
+    
+%%%
+%%% Read heap data.
+%%%
+
+read_heap(Fd,Pid,Dict0) ->
+    case ets:match(cdv_dump_index_table,{"=proc_heap",Pid,'$2'}) of
+	[[Pos]] ->
+	    pos_bof(Fd,Pos),
+	    read_heap(Dict0);
+	[] ->
+	    Dict0
+    end.
+
+read_heap(Dict0) ->
+    %% This function is never called if the dump is truncated in "=proc_heap:Pid"
+    case get(fd) of
+	end_of_heap ->
+	    Dict0;
+	Fd ->
+	    case val(Fd) of
+		"=" ++ _next_tag ->
+		    put(fd, end_of_heap),
+		    Dict0;
+		Line ->
+		    Dict = parse(Line,Dict0),
+		    read_heap(Dict)
+	    end
+    end.
+
+parse(Line0, Dict0) ->
+    {Addr,":"++Line1} = get_hex(Line0),
+    {_Term,Line,Dict} = parse_heap_term(Line1, Addr, Dict0),
+    [] = skip_blanks(Line),
+    Dict.
+
+
+do_sort_procs("state",Procs,"state") ->
+    {lists:reverse(lists:keysort(#proc.state,Procs)),"rstate"};
+do_sort_procs("state",Procs,_) ->
+    {lists:keysort(#proc.state,Procs),"state"};
+do_sort_procs("pid",Procs,"pid") ->
+    {lists:reverse(Procs),"rpid"};
+do_sort_procs("pid",Procs,_) ->
+    {Procs,"pid"};
+do_sort_procs("msg_q_len",Procs,"msg_q_len") ->
+    {lists:keysort(#proc.msg_q_len,Procs),"rmsg_q_len"};
+do_sort_procs("msg_q_len",Procs,_) ->
+    {lists:reverse(lists:keysort(#proc.msg_q_len,Procs)),"msg_q_len"};
+do_sort_procs("reds",Procs,"reds") ->
+    {lists:keysort(#proc.reds,Procs),"rreds"};
+do_sort_procs("reds",Procs,_) ->
+    {lists:reverse(lists:keysort(#proc.reds,Procs)),"reds"};
+do_sort_procs("mem",Procs,"mem") ->
+    {lists:keysort(#proc.stack_heap,Procs),"rmem"};
+do_sort_procs("mem",Procs,_) ->
+    {lists:reverse(lists:keysort(#proc.stack_heap,Procs)),"mem"};
+do_sort_procs("init_func",Procs,"init_func") ->
+    {lists:reverse(lists:keysort(#proc.init_func,Procs)),"rinit_func"};
+do_sort_procs("init_func",Procs,_) ->
+    {lists:keysort(#proc.init_func,Procs),"init_func"};
+do_sort_procs("name_func",Procs,"name_func") ->
+    {lists:reverse(lists:keysort(#proc.name,Procs)),"rname_func"};
+do_sort_procs("name_func",Procs,_) ->
+    {lists:keysort(#proc.name,Procs),"name_func"};
+do_sort_procs("name",Procs,Sorted) ->
+    {No,Yes} = 
+	lists:foldl(fun(P,{N,Y}) ->
+			    case P#proc.name of
+				?space -> {[P|N],Y};
+				_other -> {N,[P|Y]}
+			    end
+		    end,
+		    {[],[]},
+		    Procs),
+    Result = lists:keysort(#proc.name,Yes) ++ No,
+    case Sorted of
+	"name" -> {lists:reverse(Result),"rname"};
+	_ -> {Result,"name"}
+    end.
+    
+
+get_port(File,Port) ->
+    case ets:match(cdv_dump_index_table,{"=port",Port,'$1'}) of
+	[[Start]] ->
+	    Fd = open(File),
+	    R = get_portinfo(Fd,Port,Start),
+	    close(Fd),
+	    {ok,R};
+	[] ->
+	    case maybe_other_node(File,Port) of
+		{other_node,Type,Node} -> 
+		    Info = "The port you are searching for was residing on "
+			"a remote node. No port information is available. "
+			"Information about the remote node is show below.",
+		    {other_node,{Type,Info,Node}};
+		not_found ->
+		    not_found
+	    end
+    end.
+
+get_ports(File) ->
+    Ports = ets:lookup(cdv_dump_index_table,"=port"),
+    Fd = open(File),
+    R = lists:map(fun({"=port",Id,Start}) -> get_portinfo(Fd,Id,Start) end, 
+		  Ports),
+    close(Fd),
+    R.
+
+
+get_portinfo(Fd,Id,Start) ->
+    pos_bof(Fd,Start),
+    get_portinfo(Fd,#port{id=Id,_=?space}).
+
+get_portinfo(Fd,Port) ->
+    case line_head(Fd) of
+	"Slot" ->
+	    get_portinfo(Fd,Port#port{slot=val(Fd)});
+	"Connected" ->
+	    get_portinfo(Fd,Port#port{connected=val(Fd)});
+	"Links" ->
+	    get_portinfo(Fd,Port#port{links=val(Fd)});
+	"Port controls linked-in driver" ->
+	    get_portinfo(Fd,Port#port{controls=["Linked in driver: " |
+						val(Fd)]});
+	"Port controls external process" ->
+	    get_portinfo(Fd,Port#port{controls=["External proc: " | val(Fd)]});
+	"Port is a file" ->
+	    get_portinfo(Fd,Port#port{controls=["File: "| val(Fd)]});
+	"Port is UNIX fd not opened by emulator" ->
+	    get_portinfo(Fd,Port#port{
+			      controls=["UNIX fd not opened by emulator: "| 
+					val(Fd)]});
+	"=" ++ _next_tag ->
+	    Port;
+	Other ->
+	    unexpected(Fd,Other,"port info"),
+	    Port
+    end.
+
+get_ets_tables(File,Pid,WS) ->
+    EtsTables = ets:match_object(cdv_dump_index_table,{"=ets",Pid,'_'}),
+    Fd = open(File),
+    R = lists:map(fun({"=ets",P,Start}) -> 
+			  get_etsinfo(Fd,P,Start,WS) 
+		  end, 
+		  EtsTables),
+    close(Fd),
+    R.
+
+get_internal_ets_tables(File,WS) ->
+    InternalEts = ets:match_object(cdv_dump_index_table,
+				   {"=internal_ets",'_','_'}),
+    Fd = open(File),
+    R = lists:map(fun({"=internal_ets",Descr,Start}) ->
+			  {Descr,get_etsinfo(Fd,undefined,Start,WS)}
+		  end,
+		  InternalEts),
+    close(Fd),
+    R.
+    
+get_etsinfo(Fd,Pid,Start,WS) ->
+    pos_bof(Fd,Start),
+    get_etsinfo(Fd,#ets_table{pid=Pid,type="hash",_=?space},WS).
+
+get_etsinfo(Fd,EtsTable,WS) ->
+    case line_head(Fd) of
+	"Slot" ->
+	    get_etsinfo(Fd,EtsTable#ets_table{slot=val(Fd)},WS);
+	"Table" ->
+	    get_etsinfo(Fd,EtsTable#ets_table{id=val(Fd)},WS);
+	"Name" ->
+	    get_etsinfo(Fd,EtsTable#ets_table{name=val(Fd)},WS);
+	"Ordered set (AVL tree), Elements" ->
+	    skip_rest_of_line(Fd),
+	    get_etsinfo(Fd,EtsTable#ets_table{type="tree",buckets="-"},WS);
+	"Buckets" ->
+	    get_etsinfo(Fd,EtsTable#ets_table{buckets=val(Fd)},WS);
+	"Objects" ->
+	    get_etsinfo(Fd,EtsTable#ets_table{size=val(Fd)},WS);
+	"Words" ->
+	    Words = list_to_integer(val(Fd)),
+	    Bytes = 
+		case Words of
+		    -1 -> "-1"; % probably truncated
+		    _ -> integer_to_list(Words * WS)
+		end,
+	    get_etsinfo(Fd,EtsTable#ets_table{memory=Bytes},WS);
+	"=" ++ _next_tag ->
+	    EtsTable;
+	Other ->
+	    unexpected(Fd,Other,"ETS info"),
+	    EtsTable
+    end.
+
+get_timers(File,Pid) ->
+    Timers = ets:match_object(cdv_dump_index_table,{"=timer",Pid,'$1'}),
+    Fd = open(File),
+    R = lists:map(fun({"=timer",P,Start}) -> 
+			  get_timerinfo(Fd,P,Start) 
+		  end, 
+		  Timers),
+    close(Fd),
+    R.
+
+get_timerinfo(Fd,Pid,Start) ->
+    pos_bof(Fd,Start),
+    get_timerinfo(Fd,#timer{pid=Pid,_=?space}).
+
+get_timerinfo(Fd,Timer) ->
+    case line_head(Fd) of
+	"Message" ->
+	    get_timerinfo(Fd,Timer#timer{msg=val(Fd)});
+	"Time left" ->
+	    get_timerinfo(Fd,Timer#timer{time=val(Fd)});
+	"=" ++ _next_tag ->
+	    Timer;
+	Other ->
+	    unexpected(Fd,Other,"timer info"),
+	    Timer
+    end.
+
+nods(File) ->
+    case ets:lookup(cdv_dump_index_table,"=no_distribution") of
+	[] ->
+	    V = ets:lookup(cdv_dump_index_table,"=visible_node"),
+	    H = ets:lookup(cdv_dump_index_table,"=hidden_node"),
+	    N = ets:lookup(cdv_dump_index_table,"=not_connected"),
+	    Fd = open(File),
+	    Visible = lists:map(
+			fun({"=visible_node",Channel,Start}) -> 
+				get_nodeinfo(Fd,Channel,Start)
+			end, 
+			V),
+	    Hidden = lists:map(
+		       fun({"=hidden_node",Channel,Start}) -> 
+			       get_nodeinfo(Fd,Channel,Start)
+		       end, 
+		       H),
+	    NotConnected = lists:map(
+			     fun({"=not_connected",Channel,Start}) -> 
+				     get_nodeinfo(Fd,Channel,Start)
+			     end, 
+			     N),
+	    close(Fd),
+	    {Visible,Hidden,NotConnected};
+	[_] ->
+	    no_distribution
+    end.
+
+get_nodeinfo(Fd,Channel,Start) ->
+    pos_bof(Fd,Start),
+    get_nodeinfo(Fd,#nod{channel=Channel,_=?space}).
+
+get_nodeinfo(Fd,Nod) ->
+    case line_head(Fd) of
+	"Name" ->
+	    get_nodeinfo(Fd,Nod#nod{name=val(Fd)});
+	"Controller" ->
+	    get_nodeinfo(Fd,Nod#nod{controller=val(Fd)});
+	"Creation" ->
+	    get_nodeinfo(Fd,Nod#nod{creation=val(Fd)});
+	"Remote link" ->
+	    Procs = val(Fd), % e.g. "<0.31.0> <4322.54.0>"
+	    RemoteLinks = Nod#nod.remote_links,
+	    get_nodeinfo(Fd,Nod#nod{remote_links=[split(Procs)|RemoteLinks]});
+	"Remote monitoring" ->
+	    Procs = val(Fd), % e.g. "<0.31.0> <4322.54.0>"
+	    RemoteMon = Nod#nod.remote_mon,
+	    get_nodeinfo(Fd,Nod#nod{remote_mon=[split(Procs)|RemoteMon]});
+	"Remotely monitored by" ->
+	    Procs = val(Fd), % e.g. "<0.31.0> <4322.54.0>"
+	    RemoteMonBy = Nod#nod.remote_mon_by,
+	    get_nodeinfo(Fd,Nod#nod{remote_mon_by=[split(Procs)|RemoteMonBy]});
+	"Error" ->
+	    get_nodeinfo(Fd,Nod#nod{error=val(Fd)});	    
+	"=" ++ _next_tag ->
+	    Nod;
+	Other ->
+	    unexpected(Fd,Other,"node info"),
+	    Nod
+    end.
+
+loaded_mods(File) ->
+    case ets:lookup(cdv_dump_index_table,"=loaded_modules") of
+	[{"=loaded_modules",_,StartTotal}] ->
+	    Fd = open(File),
+	    pos_bof(Fd,StartTotal),
+	    {CC,OC} = get_loaded_mod_totals(Fd,{"unknown","unknown"}),
+	    
+	    Mods = ets:lookup(cdv_dump_index_table,"=mod"),
+	    LM = lists:map(fun({"=mod",M,Start}) -> 
+				   pos_bof(Fd,Start),
+				   InitLM = #loaded_mod{mod=M,_=?space},
+				   get_loaded_mod_info(Fd,InitLM,
+						       fun main_modinfo/3)
+			   end, 
+			   Mods),
+	    close(Fd),
+	    {CC,OC,LM};
+	[] ->
+	    {"unknown","unknown",[]}
+    end.
+
+get_loaded_mod_totals(Fd,{CC,OC}) ->
+    case line_head(Fd) of
+	"Current code" ->
+	    get_loaded_mod_totals(Fd,{val(Fd),OC});
+	"Old code" ->
+	    get_loaded_mod_totals(Fd,{CC,val(Fd)});
+	"=" ++ _next_tag ->
+	    {CC,OC};
+	Other ->
+	    unexpected(Fd,Other,"loaded modules info"),
+	    {CC,OC} % truncated file
+    end.
+
+get_loaded_mod_details(File,Mod) ->
+    [[Start]] = ets:match(cdv_dump_index_table,{"=mod",Mod,'$1'}),
+    Fd = open(File),
+    pos_bof(Fd,Start),
+    InitLM = #loaded_mod{mod=Mod,old_size="No old code exists",
+			 _="No information available"},
+    ModInfo = get_loaded_mod_info(Fd,InitLM,fun all_modinfo/3),
+    close(Fd),
+    ModInfo.
+
+get_loaded_mod_info(Fd,LM,Fun) ->
+    case line_head(Fd) of
+	"Current size" ->
+	    get_loaded_mod_info(Fd,LM#loaded_mod{current_size=val(Fd)},Fun);
+	"Old size" ->
+	    get_loaded_mod_info(Fd,LM#loaded_mod{old_size=val(Fd)},Fun);
+	"=" ++ _next_tag ->
+	    LM;
+	{eof,_} ->
+	    LM; % truncated file
+	Other ->
+	    LM1 = Fun(Fd,LM,Other),
+	    get_loaded_mod_info(Fd,LM1,Fun)
+    end.
+
+main_modinfo(_Fd,LM,_LineHead) ->
+    LM.
+all_modinfo(Fd,LM,LineHead) ->
+    case LineHead of
+	"Current attributes" ->
+	    Str = hex_to_str(val(Fd)),
+	    LM#loaded_mod{current_attrib=Str};
+	"Current compilation info" ->
+	    Str = hex_to_str(val(Fd)),
+	    LM#loaded_mod{current_comp_info=Str};
+	"Old attributes" ->
+	    Str = hex_to_str(val(Fd)),
+	    LM#loaded_mod{old_attrib=Str};
+	"Old compilation info" ->
+	    Str = hex_to_str(val(Fd)),
+	    LM#loaded_mod{old_comp_info=Str};
+	Other ->
+	    unexpected(Fd,Other,"loaded modules info"),
+	    LM
+    end.
+    
+
+hex_to_str(Hex) ->
+    Term = hex_to_term(Hex,[]),
+    io_lib:format("~p~n",[Term]).
+
+hex_to_term([X,Y|Hex],Acc) ->
+    MS = hex_to_dec([X]),
+    LS = hex_to_dec([Y]),
+    Z = 16*MS+LS,
+    hex_to_term(Hex,[Z|Acc]);
+hex_to_term([],Acc) ->
+    Bin = list_to_binary(lists:reverse(Acc)),
+    case catch binary_to_term(Bin) of
+	{'EXIT',_Reason} ->
+	    {"WARNING: The term is probably truncated!",
+	     "I can not do binary_to_term.",
+	     Bin};
+	Term ->
+	    Term
+    end.
+
+hex_to_dec("F") -> 15;
+hex_to_dec("E") -> 14;
+hex_to_dec("D") -> 13;
+hex_to_dec("C") -> 12;
+hex_to_dec("B") -> 11;
+hex_to_dec("A") -> 10;
+hex_to_dec(N) -> list_to_integer(N).
+    
+
+
+funs(File) ->
+    case ets:lookup(cdv_dump_index_table,"=fun") of
+	[] ->
+	    [];
+	AllFuns ->
+	    Fd = open(File),
+	    R = lists:map(fun({"=fun",_,Start}) -> 
+				  get_funinfo(Fd,Start) 
+			  end, 
+			  AllFuns),
+	    close(Fd),
+	    R
+    end.
+
+get_funinfo(Fd,Start) ->
+    pos_bof(Fd,Start),
+    get_funinfo1(Fd,#fu{_=?space}).
+
+get_funinfo1(Fd,Fu) ->
+    case line_head(Fd) of
+	"Module" ->
+	    get_funinfo1(Fd,Fu#fu{module=val(Fd)});
+	"Uniq" ->
+	    get_funinfo1(Fd,Fu#fu{uniq=val(Fd)});
+	"Index" ->
+	    get_funinfo1(Fd,Fu#fu{index=val(Fd)});
+	"Address" ->
+	    get_funinfo1(Fd,Fu#fu{address=val(Fd)});
+	"Native_address" ->
+	    get_funinfo1(Fd,Fu#fu{native_address=val(Fd)});
+	"Refc" ->
+	    get_funinfo1(Fd,Fu#fu{refc=val(Fd)});
+	"=" ++ _next_tag ->
+	    Fu;
+	Other ->
+	    unexpected(Fd,Other,"fun info"),
+	    Fu
+    end.
+
+atoms(File) ->
+    case ets:lookup(cdv_dump_index_table,"=atoms") of
+	[{_atoms,_Id,Start}] ->
+	    Fd = open(File),
+	    pos_bof(Fd,Start),
+	    R = case get_n_lines_of_tag(Fd,100) of
+		    {all,N,Lines} ->
+			{n_lines,1,N,"Atoms",Lines};
+		    {part,100,Lines} ->
+			{n_lines,1,100,"Atoms",Lines,get(pos)};
+		    empty ->
+			[]
+		end,
+	    close(Fd),
+	    R;
+	_ ->
+	    []
+    end.
+
+memory(File) ->
+    case ets:lookup(cdv_dump_index_table,"=memory") of
+	[{"=memory",_,Start}] ->
+	    Fd = open(File),
+	    pos_bof(Fd,Start),
+	    R = get_meminfo(Fd,[]),
+	    close(Fd),
+	    R;
+	_ ->
+	    []
+    end.
+
+get_meminfo(Fd,Acc) ->
+    case line_head(Fd) of
+	"=" ++ _next_tag ->
+	    lists:reverse(Acc);
+	{eof,_last_line} ->
+	    lists:reverse(Acc);
+	Key ->
+	    get_meminfo(Fd,[{Key,val(Fd)}|Acc])
+    end.
+	    
+allocated_areas(File) ->
+    case ets:lookup(cdv_dump_index_table,"=allocated_areas") of
+	[{"=allocated_areas",_,Start}] ->
+	    Fd = open(File),
+	    pos_bof(Fd,Start),
+	    R = get_allocareainfo(Fd,[]),
+	    close(Fd),
+	    R;
+	_ ->
+	    []
+    end.
+
+get_allocareainfo(Fd,Acc) ->
+    case line_head(Fd) of
+	"=" ++ _next_tag ->
+	    lists:reverse(Acc);
+	{eof,_last_line} ->
+	    lists:reverse(Acc);
+	Key ->
+	    Val = val(Fd),
+	    AllocInfo =
+		case split(Val) of
+		    {Alloc,[]} ->
+			{Key,Alloc,?space};
+		    {Alloc,Used} ->
+			{Key,Alloc,Used}
+		end,
+	    get_allocareainfo(Fd,[AllocInfo|Acc])
+    end.
+	    
+allocator_info(File) ->
+    case ets:lookup(cdv_dump_index_table,"=allocator") of
+	[] ->
+	    [];
+	AllAllocators ->
+	    Fd = open(File),
+	    R = lists:map(fun({"=allocator",Heading,Start}) -> 
+				  {Heading,get_allocatorinfo(Fd,Start)} 
+			  end, 
+			  AllAllocators),
+	    close(Fd),
+	    R
+    end.
+
+get_allocatorinfo(Fd,Start) ->
+    pos_bof(Fd,Start),
+    get_allocatorinfo1(Fd,[]).
+
+get_allocatorinfo1(Fd,Acc) ->
+    case line_head(Fd) of
+	"=" ++ _next_tag ->
+	    lists:reverse(Acc);
+	{eof,_last_line} ->
+	    lists:reverse(Acc);
+	Key ->
+	    Values = get_all_vals(val(Fd),[]),
+	    get_allocatorinfo1(Fd,[{Key,Values}|Acc])
+    end.
+	    
+get_all_vals([$ |Rest],Acc) ->
+    [lists:reverse(Acc)|get_all_vals(Rest,[])];
+get_all_vals([],Acc) ->
+    [lists:reverse(Acc)];
+get_all_vals([Char|Rest],Acc) ->
+    get_all_vals(Rest,[Char|Acc]).
+
+
+hash_tables(File) ->
+    case ets:lookup(cdv_dump_index_table,"=hash_table") of
+	[] ->
+	    [];
+	AllHashTables ->
+	    Fd = open(File),
+	    R = lists:map(fun({"=hash_table",Name,Start}) -> 
+				  get_hashtableinfo(Fd,Name,Start) 
+			  end, 
+			  AllHashTables),
+	    close(Fd),
+	    R
+    end.
+
+get_hashtableinfo(Fd,Name,Start) ->
+    pos_bof(Fd,Start),
+    get_hashtableinfo1(Fd,#hash_table{name=Name,_=?space}).
+
+get_hashtableinfo1(Fd,HashTable) ->
+    case line_head(Fd) of
+	"size" ->
+	    get_hashtableinfo1(Fd,HashTable#hash_table{size=val(Fd)});
+	"used" ->
+	    get_hashtableinfo1(Fd,HashTable#hash_table{used=val(Fd)});
+	"objs" ->
+	    get_hashtableinfo1(Fd,HashTable#hash_table{objs=val(Fd)});
+	"depth" ->
+	    get_hashtableinfo1(Fd,HashTable#hash_table{depth=val(Fd)});
+    	"=" ++ _next_tag ->
+	    HashTable;
+	Other ->
+	    unexpected(Fd,Other,"hash table information"),
+	    HashTable
+    end.
+
+index_tables(File) ->
+    case ets:lookup(cdv_dump_index_table,"=index_table") of
+	[] ->
+	    [];
+	AllIndexTables ->
+	    Fd = open(File),
+	    R = lists:map(fun({"=index_table",Name,Start}) -> 
+				  get_indextableinfo(Fd,Name,Start) 
+			  end, 
+			  AllIndexTables),
+	    close(Fd),
+	    R
+    end.
+
+get_indextableinfo(Fd,Name,Start) ->
+    pos_bof(Fd,Start),
+    get_indextableinfo1(Fd,#index_table{name=Name,_=?space}).
+
+get_indextableinfo1(Fd,IndexTable) ->
+    case line_head(Fd) of
+	"size" ->
+	    get_indextableinfo1(Fd,IndexTable#index_table{size=val(Fd)});
+	"used" ->
+	    get_indextableinfo1(Fd,IndexTable#index_table{used=val(Fd)});
+	"limit" ->
+	    get_indextableinfo1(Fd,IndexTable#index_table{limit=val(Fd)});
+	"rate" ->
+	    get_indextableinfo1(Fd,IndexTable#index_table{rate=val(Fd)});
+    	"=" ++ _next_tag ->
+	    IndexTable;
+	Other ->
+	    unexpected(Fd,Other,"index table information"),
+	    IndexTable
+    end.
+
+    
+
+
+
+get_expanded(File,Pos,Size) ->
+    Fd = open(File),
+    R = case file:pread(Fd,Pos,Size) of
+	    {ok,Bin}->
+		binary_to_list(Bin);
+	    eof ->
+		?space
+	end,
+    close(Fd),
+    R.
+
+
+get_next(File,Pos,N0,Start,What) ->
+    Fd = open(File),
+    pos_bof(Fd,Pos),
+    R = case get_n_lines_of_tag(Fd,N0) of
+	    {all,N,Lines} ->
+		{n_lines,Start,N,What,Lines};
+	    {part,N,Lines} ->
+		{n_lines,Start,N,What,Lines,get(pos)}
+	end,
+    close(Fd),
+    R.
+
+
+
+replace_all(From,To,[From|Rest],Acc) ->
+    replace_all(From,To,Rest,[To|Acc]);
+replace_all(From,To,[Char|Rest],Acc) ->
+    replace_all(From,To,Rest,[Char|Acc]);
+replace_all(_From,_To,[],Acc) ->
+    lists:reverse(Acc).
+
+
+%%%-----------------------------------------------------------------
+%%% Parse memory in crashdump version 0.1 and newer
+%%%
+parse_heap_term([$l|Line0], Addr, D0) ->	%Cons cell.
+    {H,"|"++Line1,D1} = parse_term(Line0, D0),
+    {T,Line,D2} = parse_term(Line1, D1),
+    Term = [H|T],
+    D = gb_trees:insert(Addr, Term, D2),
+    {Term,Line,D};
+parse_heap_term([$t|Line0], Addr, D) ->		%Tuple
+    {N,":"++Line} = get_hex(Line0),
+    parse_tuple(N, Line, Addr, D, []);
+parse_heap_term([$F|Line0], Addr, D0) ->	%Float
+    {N,":"++Line1} = get_hex(Line0),
+    {Chars,Line} = get_chars(N, Line1),
+    Term = list_to_float(Chars),
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D};
+parse_heap_term("B16#"++Line0, Addr, D0) ->	%Positive big number.
+    {Term,Line} = get_hex(Line0),
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D};
+parse_heap_term("B-16#"++Line0, Addr, D0) ->	%Negative big number
+    {Term0,Line} = get_hex(Line0),
+    Term = -Term0,
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D};
+parse_heap_term("B"++Line0, Addr, D0) ->	%Decimal big num (new in R10B-something).
+    case string:to_integer(Line0) of
+	{Int,Line} when is_integer(Int) ->
+	    D = gb_trees:insert(Addr, Int, D0),
+	    {Int,Line,D}
+    end;
+parse_heap_term([$P|Line0], Addr, D0) ->	% External Pid.
+    {Pid0,Line} = get_id(Line0),
+    Pid = "#CDVPid"++Pid0,
+    D = gb_trees:insert(Addr, Pid, D0),
+    {Pid,Line,D};
+parse_heap_term([$p|Line0], Addr, D0) ->        % External Port.
+    {Port0,Line} = get_id(Line0),
+    Port = "#CDVPort"++Port0,
+    D = gb_trees:insert(Addr, Port, D0),
+    {Port,Line,D};
+parse_heap_term("E"++Line0, Addr, D0) ->	%Term encoded in external format.
+    {Bin,Line} = get_binary(Line0),
+    Term = binary_to_term(Bin),
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D};
+parse_heap_term("Yh"++Line0, Addr, D0) ->	%Heap binary.
+    {Term,Line} = get_binary(Line0),
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D};
+parse_heap_term("Yc"++Line0, Addr, D0) ->	%Reference-counted binary.
+    {Binp,":"++Line1} = get_hex(Line0),
+    {First,":"++Line2} = get_hex(Line1),
+    {Sz,Line} = get_hex(Line2),
+    Term = case gb_trees:lookup(Binp, D0) of
+	       {value,<<_:First/binary,T:Sz/binary,_/binary>>} -> T;
+	       {value,{'#CDVTooBig',binary,Pos}} -> cdvbin(Sz,Pos);
+	       {value,'#CDVTruncatedBinary'} -> '#CDVTruncatedBinary';
+	       none -> '#CDVNonexistingBinary'
+	   end,
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D};
+parse_heap_term("Ys"++Line0, Addr, D0) ->	%Sub binary.
+    {Binp,":"++Line1} = get_hex(Line0),
+    {First,":"++Line2} = get_hex(Line1),
+    {Sz,Line} = get_hex(Line2),
+    Term = case gb_trees:lookup(Binp, D0) of
+	       {value,<<_:First/binary,T:Sz/binary,_/binary>>} -> T;
+	       {value,{'#CDVTooBig',binary,Pos}} -> cdvbin(Sz,Pos);
+	       {value,'#CDVTruncatedBinary'} -> '#CDVTruncatedBinary';
+	       none -> '#CDVNonexistingBinary'
+	   end,
+    D = gb_trees:insert(Addr, Term, D0),
+    {Term,Line,D}.
+
+
+parse_tuple(0, Line, Addr, D0, Acc) ->
+    Tuple = list_to_tuple(lists:reverse(Acc)),
+    D = gb_trees:insert(Addr, Tuple, D0),
+    {Tuple,Line,D};
+parse_tuple(N, Line0, Addr, D0, Acc) ->
+    case parse_term(Line0, D0) of
+	{Term,[$,|Line],D} when N > 1 ->
+	    parse_tuple(N-1, Line, Addr, D, [Term|Acc]);
+	{Term,Line,D}->
+	    parse_tuple(N-1, Line, Addr, D, [Term|Acc])
+    end.
+
+parse_term([$H|Line0], D) ->			%Pointer to heap term.
+    {Ptr,Line} = get_hex(Line0),
+    deref_ptr(Ptr, Line, D);
+parse_term([$N|Line], D) ->			%[] (nil).
+    {[],Line,D};
+parse_term([$I|Line0], D) ->			%Small.
+    {Int,Line} = string:to_integer(Line0),
+    {Int,Line,D};
+parse_term([$A|_]=Line, D) ->			%Atom.
+    parse_atom(Line, D);
+parse_term([$P|Line0], D) ->			%Pid.
+    {Pid,Line} = get_id(Line0),
+    {"#CDVPid"++Pid,Line,D};
+parse_term([$p|Line0], D) ->			%Port.
+    {Port,Line} = get_id(Line0),
+    {"#CDVPort"++Port,Line,D};
+parse_term([$S|Str0], D) ->			%Information string.
+    Str = lists:reverse(skip_blanks(lists:reverse(Str0))),
+    {Str,[],D};
+parse_term([$D|Line0], D) ->                    %DistExternal
+    try
+	{AttabSize,":"++Line1} = get_hex(Line0),
+	{Attab, "E"++Line2} = parse_atom_translation_table(AttabSize, Line1, []),
+	{Bin,Line3} = get_binary(Line2),
+	{try
+	     erts_debug:dist_ext_to_term(Attab, Bin)
+	 catch
+	     error:_ -> '<invalid-distribution-message>'
+	 end,
+	 Line3,
+	 D}
+    catch
+	error:_ -> 
+	    {'#CDVBadDistExt', skip_dist_ext(Line0), D}
+    end.
+
+skip_dist_ext(Line) ->
+    skip_dist_ext(lists:reverse(Line), []).
+
+skip_dist_ext([], SeqTraceToken) ->
+    SeqTraceToken;
+skip_dist_ext([$:| _], SeqTraceToken) ->
+    [$:|SeqTraceToken];
+skip_dist_ext([C|Cs], KeptCs) ->
+    skip_dist_ext(Cs, [C|KeptCs]).
+
+parse_atom([$A|Line0], D) ->
+    {N,":"++Line1} = get_hex(Line0),
+    {Chars, Line} = get_chars(N, Line1),
+    {list_to_atom(Chars), Line, D}.
+
+parse_atom_translation_table(0, Line0, As) ->
+    {list_to_tuple(lists:reverse(As)), Line0};
+parse_atom_translation_table(N, Line0, As) ->
+    {A, Line1, _} = parse_atom(Line0, []),
+    parse_atom_translation_table(N-1, Line1, [A|As]).
+    
+    
+
+deref_ptr(Ptr, Line, D0) ->
+    case gb_trees:lookup(Ptr, D0) of
+	{value,Term} ->
+	    {Term,Line,D0};
+	none ->
+	    case get(fd) of
+		end_of_heap ->
+		    {['#CDVIncompleteHeap'],Line,D0};
+		Fd ->
+		    case val(Fd) of
+			"="++_ ->
+			    put(fd, end_of_heap),
+			    deref_ptr(Ptr, Line, D0);
+			L ->
+			    D = parse(L, D0),
+			    deref_ptr(Ptr, Line, D)
+		    end
+	    end
+    end.
+
+get_hex(L) ->
+    get_hex_1(L, 0).
+
+get_hex_1([H|T]=L, Acc) ->
+    case get_hex_digit(H) of
+	none -> {Acc,L};
+	Digit -> get_hex_1(T, (Acc bsl 4) bor Digit)
+    end;
+get_hex_1([], Acc) -> {Acc,[]}.
+
+get_hex_digit(C) when $0 =< C, C =< $9 -> C-$0;
+get_hex_digit(C) when $a =< C, C =< $f -> C-$a+10;
+get_hex_digit(C) when $A =< C, C =< $F -> C-$A+10;
+get_hex_digit(_) -> none.
+
+skip_blanks([$\s|T]) ->
+    skip_blanks(T);
+skip_blanks([$\r|T]) ->
+    skip_blanks(T);
+skip_blanks([$\n|T]) ->
+    skip_blanks(T);
+skip_blanks([$\t|T]) ->
+    skip_blanks(T);
+skip_blanks(T) -> T.
+
+get_chars(N, Line) ->
+    get_chars(N, Line, []).
+
+get_chars(0, Line, Acc) ->
+    {lists:reverse(Acc),Line};
+get_chars(N, [H|T], Acc) ->
+    get_chars(N-1, T, [H|Acc]).
+
+get_id(Line) ->
+    get_id(Line, []).
+
+get_id([$>|Line], Acc) ->
+    {lists:reverse(Acc, [$>]),Line};
+get_id([H|T], Acc) ->
+    get_id(T, [H|Acc]).
+
+get_label(L) ->
+    get_label(L, []).
+
+get_label([$:|Line], Acc) ->
+    Label = lists:reverse(Acc),
+    case get_hex(Label) of
+	{Int,[]} ->
+	    {Int,Line};
+	_ ->
+	    {list_to_atom(Label),Line}
+    end;
+get_label([H|T], Acc) ->
+    get_label(T, [H|Acc]).
+
+get_binary(Line0) ->
+    {N,":"++Line} = get_hex(Line0),
+    get_binary(N, Line, []).
+
+get_binary(0, Line, Acc) ->
+    {list_to_binary(lists:reverse(Acc)),Line};
+get_binary(N, [A,B|Line], Acc) ->
+    Byte = (get_hex_digit(A) bsl 4) bor get_hex_digit(B),
+    get_binary(N-1, Line, [Byte|Acc]);
+get_binary(_N, [], _Acc) ->
+    {'#CDVTruncatedBinary',[]}.
+
+cdvbin(Sz,Pos) ->
+    "#CDVBin<"++integer_to_list(Sz)++","++integer_to_list(Pos)++">".