rbx-trepanning 0.0.8-universal-rubinius-1.2 → 0.1.0-universal-rubinius-1.2

data/processor/help.rb

@@ -1,4 +1,5 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
 class Trepan
   # class SubHelp
   #   def initialize(name, dir)
@@ -48,7 +49,7 @@ class Trepan
     # like "show", "info" or "set". Generally this means list
     # all of the subcommands.
     def summary_list(name, subcmds)
-      msg "List of #{name} commands (with minimum abbreviation in parenthesis):"
+      section "List of #{name} commands (with minimum abbreviation in parenthesis):"
       subcmds.list.each do |subcmd_name|
         # Some commands have lots of output.
         # they are excluded here because 'in_list' is false.
@@ -59,8 +60,9 @@ class Trepan
 
     # Error message when subcommand asked for but doesn't exist
     def undefined_subcmd(cmd, subcmd)
-      errmsg(('Undefined "%s" subcommand: "%s". ' + 
-              'Try "help %s *".') % [cmd, subcmd, cmd])
+      ambig = settings[:abbrev] ? 'or ambiguous ' : ''
+      errmsg(['Undefined %s"%s" subcommand: "%s". ' % [ambig, cmd, subcmd],
+              'Try "help %s *".' % cmd])
     end
 
   end

data/processor/hook.rb

@@ -1,113 +1,114 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
-class Trepan
-  class CmdProcessor
-    # Command processor hooks.
-    attr_reader   :autodis_hook
-    attr_reader   :autoirb_hook
-    attr_reader   :autolist_hook
-    attr_reader   :debug_dbgr_hook
-    attr_reader   :display_hook
-    attr_reader   :timer_hook
-    attr_reader   :trace_hook
-    attr_reader   :tracebuf_hook
-    attr_reader   :unconditional_prehooks
-    attr_reader   :cmdloop_posthooks
-    attr_reader   :cmdloop_prehooks
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'virtual'
 
-    # Used to time how long a debugger action takes
-    attr_accessor :time_last
-
-    class Hook
-      attr_accessor :list
-
-      def initialize(list=[])
-        @list = list
-      end
-
-      def delete_by_name(delete_name)
-        @list.delete_if {|hook_name, priority, hook| hook_name == delete_name}
-      end
-
-      def empty?
-        @list.empty?
-      end
-
-      def insert(priority, name, hook)
-        insert_loc = @list.size  # at end
-        @list.each_with_index do |entry, index|
-          n, p, h = entry
-          if priority > p 
-            insert_loc = index
-            break
-          end
-        end
-        @list.insert(insert_loc, [name, priority, hook])
-      end
-
-      def insert_if_new(priority, name, hook)
-        insert(priority, name, hook) unless
-          @list.find {|try_name, try_priority, try_hook| try_name == name}
-      end
-
-      # Run each function in `hooks' with args
-      def run(*args)
-        @list.each do |name, priority, hook| 
-          hook.call(name, *args) 
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  # Command processor hooks.
+  attr_reader   :autodis_hook
+  attr_reader   :autoirb_hook
+  attr_reader   :autolist_hook
+  attr_reader   :debug_dbgr_hook
+  attr_reader   :display_hook
+  attr_reader   :timer_hook
+  attr_reader   :trace_hook
+  attr_reader   :tracebuf_hook
+  attr_reader   :unconditional_prehooks
+  attr_reader   :cmdloop_posthooks
+  attr_reader   :cmdloop_prehooks
+  
+  # Used to time how long a debugger action takes
+  attr_accessor :time_last
+  
+  class Hook
+    attr_accessor :list
+    
+    def initialize(list=[])
+      @list = list
+    end
+    
+    def delete_by_name(delete_name)
+      @list.delete_if {|hook_name, priority, hook| hook_name == delete_name}
+    end
+    
+    def empty?
+      @list.empty?
+    end
+    
+    def insert(priority, name, hook)
+      insert_loc = @list.size  # at end
+      @list.each_with_index do |entry, index|
+        n, p, h = entry
+        if priority > p 
+          insert_loc = index
+          break
         end
       end
-
-      # Could add delete_at and delete if necessary.
+      @list.insert(insert_loc, [name, priority, hook])
     end
     
-    def hook_initialize(commands)
-      @cmdloop_posthooks      = Hook.new
-      @cmdloop_prehooks       = Hook.new
-      @unconditional_prehooks = Hook.new
-
-      irb_cmd = commands['irb']
-      @autoirb_hook  = ['autoirb', 
-                        Proc.new{|*args| irb_cmd.run(['irb']) if irb_cmd}]
-
-      @debug_dbgr_hook = ['dbgdbgr',
-                          Proc.new{|*args| 
-                            if settings[:debugdbgr]
-                              $trepan_cmdproc  = self
-                              $trepan_frame    = @frame
-                            else
-                              $trepan_cmdproc  = nil
-                              $trepan_frame    = nil
-                            end}]
-
-      display_cmd = commands['display']
-      @display_hook   = ['display', 
-                         Proc.new{|*args| display_cmd.run(['display']) if display_cmd}]
-
-      # FIXME: generalize for any command run 
-      dis_cmd = commands['disassemble']
-      @autodis_hook  = ['autodis', 
-                         Proc.new{|*args| dis_cmd.run(['disassemble']) if dis_cmd}]
-
-      list_cmd = commands['list']
-      @autolist_hook  = ['autolist', 
-                         Proc.new{|*args| list_cmd.run(['list']) if list_cmd}]
-      
-      @timer_hook     = ['timer', 
-                         Proc.new{|*args|
-                           now = Time.now
-                           msg("%g seconds" % 
-                               (now - @time_last)) if @time_last
-                           @time_last = now
-                         }]
-      @timer_posthook = ['timer', Proc.new{|*args| @time_last = Time.now}]
-      @trace_hook     = ['trace', 
-                        Proc.new{|*args| print_location}]
-      @tracebuf_hook  = ['tracebuffer', 
-                         Proc.new{|*args| @eventbuf.append(@event, @frame, 
-                                                           nil)}]
+    def insert_if_new(priority, name, hook)
+      insert(priority, name, hook) unless
+        @list.find {|try_name, try_priority, try_hook| try_name == name}
     end
-
+    
+    # Run each function in `hooks' with args
+    def run(*args)
+      @list.each do |name, priority, hook| 
+        hook.call(name, *args) 
+      end
+    end
+    
+    # Could add delete_at and delete if necessary.
+  end
+  
+  def hook_initialize(commands)
+    @cmdloop_posthooks      = Hook.new
+    @cmdloop_prehooks       = Hook.new
+    @unconditional_prehooks = Hook.new
+    
+    irb_cmd = commands['shell']
+    @autoirb_hook  = ['autoirb', 
+                      Proc.new{|*args| irb_cmd.run(['shell']) if irb_cmd}]
+    
+    @debug_dbgr_hook = ['dbgdbgr',
+                        Proc.new{|*args| 
+                          if settings[:debugdbgr]
+                            $trepan_cmdproc  = self
+                            $trepan_frame    = @frame
+                          else
+                            $trepan_cmdproc  = nil
+                            $trepan_frame    = nil
+                          end}]
+    
+    display_cmd = commands['display']
+    @display_hook   = ['display', 
+                       Proc.new{|*args| display_cmd.run(['display']) if display_cmd}]
+    
+    # FIXME: generalize for any command run 
+    dis_cmd = commands['disassemble']
+    @autodis_hook  = ['autodis', 
+                      Proc.new{|*args| dis_cmd.run(['disassemble']) if dis_cmd}]
+    
+    list_cmd = commands['list']
+    @autolist_hook  = ['autolist', 
+                       Proc.new{|*args| list_cmd.run(['list']) if list_cmd}]
+    
+    @timer_hook     = ['timer', 
+                       Proc.new{|*args|
+                         now = Time.now
+                         msg("%g seconds" % 
+                             (now - @time_last)) if @time_last
+                         @time_last = now
+                       }]
+    @timer_posthook = ['timer', Proc.new{|*args| @time_last = Time.now}]
+    @trace_hook     = ['trace', 
+                       Proc.new{|*args| print_location}]
+    @tracebuf_hook  = ['tracebuffer', 
+                       Proc.new{|*args| @eventbuf.append(@event, @frame, 
+                                                         nil)}]
   end
 end
+
 if __FILE__ == $0
   # Demo it.
   hooks = Trepan::CmdProcessor::Hook.new

data/processor/list.rb

@@ -0,0 +1,123 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Trepan command list validation routines.  A String type is
+# usually passed in as the argument to validation routines.
+
+require 'rubygems'
+require 'require_relative'
+
+require_relative './validate'
+
+class Trepan
+  class CmdProcessor < VirtualCmdProcessor
+
+    # If last is less than first, assume last is a count rather than an
+    # end line number. If last is negative, range is [first+last..first].
+    def adjust_last(first, last)
+      last < first ? first + last - 1 : last
+    end
+
+    # Parse a list command. On success return:
+    #   - compiled method
+    #   - the line number - a Fixnum
+    #   - file name
+    #   - last line
+    def parse_list_cmd(position_str, listsize, center_correction=0)
+      cm = nil
+      if position_str.empty?
+        filename = frame.file
+        first = [1, frame.line - center_correction].max
+      else
+        list_cmd_parse = parse_list(position_str,
+                                    :file_exists_proc => file_exists_proc)
+        return [nil] * 4 unless list_cmd_parse
+        last = list_cmd_parse.num
+        position = list_cmd_parse.position
+
+        if position.is_a?(String)
+          if position == '-'
+            return no_frame_msg_for_list unless frame.line
+            first = [1, frame.line - 2*listsize - 1].max
+          elsif position == '.'
+            return no_frame_msg_for_list unless frame.line
+            if (second = list_cmd_parse.num)
+              first = frame.line 
+              last = adjust_last(first, second)
+            else
+              first = [1, frame.line - center_correction].max
+              last = first + listsize - 1
+            end
+          end
+          filename = frame.file
+          cm = frame.method
+        else
+          cm, filename, offset, offset_type = 
+            parse_position(position)
+
+          return [nil] * 4 unless filename
+          if offset_type == :line
+            first = offset
+          elsif cm
+            first, vm_offset = 
+              position_to_line_and_offset(cm, filename, position, 
+                                          offset_type)
+            unless first
+              errmsg("Unable to get location in #{meth_or_frame}")
+              return [nil] * 4 
+            end
+          elsif !offset 
+            first = 1
+          else
+            errmsg("Unable to parse list position #{position_str}")
+            return [nil] * 4
+          end
+        end
+      end
+      if last
+        first, last = [first + last, first] if last < 0
+        last = adjust_last(first, last)
+      else
+        first = [1, first - center_correction].max 
+        last = first + listsize - 1 unless last
+      end
+      LineCache::cache(filename) unless LineCache::cached?(filename)
+      return [cm, filename, first, last]
+    end
+    
+    def no_frame_msg_for_list
+      errmsg("No Ruby program loaded.")
+      return [nil] * 4
+    end
+    
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative 'mock'
+  require_relative 'frame'
+  dbgr, cmd = MockDebugger::setup('exit', false)
+  cmdproc  = cmd.proc
+  cmdproc.frame_initialize
+  cmdproc.instance_variable_set('@settings', 
+                                Trepan::CmdProcessor::DEFAULT_SETTINGS)
+  def foo; 5 end
+  def cmdproc.errmsg(msg)
+    puts msg
+  end
+  puts '-' * 20
+  p cmdproc.parse_list_cmd('.', 10)
+  p cmdproc.parse_list_cmd('-', 10)
+  p cmdproc.parse_list_cmd('foo', 10)
+  p cmdproc.parse_list_cmd('@0', 10)
+  p cmdproc.parse_list_cmd("#{__LINE__}", 10)
+  p cmdproc.parse_list_cmd("#{__FILE__}   @0", 10)
+  p '-' * 40
+  # require_relative '../lib/trepanning'; debugger
+  p cmdproc.parse_list_cmd("#{__FILE__}:#{__LINE__}", 10)
+  p cmdproc.parse_list_cmd("#{__FILE__} #{__LINE__}", 10)
+  p '-' * 40
+  p cmdproc.parse_list_cmd("cmdproc.errmsg", 10)
+  p cmdproc.parse_list_cmd("cmdproc.errmsg:@0", 10)
+  p cmdproc.parse_list_cmd("cmdproc.errmsg:@0", -10)
+end

data/processor/load_cmds.rb

@@ -7,8 +7,9 @@ require 'tmpdir'
 # Sets @commands, @aliases, @macros
 require 'rubygems'; require 'require_relative'
 require_relative '../app/complete'
+require_relative 'virtual'
 class Trepan
-  class CmdProcessor
+  class CmdProcessor < VirtualCmdProcessor
 
     attr_reader   :aliases         # Hash[String] of command names
                                    # indexed by alias name
@@ -16,6 +17,8 @@ class Trepan
                                    # 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
@@ -37,10 +40,14 @@ class Trepan
     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
+        $0 = old_dollar0
       elsif File.readable?(file_or_dir)
         # We use load in case we are reloading. 
         # 'require' would not be effective here
@@ -138,6 +145,7 @@ class Trepan
     # 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,

data/processor/location.rb

@@ -1,223 +1,228 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
-require 'pathname'  # For cleanpath
 require 'rubygems'; 
+require 'pathname'  # For cleanpath
 require 'linecache'
 require 'require_relative'
 require_relative 'disassemble'
 require_relative 'msg'
 require_relative 'frame'
-class Trepan
-  class CmdProcessor
-    attr_accessor :reload_on_change
-
-    def location_initialize
-      @reload_on_change = nil
+require_relative '../app/file'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+    unless defined?(EVENT2ICON)
+      # Event icons used in printing locations.
+      EVENT2ICON = {
+        'brkpt'          => 'xx',
+        'tbrkpt'         => 'x1',
+        'c-call'         => 'C>',
+        'c-return'       => '<C',
+        'step-call'      => '->',
+        'call'           => '->',
+        'class'          => '::',
+        'coverage'       => '[]',
+        'debugger-call'  => ':o',
+        'end'            => '-|',
+        'line'           => '--',
+        'raise'          => '!!',
+        'return'         => '<-',
+        'start'          => '>>',
+        'switch'         => 'sw',
+        'trace-var'      => '$V',
+        'unknown'        => '?!',
+        'vm'             => 'VM',
+        'vm-insn'        => '..',
+      } 
     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)
+  def canonic_file(filename, resolve=true)
+    # For now we want resolved filenames 
+    if @settings[:basename] 
+      return File.basename(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_on_change}
-      loc, junk, text = loc_and_text(source_location_info, 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
-            Rubinius::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)
+    if resolve
+      try_filename = LineCache::map_file(filename)
+      filename = try_filename || filename
+      if !File.exist?(filename) 
+        if (try_filename = find_load_path(filename))
+          return try_filename
+        elsif (try_filename = resolve_file_with_dir(filename))
+          return try_filename
+        else
+          return File.expand_path(Pathname.new(filename).cleanpath.to_s).
+            gsub(/\.rbc$/, '.rb')
+        end
       end
-      nil
     end
+    return filename.gsub(/\.rbc$/, '.rb')
+  end
 
-    # Get line +line_number+ from file named +filename+. Return "\n"
-    # 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]
-                })
-      # We use linecache first to give precidence to user-remapped
-      # file names
-      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)
+  # 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 => settings[:reload]}
+    loc, junk, text = loc_and_text(source_location_info, 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
+          Rubinius::OS_STARTUP_DIR
+        elsif '$rbx' == dir
+          compiler_file = '/lib/compiler/compiler.rb'
+          compiler_rb_path = 
+            $LOADED_FEATURES.find{|f| f.end_with?(compiler_file)}
+          if compiler_rb_path
+            compiler_rb_path[0...-(compiler_file.size)]
+          else
+            nil
           end
+        else
+          dir
         end
-      end
-      return nil unless line
-      return line.lstrip.chomp
+      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, opts=
-                     {:reload_on_change => @reload_on_change,
-                       :output => @settings[:highlight]
-                     })
-
-      vm_location = @frame.vm_location
-      filename = vm_location.method.active_path
-      line_no  = vm_location.line
-      static   = vm_location.static_scope
-      opts[:compiled_method] = top_scope(@frame.method)
-
-      if @frame.eval?
-        file = LineCache::map_script(static.script)
-        text = LineCache::getline(static.script, line_no, opts)
-        loc += " remapped #{canonic_file(file)}:#{line_no}"
-      else
-        text = line_at(filename, line_no, opts)
-        map_file, map_line = LineCache::map_file_line(filename, line_no)
-        if [filename, 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 "\n"
+  # there was a problem. Leading blanks are stripped off.
+  def line_at(filename, line_number, 
+              opts = {
+                :reload_on_change => @settings[:reload],
+                :output => @settings[:highlight]
+              })
+    # We use linecache first to give precidence to user-remapped
+    # file names
+    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
       end
-        
-      [loc, line_no, text]
-    end
-
-    def format_location(event=@event, frame=@frame, frame_index=@frame_index)
-      text      = nil
-      ev        = if event.nil? || 0 != frame_index
-                    '  ' 
-                  else
-                    (EVENT2ICON[event] || event)
-                  end
-
-      @line_no  = frame.vm_location.line
-
-      loc = source_location_info
-      loc, @line_no, text = loc_and_text(loc)
-      ip_str = frame.method ? " @#{frame.next_ip}" : ''
-
-      "#{ev} (#{loc}#{ip_str})"
     end
-
-    # FIXME: Use above format_location routine
-    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' == @core.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.vm_location.line
-
-      loc = source_location_info
-      loc, @line_no, text = loc_and_text(loc)
-      ip_str = frame.method ? " @#{frame.next_ip}" : ''
-
-      msg "#{ev} (#{loc}#{ip_str})"
-
-      # if %w(return c-return).member?(@core.event)
-      #   retval = Trepan::Frame.value_returned(@frame, @core.event)
-      #   msg 'R=> %s' % retval.inspect 
-      # end
-      
-      if text && !text.strip.empty?
-        old_maxstring = @settings[:maxstring]
-        @settings[:maxstring] = -1
-        msg text
-        @settings[:maxstring] = old_maxstring
-        @line_no -= 1
-      else
-        show_bytecode
+    return nil unless line
+    return line.lstrip.chomp
+  end
+  
+  def loc_and_text(loc, opts=
+                   {:reload_on_change => @settings[:reload],
+                     :output => @settings[:highlight]
+                   })
+    
+    vm_location = @frame.vm_location
+    filename = vm_location.method.active_path
+    line_no  = @frame.line
+    static   = vm_location.static_scope
+    opts[:compiled_method] = top_scope(@frame.method)
+    
+    if @frame.eval?
+      file = LineCache::map_script(static.script)
+      text = LineCache::getline(static.script, line_no, opts)
+      loc += " remapped #{canonic_file(file)}:#{line_no}"
+    else
+      text = line_at(filename, line_no, opts)
+      map_file, map_line = LineCache::map_file_line(filename, line_no)
+      if [filename, line_no] != [map_file, map_line]
+        loc += " remapped #{canonic_file(map_file)}:#{map_line}"
       end
     end
-
-    # def print_location(event=@event, frame=@frame)
-    #   text = format_location(event, frame)
-    #   if text && !text.strip.empty?
-    #     old_maxstring = @settings[:maxstring]
-    #     @settings[:maxstring] = -1
-    #     msg text
-    #     @settings[:maxstring] = old_maxstring
-    #     @line_no -= 1
-    #   else
-    #     show_bytecode
-    #   end
+    [loc, line_no, text]
+  end
+  
+  def format_location(event=@event, frame=@frame, frame_index=@frame_index)
+    text      = nil
+    ev        = if event.nil? || 0 != frame_index
+                  '  ' 
+                else
+                  (EVENT2ICON[event] || event)
+                end
+    
+    @line_no  = frame.line
+    
+    loc = source_location_info
+    loc, @line_no, text = loc_and_text(loc)
+    ip_str = frame.method ? " @#{frame.next_ip}" : ''
+    
+    "#{ev} (#{loc}#{ip_str})"
+  end
+  
+  # FIXME: Use above format_location routine
+  def print_location
+    text      = nil
+    ev        = if @event.nil? || 0 != @frame_index
+                  '  ' 
+                else
+                  (EVENT2ICON[@event] || @event)
+                end
+    
+    @line_no  = @frame.line
+    
+    loc = source_location_info
+    loc, @line_no, text = loc_and_text(loc)
+    ip_str = frame.method ? " @#{frame.next_ip}" : ''
+    
+    msg "#{ev} (#{loc}#{ip_str})"
+    
+    # if %w(return c-return).member?(@core.event)
+    #   retval = Trepan::Frame.value_returned(@frame, @core.event)
+    #   msg 'R=> %s' % retval.inspect 
     # end
-
-    def source_location_info
-      filename  = @frame.vm_location.method.active_path
-      canonic_filename = 
-        if @frame.eval?
-          'eval ' + safe_repr(@frame.eval_string.gsub("\n", ';').inspect, 20)
-        else
-          canonic_file(filename)
-        end
-      loc = "#{canonic_filename}:#{@frame.vm_location.line}"
-      return loc
-    end 
-
+    
+    if text && !text.strip.empty?
+      old_maxstring = @settings[:maxstring]
+      @settings[:maxstring] = -1
+      msg text
+      @settings[:maxstring] = old_maxstring
+      @line_no -= 1
+    else
+      show_bytecode
+    end
   end
+  
+  def source_location_info
+    filename  = @frame.vm_location.method.active_path
+    canonic_filename = 
+      if @frame.eval?
+        'eval ' + safe_repr(@frame.eval_string.gsub("\n", ';').inspect, 20)
+      else
+        canonic_file(filename, false)
+      end
+    loc = "#{canonic_filename}:#{@frame.line}"
+    return loc
+  end 
 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
-    end
-    def print_location
-      puts "#{@frame.source_container} #{frame.source_location[0]}"
-    end
-  end
-
-  proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
-  proc.instance_variable_set('@settings', {})
-  proc.frame_initialize
-  #proc.frame_setup(RubyVM::ThreadFrame.current)
+  require_relative './mock'
+  dbgr = MockDebugger::MockDebugger.new
+  proc = Trepan::CmdProcessor.new(dbgr)
+  proc.settings = {:directory => '$rbx:$cdir:$cwd'}
   proc.frame_initialize
+  frame = Trepan::Frame.new(self, 1, Rubinius::VM.backtrace(0)[0])
+  proc.instance_variable_set('@frame', frame)
 
-  proc.location_initialize
   puts proc.canonic_file(__FILE__)
-  proc.instance_variable_set('@settings', {:basename => true})
+  puts proc.canonic_file('lib/compiler/ast.rb')
+  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
+     frame = Trepan::Frame.new(self, 1, Rubinius::VM.backtrace(0)[0])
+     proc.instance_variable_set('@frame', frame)
+     puts proc.current_source_text
   END
 end