trepanning 0.1.3 → 0.1.4

data/processor/hook.rb

@@ -1,109 +1,108 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 require_relative 'virtual'
-class Trepan
-  class CmdProcessor < VirtualCmdProcessor
-    # Command processor hooks.
-    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
-        @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   :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}]
-      
-      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, 
-                                                           @core.hook_arg)}]
+    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}]
+    
+    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, 
+                                                         @core.hook_arg)}]
   end
 end
+
 if __FILE__ == $0
   # Demo it.
   hooks = Trepan::CmdProcessor::Hook.new

data/processor/list.rb

@@ -0,0 +1,146 @@
+# 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_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
+
+    def frame_filename
+      
+      container = frame_container(frame, false)
+      
+      # FIXME: put into a helper routine
+      # See also duplicate code in print_location
+      if container[0] != 'file'
+        try_container = container
+        while try_container[0] != 'file' && frame.prev do
+          frame            = frame.prev
+          try_container = frame_container(frame, false)
+        end
+        container = try_container if try_container[0] == 'file'
+      end
+      
+      return container[1]
+    end
+
+
+    # Parse a list command. On success return:
+    #   - the line number - a Fixnum
+    #   - file name
+    def parse_list_cmd(position_str, listsize, center_correction=0)
+      iseq = nil
+      if position_str.empty?
+        filename = frame_filename
+        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_filename
+        else
+          meth_or_frame, filename, offset, offset_type = 
+            parse_position(position)
+          return [nil] * 4 unless filename
+          if offset_type == :line
+            first = offset
+          elsif meth_or_frame
+            if iseq = meth_or_frame.iseq
+              iseq, first, vm_offset = 
+                position_to_line_and_offset(iseq, filename, position, offset_type)
+              unless first
+              errmsg("Unable to get location in #{meth_or_frame}")
+                return [nil] * 4 
+              end
+            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 [iseq, filename, first, last]
+    end
+    
+    def no_frame_msg_for_list
+      errmsg("No Ruby program loaded.")
+      return nil, nil, nil, nil
+    end
+    
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  if !(ARGV.size == 1 && ARGV[0] == 'noload')
+    ARGV[0..-1]    = ['noload']
+    load(__FILE__)
+  else    
+    require 'thread_frame'
+    require_relative '../app/mock'
+    require_relative './default'
+    require_relative 'frame'
+
+    # FIXME: Have to include before defining CmdProcessor!
+    require_relative '../processor' 
+
+    cmdproc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    cmdproc.frame_initialize
+    cmdproc.instance_variable_set('@settings', 
+                               Trepan::CmdProcessor::DEFAULT_SETTINGS)
+    cmdproc.frame_setup(RubyVM::ThreadFrame.current)
+    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 cmdproc.parse_list_cmd("#{__FILE__}:#{__LINE__}", 10)
+    p cmdproc.parse_list_cmd("#{__FILE__} #{__LINE__}", 10)
+    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
+end

data/processor/location.rb

@@ -8,6 +8,32 @@ require_relative 'virtual'
 class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
   include Trepan::Frame
 
+  unless defined?(EVENT2ICON)
+    # Event icons used in printing locations.
+    EVENT2ICON = {
+      'brkpt'          => 'xx',
+      'tbrkpt'         => 'x1',
+      'c-call'         => 'C>',
+      'c-return'       => '<C',
+      'call'           => '->',
+      'send'           => '=>',
+      'leave'          => '<=',
+      'class'          => '::',
+      'coverage'       => '[]',
+      'debugger-call'  => ':o',
+      'end'            => '-|',
+      'line'           => '--',
+      'raise'          => '!!',
+      'return'         => '<-',
+      'switch'         => 'sw',
+      'trace-var'      => '$V',
+      'unknown'        => '?!',
+      'vm'             => 'VM',
+      'vm-insn'        => '..',
+      'yield'          => '<>',
+    } 
+  end
+
   def canonic_container(container)
     [container[0], canonic_file(container[1])]
   end

data/processor/mock.rb

@@ -1,6 +1,6 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 # Mock setup for commands.
-require_relative 'main'
+require_relative '../processor'
 
 require_relative '../app/core'
 require_relative '../app/default'
@@ -93,7 +93,7 @@ module MockDebugger
     cmd.proc.frame_setup(RubyVM::ThreadFrame::current.prev)
     cmd.proc.event = 'debugger-call'
     sub_cmd = sub_class.new(cmd)
-    sub_cmd.summary_help(sub_cmd.name)
+    sub_cmd.summary_help(sub_cmd)
     puts
     sub_cmd.run([cmd.name]) if run
     return sub_cmd
@@ -101,12 +101,9 @@ module MockDebugger
   module_function :sub_setup
 
   def subsub_setup(sub_class, subsub_class, run=true)
+    sub_cmd = sub_setup(sub_class)
     subsub_name = subsub_class.const_get('PREFIX')
-    dbgr, cmd = setup(subsub_name[0], false)
-    cmd.proc.frame_setup(RubyVM::ThreadFrame::current.prev)
-    cmd.proc.event = 'debugger-call'
-    sub_cmd = sub_class.new(dbgr.core.processor, cmd)
-    subsub_cmd = subsub_class.new(cmd.proc, sub_cmd, subsub_name.join(''))
+    subsub_cmd = subsub_class.new(sub_cmd.proc, sub_cmd, subsub_name)
     subsub_cmd.summary_help(subsub_cmd.name)
     puts
     subsub_cmd.run([]) if run

data/processor/msg.rb

@@ -2,60 +2,72 @@
 # I/O related command processor methods
 require_relative '../app/util'
 require_relative 'virtual'
-class Trepan
-  class CmdProcessor < VirtualCmdProcessor
 
-    attr_accessor :ruby_highlighter
+begin require 'term/ansicolor'; rescue LoadError; end
 
-    def errmsg(message, opts={})
-      message = safe_rep(message) unless opts[:unlimited]
-      if @settings[:highlight] && defined?(Term::ANSIColor)
-        message = 
-          Term::ANSIColor.italic + message + Term::ANSIColor.reset 
-      end
-      @dbgr.intf[-1].errmsg(message)
-    end
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  attr_accessor :ruby_highlighter
 
-    def msg(message, opts={})
-      message = safe_rep(message) unless opts[:unlimited]
-      @dbgr.intf[-1].msg(message)
-    end
+  def confirm(msg, default)
+    @settings[:confirm] ? @dbgr.intf[-1].confirm(msg, default) : true
+  end
 
-    def msg_nocr(message, opts={})
+  def errmsg(message, opts={})
+    if message.kind_of?(Array)
+      message.each do |mess|
+        errmsg(mess, opts)
+      end
+      return
+    else
       message = safe_rep(message) unless opts[:unlimited]
-      @dbgr.intf[-1].msg_nocr(message)
     end
-
-    def read_command()
-      @dbgr.intf[-1].read_command(@prompt)
+    if @settings[:highlight] && defined?(Term::ANSIColor)
+      message = 
+        Term::ANSIColor.italic + message + Term::ANSIColor.reset 
     end
+    @dbgr.intf[-1].errmsg(message)
+  end
 
-    def ruby_format(text)
-      return text unless settings[:highlight]
-      unless @ruby_highlighter
-        begin
-          require 'coderay'
-          require 'term/ansicolor'
-          @ruby_highlighter = CodeRay::Duo[:ruby, :term]
-        rescue LoadError
-          return text
-        end
-      end
-      return @ruby_highlighter.encode(text)
-    end
+  def msg(message, opts={})
+    message = safe_rep(message) unless opts[:unlimited]
+    message = ruby_format(message) if opts[:code]
+    @dbgr.intf[-1].msg(message)
+  end
 
-    def safe_rep(str)
-      Util::safe_repr(str, @settings[:maxstring])
-    end
+  def msg_nocr(message, opts={})
+    message = safe_rep(message) unless opts[:unlimited]
+    @dbgr.intf[-1].msg_nocr(message)
+  end
 
-    def section(message, opts={})
-      message = safe_rep(message) unless opts[:unlimited]
-      if @settings[:highlight] && defined?(Term::ANSIColor)
-        message = 
-          Term::ANSIColor.bold + message + Term::ANSIColor.reset 
+  def read_command()
+    @dbgr.intf[-1].read_command(@prompt)
+  end
+
+  def ruby_format(text)
+    return text unless settings[:highlight]
+    unless @ruby_highlighter
+      begin
+        require 'coderay'
+        require 'term/ansicolor'
+        @ruby_highlighter = CodeRay::Duo[:ruby, :term]
+      rescue LoadError
+        return text
       end
-      @dbgr.intf[-1].msg(message)
     end
+    return @ruby_highlighter.encode(text)
+  end
 
+  def safe_rep(str)
+    Trepan::Util::safe_repr(str, @settings[:maxstring])
   end
+
+  def section(message, opts={})
+    message = safe_rep(message) unless opts[:unlimited]
+    if @settings[:highlight] && defined?(Term::ANSIColor)
+      message = 
+        Term::ANSIColor.bold + message + Term::ANSIColor.reset 
+    end
+    @dbgr.intf[-1].msg(message)
+  end
+
 end

data/processor/running.rb

@@ -24,7 +24,11 @@ class Trepan
       @next_level      = 32000 # I'm guessing the stack size can't
                                # ever reach this
       @next_thread     = nil
-      @core.step_count = -1    # No more event stepping
+      if @settings[:traceprint]
+        @core.step_count = 1    # traceprint will avoid stopping
+      else
+        @core.step_count = -1    # No more event stepping
+      end
       @leave_cmd_loop  = true  # Break out of the processor command loop.
     end
 
@@ -90,7 +94,6 @@ class Trepan
       when '<'
         opts[:stop_events] = Set.new(%w(c-return return))
       when '>'
-        opts[:stop_events] = Set.new(%w(c-call call))
         if step_cmd.size > 1 && step_cmd[-2..-2] == '<'
           opts[:stop_events] = Set.new(%w(c-call c-return call return))
         else
@@ -119,7 +122,7 @@ class Trepan
 
       return true if 
         !frame || (@next_level < @frame.stack_size &&
-                   Thread.current == @next_thread)
+                   Thread.current == @next_thread && @event != 'raise')
 
       new_pos = [@frame.source_container, frame_line,
                  @stack_size, @current_thread, @event, @frame.pc_offset]

data/processor/subcmd.rb

@@ -1,6 +1,7 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 # gdb-like subcommand processing.
 
+### FIXME: move into command/base/submgr.rb
 class Trepan
   class Subcmd
 
@@ -14,17 +15,24 @@ class Trepan
     
     # Find subcmd in self.subcmds
     def lookup(subcmd_prefix, use_regexp=true)
-      compare = if use_regexp 
-                  lambda{|name| name.to_s =~ /^#{subcmd_prefix}/}
-                else
-                  lambda{|name| 0 == name.to_s.index(subcmd_prefix)}
-                end
+      compare = 
+        if !@cmd.settings[:abbrev]
+          lambda{|name| name.to_s == subcmd_prefix}
+        elsif use_regexp 
+          lambda{|name| name.to_s =~ /^#{subcmd_prefix}/}
+        else
+          lambda{|name| 0 == name.to_s.index(subcmd_prefix)}
+        end
+      candidates = []
       @subcmds.each do |subcmd_name, subcmd|
         if compare.call(subcmd_name) &&
             subcmd_prefix.size >= subcmd.class.const_get(:MIN_ABBREV)
-          return subcmd
+          candidates << subcmd
         end
       end
+      if candidates.size == 1
+        return candidates.first
+      end
       return nil
     end
 
@@ -61,48 +69,15 @@ class Trepan
       @cmdlist << subcmd_name
     end
 
-    # Run subcmd_name with args using obj for the environent
-    def run( subcmd_name, arg)
-      entry=lookup(subcmd_name)
-      if entry
-        entry['callback'].send(arg)
-      else
-        @proc.undefined_cmd(entry.__class__.name, subcmd_name)
-      end
-    end
-
     # help for subcommands
     # Note: format of help is compatible with ddd.
     def help(*args)
-
-      msg args
-      subcmd_prefix = args[0]
-      if not subcmd_prefix or subcmd_prefix.size == 0
-        @proc.msg(self.doc)
-        @proc.msg("\nList of %s subcommands:\n" % [@name])
-        @list.each do |subcmd_name|
-          subcmd_helper(subcmd_name, obj, true, true)
-        end
-
-        entry = lookup(subcmd_prefix)
-        if entry and entry.respond_to? :help
-          entry.help(args)
-        else
-          @proc.errmsg("Unknown 'help %s' subcommand %s" %
-                       [@name, subcmd_prefix])
-        end
-      end
+      # Not used but tested for.
     end
 
     def list
       @subcmds.keys.sort
     end
-    
-    # Error message when a subcommand doesn't exist.
-    def undefined_subcmd(cmd, subcmd)
-      @proc.errmsg('Undefined "%s" command: "%s". Try "help".' % 
-                   [cmd, subcmd])
-    end
   end
 end
 
@@ -110,7 +85,7 @@ end
 if __FILE__ == $0
 
   require_relative 'mock'
-  require_relative 'command/base/cmd'
+  require_relative 'command'
 
   class Trepan::TestCommand < Trepan::Command