rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor/mock.rb

@@ -0,0 +1,138 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Mock setup for commands.
+require 'rubygems'; require 'require_relative'
+
+require_relative '../processor'
+
+# require_relative '../app/core'
+require_relative '../app/default'
+require_relative '../app/frame'
+require_relative '../interface/user'  # user interface (includes I/O)
+
+module MockDebugger
+  class MockDebugger
+    attr_accessor :trace_filter # Procs/Methods we ignore.
+
+    attr_accessor :frame        # Actually a "Rubinius::Location object
+    attr_accessor :core         # access to Debugger::Core instance
+    attr_accessor :intf         # The way the outside world interfaces with us.
+    attr_reader   :initial_dir  # String. Current directory when program
+                                # started. Used in restart program.
+    attr_accessor :restart_argv # How to restart us, empty or nil. 
+                                # Note restart[0] is typically $0.
+    attr_reader   :settings     # Hash[:symbol] of things you can configure
+    attr_accessor :processor
+
+    # FIXME: move more stuff of here and into Trepan::CmdProcessor
+    # These below should go into Trepan::CmdProcessor.
+    attr_reader :cmd_argstr, :cmd_name, :vm_locations, :current_frame, 
+                :debugee_thread, :completion_proc
+
+    def initialize(settings={:start_frame=>1})
+      @before_cmdloop_hooks = []
+      @settings             = Trepan::DEFAULT_SETTINGS.merge(settings)
+      @intf                 = [Trepan::UserInterface.new(nil, nil,
+                                                         :history_save=>false)]
+      @vm_locations         = Rubinius::VM.backtrace(settings[:start_frame], true)
+      @current_frame        = Trepan::Frame.new(self, 0, @vm_locations[0])
+      @debugee_thread       = Thread.current
+      @frames               = []
+      @restart_argv         = Rubinius::OS_STARTUP_DIR
+
+      ## @core                 = Trepan::Core.new(self)
+      @trace_filter         = []
+
+      @completion_proc = Proc.new{|str| str}
+
+      # Don't allow user commands in mocks.
+      ## @core.processor.settings[:user_cmd_dir] = nil 
+
+    end
+
+    def frame(num)
+      @frames[num] ||= Trepan::Frame.new(self, num, @vm_locations[num])
+    end
+  end
+
+  # Common Mock debugger setup 
+  def setup(name=nil, show_constants=true)
+    unless name
+      loc = Rubinius::VM.backtrace(1, true)[0]
+      name = File.basename(loc.file, '.rb')
+    end
+
+    if ARGV.size > 0 && ARGV[0] == 'debug'
+      require_relative '../lib/trepanning'
+      dbgr = Trepan.new
+      dbgr.debugger
+    else
+      dbgr = MockDebugger.new(:start_frame=>2)
+    end
+
+    cmdproc = Trepan::CmdProcessor.new(dbgr)
+    cmdproc.frame = dbgr.frame(0)
+    dbgr.processor = cmdproc
+    
+    cmdproc.load_cmds_initialize
+    cmds = cmdproc.commands
+    cmd  = cmds[name]
+    cmd.proc.frame_setup
+    cmd.proc.event = 'debugger-call'
+    show_special_class_constants(cmd) if show_constants
+
+    def cmd.confirm(prompt, default)
+      true
+    end
+    def cmd.msg_nocr(message, opts={})
+      print message
+    end
+    def cmd.section(message, opts={})
+      puts "Section: #{message}"
+    end
+
+    return dbgr, cmd
+  end
+  module_function :setup
+
+  def sub_setup(sub_class, run=true)
+    sub_name = sub_class.const_get('PREFIX')
+    dbgr, cmd = setup(sub_name[0], false)
+    sub_cmd = sub_class.new(cmd)
+    sub_cmd.summary_help(sub_cmd.name)
+    puts
+    sub_cmd.run([cmd.name]) if run
+    return sub_cmd
+  end
+  module_function :sub_setup
+
+  def subsub_setup(sub_class, subsub_class, run=true)
+    subsub_name = subsub_class.const_get('PREFIX')
+    dbgr, cmd = setup(subsub_name[0], false)
+    sub_cmd = sub_class.new(dbgr.processor, cmd)
+    subsub_cmd = subsub_class.new(cmd.proc, sub_cmd, subsub_name.join(''))
+    subsub_cmd.run([subsub_cmd.name]) if run
+    return subsub_cmd
+  end
+  module_function :subsub_setup
+
+  def show_special_class_constants(cmd)
+    puts 'ALIASES: %s' % [cmd.class.const_get('ALIASES').inspect] if
+      cmd.class.constants.member?(:ALIASES)
+    %w(CATEGORY MIN_ARGS MAX_ARGS 
+       NAME NEED_STACK SHORT_HELP).each do |name|
+      puts '%s: %s' % [name, cmd.class.const_get(name).inspect]
+    end
+    puts '-' * 30
+    puts cmd.class.const_get('HELP')
+    puts '=' * 30
+  end
+  module_function :show_special_class_constants
+
+end
+
+if __FILE__ == $0
+  dbgr = MockDebugger::MockDebugger.new
+  p dbgr.settings
+  puts '=' * 10
+  # p dbgr.core.processor.settings
+end

data/processor/msg.rb

@@ -0,0 +1,74 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# I/O related command processor methods
+require 'rubygems'; require 'require_relative'
+require_relative '../app/util'
+require_relative 'virtual'
+
+begin require 'term/ansicolor'; rescue LoadError; end
+
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  attr_accessor :ruby_highlighter
+
+  def confirm(msg, default)
+    @settings[:confirm] ? @dbgr.intf[-1].confirm(msg, default) : true
+  end
+
+  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]
+    end
+    if @settings[:highlight] && defined?(Term::ANSIColor)
+      message = 
+        Term::ANSIColor.italic + message + Term::ANSIColor.reset 
+    end
+    @dbgr.intf[-1].errmsg(message)
+  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 msg_nocr(message, opts={})
+    message = safe_rep(message) unless opts[:unlimited]
+    @dbgr.intf[-1].msg_nocr(message)
+  end
+
+  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
+    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

@@ -0,0 +1,244 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'set'
+require 'rubygems'; require 'require_relative'
+require_relative 'virtual'
+class Trepan
+  class CmdProcessor < VirtualCmdProcessor
+
+    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(return_to_program)
+      @next_level      = 32000 # I'm guessing the stack size can't
+                               # ever reach this
+      @next_thread     = nil
+      @step_count      = -1    # No more event stepping
+      if 'step-finish' == return_to_program
+        step_to_return_or_yield
+        return_to_program = 'step'
+      end
+      @return_to_program = return_to_program
+    end
+
+    # Does whatever setup needs to be done to set to ignore stepping
+    # to the finish of the current method. Elsewhere in
+    # "stepping_skip?" we do the checking.
+    def finish(level_count=0, opts={})
+      step_to_return_or_yield
+      continue('finish')
+      @next_level        = @stack_size - level_count
+      @next_thread       = @current_thread
+
+      @step_count = 2 if 'nostack' == opts[:different_pos]
+
+      # # 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', step_count, opts)
+      @next_level      = opts[:next_level] || @stack_size
+      @next_thread     = Thread.current
+    end
+
+    # Does whatever needs to be done to set to step program
+    # execution.
+    def step(return_to_program, step_count=1, opts={}, condition=nil)
+      continue(return_to_program)
+      @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?
+
+      if @settings[:'debugskip']
+        puts "diff: #{@different_pos}, event : #{@event}, #{@stop_events.inspect}" 
+        puts "step_count  : #{@step_count}" 
+        puts "next_level  : #{@next_level},    ssize : #{@stack_size}" 
+        puts "next_thread : #{@next_thread},   thread: #{Thread.current}" 
+      end
+
+      return true if 
+        !frame || (@next_level < @stack_size &&
+                   Thread.current == @next_thread && @event != 'raise')
+
+      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 return).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}")
+        msg("@step_count: #{@step_count}")
+      end
+
+      @last_pos[2] = new_pos[2] if 'nostack' == @different_pos
+      condition_met = 
+          if @stop_condition
+            puts "stop_cond #{@stop_condition}" 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']
+            @step_count == 0
+          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 || 'finish' == @return_to_program)
+      return should_skip
+    end
+
+  end
+end

data/processor/stepping.rb

@@ -0,0 +1,135 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../app/iseq'
+require_relative 'virtual'
+class Trepan
+  class CmdProcessor < VirtualCmdProcessor
+
+    def stepping_initialize
+      @step_brkpts  = []
+    end
+
+    def stepping_breakpoint_finalize
+      @step_brkpts.each do |bp| 
+        bp.remove!
+      end
+    end
+
+    def remove_step_brkpt
+      return unless @step_bp
+      @step_brkpts = @step_brkpts.select do |bp| 
+        (bp != @step_bp) && bp.active?
+      end
+      @step_bp.remove!
+    end
+
+    # It might be interesting to allow stepping within a parent frame
+    def step_over_by(step, frame=@top_frame)
+      
+      f = frame
+      
+      meth = f.method
+      possible_line = f.line + step
+      next_ip = f.next_ip == f.ip ? f.next_ip + 1 : f.next_ip
+      # BUGGY: remove after writing a decent test case for this.
+      # See beginning of rbx-require/require_relative.
+      fin_ip = meth.first_ip_on_line_after(possible_line, f.next_ip)
+      # fin_ip = meth.first_ip_on_line_after(possible_line, next_ip)
+      
+      unless fin_ip
+        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
+      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 = 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 = ISeq.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 = Breakpoint.for_ip(meth, ip, opts)
+        bp.scoped!(@frame.scope)
+        bp.activate
+        bps << bp
+      end
+      @step_brkpts += bps
+      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 = ISeq::yield_or_return_between(meth, start_ip, fin_ip)
+      if ips.empty?
+        errmsg '"ret" or "yield_stack" opcode not found'
+        return []
+      end
+      
+      bp1 = 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 = Breakpoint.for_ip(meth, ips[i], 
+                                { :event => 'return',
+                                  :temp  => true})
+        bp2.scoped!(@frame.scope)
+        bp1.related_with(bp2)
+        bp2.activate
+        result << bp2
+      end
+      @step_brkpts += result
+      return result
+    end
+  end
+end