trepanning 0.1.2 → 0.1.3

data/processor/hook.rb

@@ -1,6 +1,7 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'virtual'
 class Trepan
-  class CmdProcessor
+  class CmdProcessor < VirtualCmdProcessor
     # Command processor hooks.
     attr_reader   :autoirb_hook
     attr_reader   :autolist_hook

data/processor/load_cmds.rb

@@ -6,208 +6,215 @@ require 'tmpdir'
 # builtin and user directories.  
 # Sets @commands, @aliases, @macros
 require_relative '../app/complete'
-class Trepan
-  class CmdProcessor
-
-    attr_reader   :aliases         # Hash[String] of command names
-                                   # indexed by alias name
-    attr_reader   :commands        # Hash[String] of command objects
-                                   # indexed by name
-    attr_reader   :macros          # Hash[String] of Proc objects 
-                                   # indexed by macro name.
-    
-    # "initialize" for multi-file class. Called from main.rb's "initialize".
-    def load_cmds_initialize
-      @commands = {}
-      @aliases = {}
-      @macros = {}
-
-      cmd_dirs = [ File.join(File.dirname(__FILE__), 'command') ]
-      cmd_dirs <<  @settings[:user_cmd_dir] if @settings[:user_cmd_dir]
-      cmd_dirs.each do |cmd_dir| 
-        load_debugger_commands(cmd_dir) if File.directory?(cmd_dir)
-      end
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  attr_reader   :aliases         # Hash[String] of command names
+                                 # indexed by alias name
+  attr_reader   :commands        # Hash[String] of command objects
+                                 # indexed by name
+  attr_reader   :macros          # Hash[String] of Proc objects 
+                                 # indexed by macro name.
+  attr_reader   :leading_str     # leading part of string. Used in 
+                                 # command completion
+
+  # "initialize" for multi-file class. Called from main.rb's "initialize".
+  def load_cmds_initialize
+    @commands = {}
+    @aliases = {}
+    @macros = {}
+
+    cmd_dirs = [ File.join(File.dirname(__FILE__), 'command') ]
+    cmd_dirs <<  @settings[:user_cmd_dir] if @settings[:user_cmd_dir]
+    cmd_dirs.each do |cmd_dir| 
+      load_debugger_commands(cmd_dir) if File.directory?(cmd_dir)
     end
+  end
 
-    # Loads in debugger commands by require'ing each ruby file in the
-    # 'command' directory. Then a new instance of each class of the 
-    # form Trepan::xxCommand is added to @commands and that array
-    # is returned.
-    def load_debugger_commands(file_or_dir)
-      if File.directory?(file_or_dir)
-        dir = File.expand_path(file_or_dir)
-        Dir.glob(File.join(dir, '*.rb')).each do |rb| 
-          # We use require so that multiple calls have no effect.
-          require rb
-        end
-      elsif File.readable?(file_or_dir)
-        # We use load in case we are reloading. 
-        # 'require' would not be effective here
-        load file_or_dir
-      else
-        return false
-      end
-      Trepan::Command.constants.grep(/.Command$/).each do |command|
-        setup_command(command)
+  # Loads in debugger commands by require'ing each ruby file in the
+  # 'command' directory. Then a new instance of each class of the 
+  # form Trepan::xxCommand is added to @commands and that array
+  # is returned.
+  def load_debugger_commands(file_or_dir)
+    if File.directory?(file_or_dir)
+      dir = File.expand_path(file_or_dir)
+      # change $0 so it doesn't get in the way of __FILE__ = $0
+      old_dollar0 = $0
+      $0 = ''
+      Dir.glob(File.join(dir, '*.rb')).each do |rb| 
+        # We use require so that multiple calls have no effect.
+        require rb
       end
-      return true
+      $0 = old_dollar0
+    elsif File.readable?(file_or_dir)
+      # We use load in case we are reloading. 
+      # 'require' would not be effective here
+      load file_or_dir
+    else
+      return false
+    end
+    # Instantiate each Command class found by the above require(s).
+    Trepan::Command.constants.grep(/.Command$/).each do |command|
+      setup_command(command)
     end
+    return true
+  end
 
-    def load_debugger_command(command_file)
-      return unless File.readable?(command_file)
-      load command_file
-      Trepan::Command.constants.grep(/.Command$/).each do |command|
-        setup_command(command)
-      end
+  def load_debugger_command(command_file)
+    return unless File.readable?(command_file)
+    load command_file
+    Trepan::Command.constants.grep(/.Command$/).each do |command|
+      setup_command(command)
     end
+  end
 
-    # Looks up cmd_array[0] in @commands and runs that. We do lots of 
-    # validity testing on cmd_array.
-    def run_cmd(cmd_array)
-      unless cmd_array.is_a?(Array)
-        errmsg "run_cmd argument should be an Array, got: #{cmd_array.class}"
-        return
-      end
-      if cmd_array.detect{|item| !item.is_a?(String)}
-        errmsg "run_cmd argument Array should only contain strings. " + 
-          "Got #{cmd_array.inspect}"
-        return
-      end
-      if cmd_array.empty?
-        errmsg "run_cmd Array should have at least one item. " + 
-          "Got: #{cmd_array.inspect}"
-        return
-      end
-      cmd_name = cmd_array[0]
-      if @commands.member?(cmd_name)
-        @commands[cmd_name].run(cmd_array)
-      end
+  # Looks up cmd_array[0] in @commands and runs that. We do lots of 
+  # validity testing on cmd_array.
+  def run_cmd(cmd_array)
+    unless cmd_array.is_a?(Array)
+      errmsg "run_cmd argument should be an Array, got: #{cmd_array.class}"
+      return
+    end
+    if cmd_array.detect{|item| !item.is_a?(String)}
+      errmsg "run_cmd argument Array should only contain strings. " + 
+        "Got #{cmd_array.inspect}"
+      return
+    end
+    if cmd_array.empty?
+      errmsg "run_cmd Array should have at least one item. " + 
+        "Got: #{cmd_array.inspect}"
+      return
+    end
+    cmd_name = cmd_array[0]
+    if @commands.member?(cmd_name)
+      @commands[cmd_name].run(cmd_array)
     end
+  end
 
-    def save_commands(opts)
-      save_filename = opts[:filename] || 
-        File.join(Dir.tmpdir, Dir::Tmpname.make_tmpname(['trepanning-save', '.txt'], nil))
-      begin
-        save_file = File.open(save_filename, 'w')
-      rescue => exc
-        errmsg("Can't open #{save_filename} for writing.")
-        errmsg("System reports: #{exc.inspect}")
-        return nil
-      end
-      save_file.puts "#\n# Commands to restore trepanning environment\n#\n"
-      @commands.each do |cmd_name, cmd_obj|
-        cmd_obj.save_command if cmd_obj.respond_to?(:save_command)
-        next unless cmd_obj.is_a?(Trepan::SubcommandMgr)
-        cmd_obj.subcmds.subcmds.each do |subcmd_name, subcmd_obj|
-          save_file.puts subcmd_obj.save_command if 
-            subcmd_obj.respond_to?(:save_command)
-          next unless subcmd_obj.is_a?(Trepan::SubSubcommandMgr)
-          subcmd_obj.subcmds.subcmds.each do |subsubcmd_name, subsubcmd_obj|
-            save_file.puts subsubcmd_obj.save_command if 
-              subsubcmd_obj.respond_to?(:save_command)
-          end
+  def save_commands(opts)
+    save_filename = opts[:filename] || 
+      File.join(Dir.tmpdir, Dir::Tmpname.make_tmpname(['trepanning-save', '.txt'], nil))
+    begin
+      save_file = File.open(save_filename, 'w')
+    rescue => exc
+      errmsg("Can't open #{save_filename} for writing.")
+      errmsg("System reports: #{exc.inspect}")
+      return nil
+    end
+    save_file.puts "#\n# Commands to restore trepanning environment\n#\n"
+    @commands.each do |cmd_name, cmd_obj|
+      cmd_obj.save_command if cmd_obj.respond_to?(:save_command)
+      next unless cmd_obj.is_a?(Trepan::SubcommandMgr)
+      cmd_obj.subcmds.subcmds.each do |subcmd_name, subcmd_obj|
+        save_file.puts subcmd_obj.save_command if 
+          subcmd_obj.respond_to?(:save_command)
+        next unless subcmd_obj.is_a?(Trepan::SubSubcommandMgr)
+        subcmd_obj.subcmds.subcmds.each do |subsubcmd_name, subsubcmd_obj|
+          save_file.puts subsubcmd_obj.save_command if 
+            subsubcmd_obj.respond_to?(:save_command)
         end
       end
-      save_file.puts "!FileUtils.rm #{save_filename.inspect}" if 
-        opts[:erase]
-      save_file.close
-
-      return save_filename
-    end
-
-    # Instantiate a Trepan::Command and extract info: the NAME, ALIASES
-    # and store the command in @commands.
-    def setup_command(command)
-      # Note: there is probably a non-eval way to instantiate the
-      # command, but I don't know it. And eval works.
-      klass = self.instance_eval("Trepan::Command::#{command}")
-      cmd = klass.send(:new, self)
-      
-      # Add to list of commands and aliases.
-      cmd_name = klass.const_get(:NAME)
-      if klass.constants.member?(:ALIASES)
-        aliases= klass.const_get(:ALIASES)  
-        aliases.each {|a| @aliases[a] = cmd_name}
-      end
-      @commands[cmd_name] = cmd
-    end
-
-    # Handle initial completion. We draw from the commands, aliases,
-    # and macros for completion. However we won't include aliases which
-    # are prefixes of other commands.
-    def complete(str, last_token)
-      next_blank_pos, token = Trepan::Complete.next_token(str, 0)
-      return [''] if token.empty? && !last_token.empty?
-      match_pairs = Trepan::Complete.complete_token_with_next(@commands,
-                                                               token)
-      match_hash = {}
-      match_pairs.each do |pair|
+    end
+    save_file.puts "!FileUtils.rm #{save_filename.inspect}" if 
+      opts[:erase]
+    save_file.close
+
+    return save_filename
+  end
+
+  # Instantiate a Trepan::Command and extract info: the NAME, ALIASES
+  # and store the command in @commands.
+  def setup_command(command)
+    # Note: there is probably a non-eval way to instantiate the
+    # command, but I don't know it. And eval works.
+    klass = self.instance_eval("Trepan::Command::#{command}")
+    cmd = klass.send(:new, self)
+    
+    # Add to list of commands and aliases.
+    cmd_name = klass.const_get(:NAME)
+    if klass.constants.member?(:ALIASES)
+      aliases= klass.const_get(:ALIASES)  
+      aliases.each {|a| @aliases[a] = cmd_name}
+    end
+    @commands[cmd_name] = cmd
+  end
+
+  # Handle initial completion. We draw from the commands, aliases,
+  # and macros for completion. However we won't include aliases which
+  # are prefixes of other commands.
+  def complete(str, last_token)
+    @leading_str = str
+    next_blank_pos, token = Trepan::Complete.next_token(str, 0)
+    return [''] if token.empty? && !last_token.empty?
+    match_pairs = Trepan::Complete.complete_token_with_next(@commands,
+                                                            token)
+    match_hash = {}
+    match_pairs.each do |pair|
+      match_hash[pair[0]] = pair[1]
+    end
+    alias_pairs = Trepan::Complete.
+      complete_token_filtered_with_next(@aliases, token, match_hash,
+                                        @commands)
+    match_pairs += alias_pairs
+    if str[next_blank_pos..-1].empty?
+      return match_pairs.map{|pair| pair[0]}.sort
+    else
+      alias_pairs.each do |pair|
         match_hash[pair[0]] = pair[1]
       end
-      alias_pairs = Trepan::Complete.
-        complete_token_filtered_with_next(@aliases, token, match_hash,
-                                          @commands)
-      match_pairs += alias_pairs
-      if str[next_blank_pos..-1].empty?
-        return match_pairs.map{|pair| pair[0]}.sort
+    end
+    if match_pairs.size > 1
+      # FIXME: figure out what to do here.
+      # Matched multiple items in the middle of the string
+      # We can't handle this so do nothing.
+      return []
+      # return match_pairs.map do |name, cmd|
+      #   ["#{name} #{args[1..-1].join(' ')}"]
+      # end
+    end
+    # match_pairs.size == 1
+    next_complete(str, next_blank_pos, match_pairs[0][1], last_token)
+  end
+
+  def next_complete(str, next_blank_pos, cmd, last_token)
+    next_blank_pos, token = Trepan::Complete.next_token(str, next_blank_pos)
+    return [] if token.empty? && !last_token.empty?
+    
+    if cmd.respond_to?(:complete_token_with_next) 
+      match_pairs = cmd.complete_token_with_next(token)
+      return [] if match_pairs.empty?
+      if str[next_blank_pos..-1].rstrip.empty? && 
+          (token.empty? || token == last_token)
+        return match_pairs.map { |completion, junk| completion }
       else
-        alias_pairs.each do |pair|
-          match_hash[pair[0]] = pair[1]
-        end
-      end
-      if match_pairs.size > 1
-        # FIXME: figure out what to do here.
-        # Matched multiple items in the middle of the string
-        # We can't handle this so do nothing.
-        return []
-        # return match_pairs.map do |name, cmd|
-        #   ["#{name} #{args[1..-1].join(' ')}"]
-        # end
-      end
-      # match_pairs.size == 1
-      next_complete(str, next_blank_pos, match_pairs[0][1], last_token)
-    end
-
-    def next_complete(str, next_blank_pos, cmd, last_token)
-      # debugger if 8 == next_blank_pos
-      next_blank_pos, token = Trepan::Complete.next_token(str, next_blank_pos)
-      return [] if token.empty? && !last_token.empty?
-      
-      if cmd.respond_to?(:complete_token_with_next) 
-        match_pairs = cmd.complete_token_with_next(token)
-        return [] if match_pairs.empty?
-        if str[next_blank_pos..-1].rstrip.empty? && 
-            (token.empty? || token == last_token)
-          return match_pairs.map { |completion, junk| completion }
-        else
-          if match_pairs.size == 1
-            return next_complete(str, next_blank_pos, match_pairs[0][1], 
-                                 last_token)
-          else
-            # FIXME: figure out what to do here.
-            # Matched multiple items in the middle of the string
-            # We can't handle this so do nothing.
-            return []
-          end
-        end
-      elsif cmd.respond_to?(:complete)
-        matches = cmd.complete(token)
-        return [] if matches.empty?
-        if str[next_blank_pos..-1].rstrip.empty? && 
-            (token.empty? || token == last_token)
-          return matches
+        if match_pairs.size == 1
+          return next_complete(str, next_blank_pos, match_pairs[0][1], 
+                               last_token)
         else
           # FIXME: figure out what to do here.
           # Matched multiple items in the middle of the string
           # We can't handle this so do nothing.
           return []
         end
+      end
+    elsif cmd.respond_to?(:complete)
+      matches = cmd.complete(token)
+      return [] if matches.empty?
+      if str[next_blank_pos..-1].rstrip.empty? && 
+          (token.empty? || token == last_token)
+        return matches
       else
+        # FIXME: figure out what to do here.
+        # Matched multiple items in the middle of the string
+        # We can't handle this so do nothing.
         return []
       end
+    else
+      return []
     end
   end
 end
+
 if __FILE__ == $0
   class Trepan::CmdProcessor
     def initialize(core, settings={})
@@ -235,7 +242,7 @@ if __FILE__ == $0
   cmdproc.run_cmd('foo')  # Invalid - not an Array
   cmdproc.run_cmd([])     # Invalid - empty Array
   cmdproc.run_cmd(['list', 5])  # Invalid - nonstring arg
-  p cmdproc.complete("d")
-  p cmdproc.complete("sho d")
-  p cmdproc.complete('')
+  p cmdproc.complete("d", 'd')
+  p cmdproc.complete("sho d", 'd')
+  p cmdproc.complete('', '')
 end

data/processor/location.rb

@@ -1,183 +1,180 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'
 require 'linecache'
 require 'pathname'  # For cleanpath
 require_relative 'msg'
 require_relative '../app/frame'
-class Trepan
-  class CmdProcessor
-    attr_accessor :reload_on_change
-    include Frame
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  include Trepan::Frame
 
-    def location_initialize
-      @reload_on_change = nil
-    end
-
-    def canonic_container(container)
-      [container[0], canonic_file(container[1])]
-    end
-
-    def canonic_file(filename)
-      # For now we want resolved filenames 
-      @settings[:basename] ? File.basename(filename) : 
-        # Cache this?
-        File.expand_path(Pathname.new(filename).cleanpath.to_s)
-    end
-
-    # Return the text to the current source line.
-    # FIXME: loc_and_text should call this rather than the other
-    # way around.
-    def current_source_text
-      opts = {:reload_on_change => @reload_on_change}
-      junk1, junk2, text, found_line = 
-        loc_and_text('', frame, frame.source_location[0], 
-                     frame.source_container, opts)
-      text
-    end
-
-    def resolve_file_with_dir(path_suffix)
-      @settings[:directory].split(/:/).each do |dir|
-        dir = 
-          if '$cwd' == dir
-            Dir.pwd
-          elsif '$cdir' == dir
-            RubyVM::OS_STARTUP_DIR
-          else
-            dir
-          end
-        next unless dir && File.directory?(dir)
-        try_file = File.join(dir, path_suffix)
-        return try_file if File.readable?(try_file)
-      end
-      nil
+  def canonic_container(container)
+    [container[0], canonic_file(container[1])]
+  end
+  
+  def canonic_file(filename, resolve=true)
+    # For now we want resolved filenames 
+    if @settings[:basename]
+      File.basename(filename)
+    elsif resolve
+      filename = LineCache::map_file(filename)
+      File.expand_path(Pathname.new(filename).cleanpath.to_s)
+    else
+      filename
     end
+  end
 
-    # Get line +line_number+ from file named +filename+. Return ''
-    # if there was a problem. Leading blanks are stripped off.
-    def line_at(filename, line_number,
-                opts = {
-                  :reload_on_change => @reload_on_change,
-                  :output => @settings[:highlight]
-                })
-      line = LineCache::getline(filename, line_number, opts)
-
-      unless line
-        # Try using search directories (set with command "directory")
-        if filename[0..0] != File::SEPARATOR
-          try_filename = resolve_file_with_dir(filename) 
-          if try_filename && 
-              line = LineCache::getline(try_filename, line_number, opts)
-            LineCache::remap_file(filename, try_filename)
-          end
+  # Return the text to the current source line.
+  # FIXME: loc_and_text should call this rather than the other
+  # way around.
+  def current_source_text
+    opts = {:reload_on_change => @reload}
+    junk1, junk2, text, found_line = 
+      loc_and_text('', frame, frame.source_location[0], 
+                   frame.source_container, opts)
+    text
+  end
+  
+  def resolve_file_with_dir(path_suffix)
+    @settings[:directory].split(/:/).each do |dir|
+      dir = 
+        if '$cwd' == dir
+          Dir.pwd
+        elsif '$cdir' == dir
+          RubyVM::OS_STARTUP_DIR
+        else
+          dir
         end
-      end
-      line ? line.lstrip.chomp : line
+      next unless dir && File.directory?(dir)
+      try_file = File.join(dir, path_suffix)
+      return try_file if File.readable?(try_file)
     end
-
-    def loc_and_text(loc, frame, line_no, source_container,
-                     opts = {
-                       :reload_on_change => @reload_on_change,
-                       :output => @settings[:highlight]
-                     })
-      found_line = true
-      ## FIXME: condition is too long.
-      if source_container[0] == 'string' && frame.iseq && frame.iseq.eval_source
-        file = LineCache::map_iseq(frame.iseq)
-        text = LineCache::getline(frame.iseq, line_no, opts)
-        loc += " remapped #{canonic_file(file)}:#{line_no}"
-      elsif source_container[0] != 'file'
-        via = loc
-        while source_container[0] != 'file' && frame.prev do
-          frame            = frame.prev
-          source_container = frame_container(frame, false)
-        end
-        if source_container[0] == 'file'
-          line_no      = frame.source_location[0]
-          filename     = source_container[1]
-          loc         += " via #{canonic_file(filename)}:#{line_no}"
-          text         = line_at(filename, line_no, opts)
-          found_line   = false
-        end
-      else
-        container = source_container[1]
-        map_file, map_line = LineCache::map_file_line(container, line_no)
-        if [container, line_no] != [map_file, map_line]
-          loc += " remapped #{canonic_file(map_file)}:#{map_line}"
+    nil
+  end
+  
+  # Get line +line_number+ from file named +filename+. Return ''
+  # if there was a problem. Leading blanks are stripped off.
+  def line_at(filename, line_number,
+              opts = {
+                :reload_on_change => @settings[:reload],
+                :output => @settings[:highlight]
+              })
+    line = LineCache::getline(filename, line_number, opts)
+    
+    unless line
+      # Try using search directories (set with command "directory")
+      if filename[0..0] != File::SEPARATOR
+        try_filename = resolve_file_with_dir(filename) 
+        if try_filename && 
+            line = LineCache::getline(try_filename, line_number, opts)
+          LineCache::remap_file(filename, try_filename)
         end
-        
-        text  = line_at(container, line_no, opts)
       end
-      [loc, line_no, text, found_line]
     end
+    line ? line.lstrip.chomp : line
+  end
 
-    def print_location
-      if %w(c-call call).member?(@event)
-        # FIXME: Fix Ruby so we don't need this workaround? 
-        # See also where.rb
-        opts = {}
-        opts[:class] = @core.hook_arg if 
-          'CFUNC' == @frame.type && @core.hook_arg && 0 == @frame_index 
-        msg format_stack_call(@frame, opts) 
-      elsif 'raise' == @event
-        msg @core.hook_arg.inspect if @core.hook_arg # Exception object
-      end
-
-      text      = nil
-      source_container = frame_container(@frame, false)
-      ev        = if @event.nil? || 0 != @frame_index
-                    '  ' 
-                  else
-                    (EVENT2ICON[@event] || @event)
-                  end
-      @line_no  = frame_line
-
-      loc = source_location_info(source_container, @line_no, @frame)
-      loc, @line_no, text, found_line = 
-        loc_and_text(loc, @frame, @line_no, source_container)
-
-      ip_str = @frame.iseq ? " @#{frame.pc_offset}" : ''
-      msg "#{ev} (#{loc}#{ip_str})"
-
-      if %w(return c-return).member?(@event)
-        retval = Trepan::Frame.value_returned(@frame, @event)
-        msg 'R=> %s' % retval.inspect 
+  def loc_and_text(loc, frame, line_no, source_container,
+                   opts = {
+                     :reload_on_change => @settings[:reload],
+                     :output => @settings[:highlight]
+                   })
+    found_line = true
+    ## FIXME: condition is too long.
+    if source_container[0] == 'string' && frame.iseq && frame.iseq.eval_source
+      file = LineCache::map_iseq(frame.iseq)
+      text = LineCache::getline(frame.iseq, line_no, opts)
+      loc += " remapped #{canonic_file(file)}:#{line_no}"
+    elsif source_container[0] != 'file'
+      via = loc
+      while source_container[0] != 'file' && frame.prev do
+        frame            = frame.prev
+        source_container = frame_container(frame, false)
       end
-      
-      if text && !text.strip.empty?
-        msg text
-        @line_no -= 1
+      if source_container[0] == 'file'
+        line_no      = frame.source_location[0]
+        filename     = source_container[1]
+        loc         += " via #{canonic_file(filename)}:#{line_no}"
+        text         = line_at(filename, line_no, opts)
+        found_line   = false
       end
-      unless found_line
-        # Can't find source line, so give assembly as consolation.
-        # This great idea comes from the Rubinius reference debugger.
-        run_command('disassemble')
+    else
+      container = source_container[1]
+      map_file, map_line = LineCache::map_file_line(container, line_no)
+      if [container, line_no] != [map_file, map_line]
+        loc += " remapped #{canonic_file(map_file)}:#{map_line}"
       end
+      
+      text  = line_at(container, line_no, opts)
+    end
+    [loc, line_no, text, found_line]
+  end
+  
+  def print_location
+    if %w(c-call call).member?(@event)
+      # FIXME: Fix Ruby so we don't need this workaround? 
+      # See also where.rb
+      opts = {}
+      opts[:class] = @core.hook_arg if 
+        'CFUNC' == @frame.type && @core.hook_arg && 0 == @frame_index 
+      msg format_stack_call(@frame, opts) 
+    elsif 'raise' == @event
+      msg @core.hook_arg.inspect if @core.hook_arg # Exception object
+    end
+    
+    text      = nil
+    source_container = frame_container(@frame, false)
+    ev        = if @event.nil? || 0 != @frame_index
+                  '  ' 
+                else
+                  (EVENT2ICON[@event] || @event)
+                end
+    @line_no  = frame_line
+    
+    loc = source_location_info(source_container, @line_no, @frame)
+    loc, @line_no, text, found_line = 
+      loc_and_text(loc, @frame, @line_no, source_container)
+    
+    ip_str = @frame.iseq ? " @#{frame.pc_offset}" : ''
+    msg "#{ev} (#{loc}#{ip_str})"
+    
+    if %w(return c-return).member?(@event)
+      retval = Trepan::Frame.value_returned(@frame, @event)
+      msg 'R=> %s' % retval.inspect 
+    end
+    
+    if text && !text.strip.empty?
+      msg text
+      @line_no -= 1
+    end
+    unless found_line
+      # Can't find source line, so give assembly as consolation.
+      # This great idea comes from the Rubinius reference debugger.
+      run_command('disassemble')
     end
-
-    def source_location_info(source_container, line_no, frame)
-      filename  = source_container[1]
-      ## FIXME: condition is too long.
-      canonic_filename = 
-        if 'string' == source_container[0] && frame.iseq && 
-            frame.iseq.eval_source
-          eval_str = frame.iseq.eval_source
-          'eval "' + safe_repr(eval_str.gsub(/\n/,';'), 15) + '"'
-        else
-          canonic_file(filename)
-        end
-      loc = "#{canonic_filename}:#{line_no}"
-      return loc
-    end # source_location_info
-
   end
+  
+  def source_location_info(source_container, line_no, frame)
+    filename  = source_container[1]
+    ## FIXME: condition is too long.
+    canonic_filename = 
+      if 'string' == source_container[0] && frame.iseq && 
+          frame.iseq.eval_source
+        eval_str = frame.iseq.eval_source
+        'eval "' + safe_repr(eval_str.gsub(/\n/,';'), 15) + '"'
+      else
+        canonic_file(filename, false)
+      end
+    loc = "#{canonic_filename}:#{line_no}"
+    return loc
+  end # source_location_info
 end
 
-if __FILE__ == $0 && caller.size == 0 && ARGV.size > 0
+if __FILE__ == $0 && caller.size == 0
   # Demo it.
   require 'thread_frame'
   require_relative 'frame'
   require_relative '../app/mock'
-  require_relative 'main'   # Have to include before defining CmdProcessor!
-                            # FIXME
   class Trepan::CmdProcessor
     def errmsg(msg)
       puts msg
@@ -193,15 +190,13 @@ if __FILE__ == $0 && caller.size == 0 && ARGV.size > 0
   proc.frame_setup(RubyVM::ThreadFrame.current)
   proc.frame_initialize
 
-  proc.location_initialize
   puts proc.canonic_file(__FILE__)
-  proc.instance_variable_set('@settings', {:basename => true})
+  proc.settings[:basename] = true
   puts proc.canonic_file(__FILE__)
   puts proc.current_source_text
   xx = eval <<-END
      proc.frame_initialize
      proc.frame_setup(RubyVM::ThreadFrame.current)
-     proc.location_initialize
-     proc.current_source_text
+     puts proc.current_source_text
   END
 end