trepanning 0.0.4

data/processor/running.rb

@@ -0,0 +1,170 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../app/core'
+class Trepan
+  class CmdProcessor
+
+    attr_accessor :stop_condition  # String or nil. When not nil
+                                   # this has to eval non-nil
+                                   # in order to stop.
+    attr_accessor :stop_events     # Set or nil. If not nil, only
+                                   # events in this set will be
+                                   # considered for stopping. This is
+                                   # like core.step_events (which
+                                   # could be used instead), but it is
+                                   # a set of event names rather than
+                                   # a bitmask and it is intended to
+                                   # be more temporarily changed via
+                                   # "step>" or "step!" commands.
+    attr_accessor :to_method
+                                  
+    # Does whatever needs to be done to set to continue program
+    # execution.
+    # FIXME: turn line_number into a condition.
+    def continue
+      @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
+      @leave_cmd_loop  = true  # Break out of the processor command loop.
+    end
+
+    # Does whatever needs to be done to set to "next" program
+    # execution.
+    def finish(level_count=0, opts={})
+      step(0, opts)
+      @next_level        = @frame.stack_size - level_count
+      @next_thread       = Thread.current
+      @stop_events       = Set.new(%w(return))
+
+      # Try high-speed (run-time-assisted) method
+      @frame.trace_off   = true  # No more tracing in this frame
+      @frame.return_stop = true  # don't need to 
+    end
+    # Does whatever needs to be done to set to "next" program
+    # execution.
+    def next(step_count=1, opts={})
+      step(step_count, opts)
+      @next_level      = @top_frame.stack_size
+      @next_thread     = Thread.current
+    end
+
+    # Does whatever needs to be done to set to step program
+    # execution.
+    def step(step_count=1, opts={}, condition=nil)
+      continue
+      @core.step_count = step_count
+      @different_pos   = opts[:different_pos] if 
+        opts.keys.member?(:different_pos)
+      @stop_condition  = condition
+      @stop_events     = opts[:stop_events]   if 
+        opts.keys.member?(:stop_events)
+      @to_method       = opts[:to_method]
+    end
+
+    def quit(cmd='quit')
+      @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
+      @leave_cmd_loop  = true  # Break out of the processor command loop.
+      @settings[:autoirb] = false
+      @cmdloop_prehooks.delete_by_name('autoirb')
+      @commands['quit'].run([cmd])
+    end
+
+    def parse_next_step_suffix(step_cmd)
+      opts = {}
+      case step_cmd[-1..-1]
+      when '-'
+        opts[:different_pos] = false
+      when '+'
+        opts[:different_pos] = 'nostack'
+      when '='
+        opts[:different_pos] = true
+      when '!'
+        opts[:stop_events] = Set.new(%w(raise))
+      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
+          opts[:stop_events] = Set.new(%w(c-call call))
+        end
+      end
+      return opts
+    end
+
+    def running_initialize
+      @stop_condition  = nil
+      @stop_events     = nil
+      @to_method       = nil
+    end
+
+    def stepping_skip?
+
+      return true if @core.step_count < 0
+
+      if @settings[:'debugskip']
+        msg "diff: #{@different_pos}, event : #{@event}, #{@stop_events.inspect}" 
+        msg "step_count  : #{@core.step_count}" 
+        msg "next_level  : #{@next_level},    ssize : #{@stack_size}" 
+        msg "next_thread : #{@next_thread},   thread: #{Thread.current}" 
+      end
+
+      return true if 
+        !frame || (@next_level < @frame.stack_size &&
+                   Thread.current == @next_thread)
+
+      new_pos = [@frame.source_container, frame_line,
+                 @stack_size, @current_thread, @event, @frame.pc_offset]
+
+      skip_val = @stop_events && !@stop_events.member?(@event)
+
+      # If the last stop was a breakpoint, don't stop again if we are at
+      # the same location with a line event.
+      skip_val |= (@last_pos[4] == 'brkpt' && 
+                   @event == 'line' &&
+                   @frame.pc_offset == @last_pos[5])
+
+      if @settings[:'debugskip']
+        puts "skip: #{skip_val.inspect}, last: #{@last_pos}, new: #{new_pos}" 
+      end
+
+      @last_pos[2] = new_pos[2] if 'nostack' == @different_pos
+      unless skip_val
+        condition_met = 
+          if @stop_condition
+            puts 'stop_cond' if @settings[:'debugskip']
+            debug_eval_no_errmsg(@stop_condition)
+          elsif @to_method
+            puts "method #{@frame.method} #{@to_method}" if 
+              @settings[:'debugskip']
+            @frame.method == @to_method
+          else
+            puts 'uncond' if @settings[:'debugskip']
+            true
+          end
+          
+        msg("condition_met: #{condition_met}, last: #{@last_pos}, " +
+             "new: #{new_pos}, different #{@different_pos.inspect}") if 
+          @settings[:'debugskip']
+        skip_val = ((@last_pos[0..3] == new_pos[0..3] && @different_pos) ||
+                    !condition_met)
+      end
+
+      @last_pos = new_pos if !@stop_events || @stop_events.member?(@event)
+
+      unless skip_val
+        # Set up the default values for the
+        # next time we consider skipping.
+        @different_pos = @settings[:different]
+        @stop_events   = nil
+      end
+
+      return skip_val
+    end
+
+  end
+end

data/processor/subcmd.rb

@@ -0,0 +1,159 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# gdb-like subcommand processing.
+
+class Trepan
+  class Subcmd
+
+    attr_reader :subcmds
+    def initialize(cmd)
+      @cmd     = cmd
+      @subcmds = {}
+      @cmdlist = []
+    end
+    
+    # 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
+      @subcmds.each do |subcmd_name, subcmd|
+        if compare.call(subcmd_name) &&
+            subcmd_prefix.size >= subcmd.class.const_get(:MIN_ABBREV)
+          return subcmd
+        end
+      end
+      return nil
+    end
+
+    # Show short help for a subcommand.
+    def short_help(subcmd_cb, subcmd_name, label=false)
+      entry = self.lookup(subcmd_name)
+      if entry
+        if label
+          prefix = entry.name
+        else
+          prefix = ''
+        end
+        if entry.respond_to?(:short_help)
+          prefix += ' -- ' if prefix 
+          @proc.msg(prefix + entry.short_help)
+        end
+      else
+        @proc.undefined_subcmd("help", subcmd_name)
+      end
+    end
+
+    # Add subcmd to the available subcommands for this object.
+    # It will have the supplied docstring, and subcmd_cb will be called
+    # when we want to run the command. min_len is the minimum length
+    # allowed to abbreviate the command. in_list indicates with the
+    # show command will be run when giving a list of all sub commands
+    # of this object. Some commands have long output like "show commands"
+    # so we might not want to show that.
+    def add(subcmd_cb, subcmd_name=nil)
+      subcmd_name ||= subcmd_cb.name
+      @subcmds[subcmd_name] = subcmd_cb
+
+      # We keep a list of subcommands to assist command completion
+      @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
+    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
+
+# When invoked as main program, invoke the debugger on a script
+if __FILE__ == $0
+
+  require_relative 'mock'
+  require_relative 'command/base/cmd'
+
+  class Trepan::TestCommand < Trepan::Command
+    
+    HELP = 'Help string string for testing'
+    CATEGORY = 'data'
+    MIN_ARGS = 0
+    MAX_ARGS = 5
+    NAME_ALIASES = %w(test)
+    
+    def initialize(proc); @proc  = proc end
+    
+    def run(args); puts 'test command run' end
+  end
+  
+  class TestTestingSubcommand
+    HELP = 'Help string for test testing subcommand'
+    
+    def initialize; @name  = 'testing' end
+    
+    SHORT_HELP = 'This is short help for test testing'
+    MIN_ABREV = 4
+    IN_LIST   = true
+    def run(args); puts 'test testing run' end
+  end
+
+  d = MockDebugger::MockDebugger.new
+  testcmd    = Trepan::TestCommand.new(nil)
+  # testcmd.debugger = d
+  testcmd.proc     = d.core.processor
+  # testcmdMgr = Subcmd.new('test', testcmd)
+  # testsub = TestTestingSubcommand.new
+  # testcmdMgr.add(testsub)
+  
+  # %w(tes test testing testing1).each do |prefix|
+  #   x = testcmdMgr.lookup(prefix)
+  #   puts x ? x.name : 'Non'
+  # end
+  
+  # testcmdMgr.short_help(testcmd, 'testing')
+  # testcmdMgr.short_help(testcmd, 'test', true)
+  # testcmdMgr.short_help(testcmd, 'tes')
+  # puts testcmdMgr.list()
+  # testsub2 = TestTestingSubcommand.new
+  # testsub2.name = 'foobar'
+  # testcmdMgr.add(testsub2)
+  # puts testcmdMgr.list()
+end