rbx-trepanning 0.0.1-universal-rubinius

data/processor/running.rb

@@ -0,0 +1,230 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require 'set'
+## require_relative '../app/core'
+class Trepan
+  class CmdProcessor
+
+
+    attr_accessor :ignore_file_re  # Hash[file_re] -> String
+                                   # action. File re's we don't want
+                                   # to stop while stepping. Like
+                                   # ignore_methods. Skipping kernel methods
+                                   # is handled this way.
+    attr_accessor :ignore_methods  # Hash[CompiledMethod] -> String:
+                                   # action. Methods we don't want to
+                                   # ever stop while stepping. action
+                                   # is 'step' or 'next'.
+    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 :step_count
+    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(how_to_continue)
+      @next_thread     = nil
+      @step_count      = -1    # No more event stepping
+      if 'step-finish' == how_to_continue
+        step_to_return_or_yield
+        how_to_continue = 'step'
+      end
+      @return_to_program = how_to_continue
+    end
+
+    # Does whatever setup needs to be done to set to ignore stepping
+    # to the finish of the current method. Elsewhere in
+    # "skipping_step?" we do the checking.
+    def finish(level_count=0, opts={})
+      step_to_return_or_yield
+      continue('finish')
+      @next_thread       = @current_thread
+
+      # # 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
+
+    def step_finish
+      step_to_return_or_yield
+      continue('step')
+      @next_thread       = @current_thread
+    end
+
+    # # Does whatever needs to be done to set to "next" program
+    # # execution.
+    # def next(step_count=1, opts={})
+    #   step(step_count, opts)
+    #   @next_thread     = Thread.current
+    # end
+
+    # Does whatever needs to be done to set to step program
+    # execution.
+    def step(how_to_continue, step_count=1, opts={}, condition=nil)
+      continue(how_to_continue)
+      @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='exit')
+      @next_level      = 32000 # I'm guessing the stack size can't
+                               # ever reach this
+      @next_thread     = nil
+      @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['exit'].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
+      @ignore_file_re  = {}
+      @ignore_methods  = {}
+
+      @step_count      = 0
+      @stop_condition  = nil
+      @stop_events     = nil
+      @to_method       = nil
+    end
+
+    # If we are not in some kind of steppable event, return 
+    # false. If we are in a steppable event, update step state
+    # and return true if the step count is 0 and other conditions
+    # like the @settings[:different] are met.
+    def stepping_skip?
+
+      debug_loc = "#{frame.vm_location.describe} #{frame.line}" if  
+        @settings[:debugskip]
+
+      if @step_count < 0  
+        # We may eventually stop for some other reason, but it's not
+        # because we were stepping here.
+        msg "skip: step_count < 0 #{debug_loc}" if @settings[:debugskip]
+        return false 
+      end
+
+      @ignore_file_re.each_pair do |file_re, action|
+        if frame.vm_location.method.active_path =~ file_re
+          @return_to_program = action
+          msg "skip re: #{debug_loc}" if @settings[:debugskip]
+          return true
+        end
+      end
+
+      ms = frame.method.scope
+      @ignore_methods.each do |m, val|
+        # Guard against crap put into @ignore_methods
+        unless m.respond_to?(:scope)
+          @ignore_methods.delete(m)
+          next
+        end
+        if ms == m.scope
+          msg "skip ignore method: #{debug_loc}" if @settings[:debugskip]
+          @return_to_program = val
+          return true
+        end
+      end
+
+      # Only skip on these kinds of events
+      unless %w(step-call line).include?(@event)
+        msg "skip non-line: #{@event} #{debug_loc}" if @settings[:debugskip]
+        return false
+      end
+
+      # We are in some kind of stepping event, so do whatever we
+      # do to record that we've hit the step. Whether we decide
+      # to stop, will be done after recording the step took place.
+      @step_count -= 1 unless step_count == 0
+      new_pos = [@frame.file, @frame.line,
+                 @stack_size, @current_thread, @event]
+
+
+      # Decide whether this step is skippable.
+      should_skip = false
+
+      if @settings[:debugskip]
+        msg("last: #{@last_pos.inspect}, ")
+        msg("new:  #{new_pos.inspect}")
+        msg("skip: #{should_skip.inspect}, event: #{@event}")
+      end
+
+      @last_pos[2] = new_pos[2] if 'nostack' == @different_pos
+      condition_met = @step_count == 0
+
+      #     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']
+
+      should_skip = ((@last_pos[0..3] == new_pos[0..3] && @different_pos) ||
+                  !condition_met)
+
+      msg("should_skip: #{should_skip}, #{debug_loc}") if @settings[:debugskip]
+
+      @last_pos = new_pos
+
+      unless should_skip
+        # Set up the default values for the
+        # next time we consider step skipping.
+        @different_pos = @settings[:different]
+        # @stop_events   = nil
+      end
+
+      @return_to_program = 'step' if should_skip && !@return_to_program
+      return should_skip
+    end
+
+  end
+end

data/processor/stepping.rb

@@ -0,0 +1,115 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../app/iseq'
+class Trepan
+  class CmdProcessor
+    include Trepanning::ISeq
+    
+    # It might be interesting to allow stepping within a parent frame
+    def step_over_by(step, frame=@top_frame)
+      
+      f = frame
+      
+      ip = -1
+      
+      meth = f.method
+      possible_line = f.line + step
+      fin_ip = meth.first_ip_on_line_after(possible_line, f.next_ip)
+      
+      if fin_ip <= -1
+        return step_to_parent('line')
+      end
+
+      set_breakpoints_between(meth, f.next_ip, fin_ip)
+    end
+    
+    def step_to_return_or_yield
+      f = @frame
+      unless f
+        msg 'Unable to find frame to finish'
+        return
+      end
+      
+      meth = f.method
+      ip = -1
+      fin_ip = meth.lines.last
+      
+      set_breakpoints_on_return_between(meth, f.next_ip, fin_ip)
+    end
+
+    def step_to_parent(event='return')
+      f = parent_frame
+      unless f
+        errmsg "Unable to find parent frame to step to next"
+        return nil 
+      end
+      meth = f.method
+      ip   = f.ip
+
+      bp = Trepanning::Breakpoint.for_ip(meth, ip, 
+                                         {:event => event, :temp => true})
+      bp.scoped!(parent_frame.scope)
+      bp.activate
+      
+      return bp
+    end
+
+    # Sets temporary breakpoints in met between start_ip and fin_ip.
+    # We also set a temporary breakpoint in the caller.
+    def set_breakpoints_between(meth, start_ip, fin_ip)
+      opts = {:event => 'line', :temp  => true}
+      ips = goto_between(meth, start_ip, fin_ip)
+      bps = []
+      
+      if ips.kind_of? Fixnum
+        if ips == -1
+          errmsg "No place to step to"
+          return nil
+        elsif ips == -2
+          bps << step_to_parent(event='line')
+          ips = []
+        else
+          ips = [ips]
+        end
+      end
+
+      msg "temp ips: #{ips.inspect}" if settings[:debugstep]
+      ips.each do |ip|
+        bp = Trepanning::Breakpoint.for_ip(meth, ip, opts)
+        bp.scoped!(@frame.scope)
+        bp.activate
+        bps << bp
+      end
+      first_bp = bps[0]
+      bps[1..-1].each do |bp| 
+        first_bp.related_with(bp) 
+      end
+      return first_bp
+    end
+    
+    def set_breakpoints_on_return_between(meth, start_ip, fin_ip)
+      ips = yield_or_return_between(meth, start_ip, fin_ip)
+      if ips.empty?
+        errmsg '"ret" or "yield_stack" opcode not found'
+        return []
+      end
+      
+      bp1 = Trepanning::Breakpoint.for_ip(meth, ips[0], 
+                                          { :event => 'return',
+                                            :temp  => true})
+      bp1.scoped!(@frame.scope)
+      bp1.activate
+      result = [bp1]
+      
+      1.upto(ips.size-1) do |i| 
+        bp2 = Trepanning::Breakpoint.for_ip(meth, ips[i], 
+                                            { :event => 'return',
+                                              :temp  => true})
+        bp2.scoped!(@frame.scope)
+        bp1.related_with(bp2)
+        bp2.activate
+        result << bp2
+      end
+      return result
+    end
+  end
+end

data/processor/subcmd.rb

@@ -0,0 +1,160 @@
+# 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.to_s] = 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 'rubygems'; require 'require_relative'
+  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