rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor/eventbuf.rb

@@ -0,0 +1,101 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# For recording hook events in a buffer for review later. Make use of
+# Trace::Buffer for this prupose.
+
+require 'rubygems'; require 'require_relative'
+require 'linecache'
+require_relative '../app/eventbuffer'
+require_relative 'virtual'
+
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  attr_reader :eventbuf
+  attr_reader :event_tracefilter
+  
+  def eventbuf_initialize(size=100)
+    @eventbuf = Trace::EventBuffer.new(size)
+    # @event_tracefilter = Trace::Filter.new
+  end
+  
+  # def event_processor(event, frame, arg=nil)
+  #   @eventbuf.append(event, frame, arg)
+  # end
+  
+  # Print event buffer entries from FROM up to TO try to stay within
+  # WIDTH. We show source lines only the first time they are
+  # encountered. Also we use separators to indicate points that the
+  # debugger has stopped at.
+  def eventbuf_print(from=nil, to=nil, width=80)
+    sep = '-' * ((width - 7) / 2)
+    last_container, last_location = nil, nil
+    if from == nil || !@eventbuf.marks[-1] 
+      mark_index = 0
+    else
+      mark_index = @eventbuf.marks.size-1
+      translated_from = @eventbuf.zero_pos + from
+      @eventbuf.marks.each_with_index do
+        |m, i|
+        if m > translated_from
+          mark_index = [0, i-1].max
+          break
+        elsif m == translated_from
+          mark_index = i
+          break
+        end
+      end
+    end
+    
+    nextmark = @eventbuf.marks[mark_index]
+    @eventbuf.each_with_index(from, to) do |e, i| 
+      if nextmark 
+        if nextmark == i
+          msg "#{sep} %5d #{sep}" % (mark_index - @eventbuf.marks.size)
+          mark_index += 1 if mark_index < @eventbuf.marks.size - 1
+          nextmark = @eventbuf.marks[mark_index]
+        elsif nextmark < i
+          mark_index += 1 if mark_index < @eventbuf.marks.size - 1
+          nextmark = @eventbuf.marks[mark_index]
+        end
+      end
+      last_container, last_location, mess = 
+        format_eventbuf_entry(e, last_container, last_location) if e
+      msg mess
+    end
+  end
+  
+  # Show event buffer entry. If the location is the same as the previous
+  # location we don't show the duplicated location information.
+  def format_eventbuf_entry(item, last_container, last_location)
+    mess = format_location(item.event, item.frame, 0)
+    return nil, nil, mess
+  end
+  
+  # FIXME: multiple hook mechanism needs work. 
+  # def start_capture
+  #   @event_tracefilter.add_trace_func(method(:event_processor).to_proc,
+  #                                     Trace::DEFAULT_EVENT_MASK)
+  # end
+  
+  # def stop_capture
+  #   @event_tracefilter.set_trace_func(nil)
+  # end
+  
+end
+
+if __FILE__ == $0
+  # Demo it.
+  cmdproc = Trepan::CmdProcessor.new([])
+  cmdproc.eventbuf_initialize(5)
+
+  def cmdproc.msg(mess)
+    puts mess
+  end
+  # cmdproc.start_capture
+  # z=5
+  # z.times do |i|
+  #   x = i
+  #   y = x+2
+  # end
+  # cmdproc.stop_capture
+  cmdproc.eventbuf_print
+end

data/processor/frame.rb

@@ -0,0 +1,265 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../app/complete'
+require_relative '../app/frame'
+require_relative '../app/util'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  include Trepan::Util
+  attr_reader   :current_thread
+
+  # ThreadFrame, current frame
+  attr_accessor :frame
+  
+  # frame index in a "backtrace" command
+  attr_accessor :frame_index
+  attr_reader   :hide_level
+
+  # Hash[thread_id] -> FixNum, the level of the last frame to
+  # show. If we called the debugger directly, then there is
+  # generally a portion of a backtrace we don't want to show. We
+  # don't need to store this for all threads, just those we want to
+  # hide frame on. A value of 1 means to hide just the oldest
+  # level. The default or showing all levels is 0.
+  attr_accessor :hidelevels
+
+  # Hash[container] -> file container. This gives us a way to map non-file
+  # container objects to a file container for display.
+  attr_accessor :remap_container
+  
+  attr_accessor :stack_size
+  
+  # top frame of current thread.
+  attr_accessor :top_frame       
+  # attr_reader   :threads2frames  # Hash[thread_id] -> top_frame
+    
+
+  def adjust_frame(frame_num, absolute_pos)
+    frame, frame_num = get_frame(frame_num, absolute_pos)
+    if frame 
+      @frame = @dbgr.frame(frame_num)
+      @frame_index = frame_num
+      unless @settings[:traceprint]
+        msg "--> #%d %s" % [frame_num, 
+                            @frame.describe(:show_ip => false,
+                                            :basename =>settings[:basename])]
+        print_location 
+      end
+      @line_no = @frame.line
+      @frame
+    else
+      nil
+    end
+  end
+  
+  def frame_low_high(direction)
+    if direction
+      low, high = [ @frame_index * -direction, 
+                    (@stack_size - 1 - @frame_index) * direction ]
+      low, high = [high, low] if direction < 0
+      [low, high]
+    else
+      [-@stack_size, @stack_size-1]
+    end
+  end
+  
+  def frame_complete(prefix, direction)
+    low, high = frame_low_high(direction)
+    ary = (low..high).map{|i| i.to_s}
+    Trepan::Complete.complete_token(ary, prefix)
+  end
+  
+  # def frame_container(frame, canonicalize=true)
+  #   container = 
+  #     if @remap_container.member?(frame.source_container)
+  #       @remap_container[frame.source_container]
+  #     elsif frame.iseq && @remap_iseq.member?(frame.iseq.sha1)
+  #       @remap_iseq[frame.iseq.sha1]
+  #     else
+  #       frame.source_container
+  #     end
+  
+  #   container[1] = canonic_file(container[1]) if canonicalize
+  #   container
+  # end
+  
+  # Initializes the thread and frame variables: @frame, @top_frame, 
+  # @frame_index, @current_thread, and @threads2frames
+  def frame_setup
+    @frame_index        = 0
+    @frame = @top_frame = @dbgr.current_frame
+    @current_thread     = @dbgr.debugee_thread
+    @line_no            = @frame.line
+    
+    @threads2frames   ||= {} 
+    @threads2frames[@current_thread] = @top_frame
+    set_hide_level
+  end
+  
+  # Remove access to thread and frame variables
+  def frame_teardown
+    @top_frame = @frame = @frame_index = @current_thread = nil 
+    @threads2frames = {}
+  end
+  
+  def frame_initialize
+    @remap_container = {}
+    @remap_iseq      = {}
+    @hidelevels      = Hash.new(nil) 
+    @hide_level      = 0
+  end
+  
+  def get_frame(frame_num, absolute_pos)
+    if absolute_pos
+      frame_num += @stack_size if frame_num < 0
+    else
+      frame_num += @frame_index
+    end
+    
+    if frame_num < 0
+      errmsg('Adjusting would put us beyond the newest frame.')
+      return [nil, nil]
+    elsif frame_num >= @stack_size
+      errmsg('Adjusting would put us beyond the oldest frame.')
+      return [nil, nil]
+    end
+    
+    [frame, frame_num]
+  end
+  
+  def parent_frame
+    frame = @dbgr.frame(@frame.number + 1)
+    unless frame
+      errmsg "Unable to find parent frame at level #{@frame.number+1}"
+      return nil
+    end
+    frame
+  end
+  
+  def print_stack_trace(frame=top_frame, opts={})
+    last_frame = nil
+    # TODO: handle indirect recursion.
+    direct_recursion_count = 0
+    count = opts[:count]
+    verbose = opts[:verbose]
+    
+    dbgr.each_frame(frame) do |frame|
+      if count and frame.number >= count
+        msg "(More stack frames follow...)" if count != stack_size
+        return 
+      end
+      if frame.location_equal(last_frame)
+        direct_recursion_count += 1
+      else
+        if direct_recursion_count > 0
+          msg("... above line repeated #{direct_recursion_count} times")
+          direct_recursion_count = 0
+        end
+        prefix = (frame == @frame) ? '-->' : '   '
+
+        ### FIXME: Move into a method.
+        msg "%s #%d %s" % [prefix, frame.number, 
+                           frame.describe(:show_ip => verbose, 
+                                          :basename => settings[:basename])]
+        if verbose
+          frame.local_variables.each do |local|
+            msg "       #{local} = #{frame.run(local.to_s).inspect}"
+          end
+        end
+        ### End FIXME
+
+      end
+      last_frame = frame
+    end
+  end
+
+  def set_hide_level
+    max_stack_size = @dbgr.vm_locations.size
+    @hide_level = 
+      if !@settings[:hidelevel] || @settings[:hidelevel] < 0
+        @settings[:hidelevel] = @hidelevels[@current_thread] =  
+          find_main_script(@dbgr.vm_locations) || max_stack_size
+      else
+        @settings[:hidelevel]
+      end
+    @stack_size = if @hide_level >= max_stack_size  
+                    max_stack_size else max_stack_size - @hide_level
+                  end
+  end
+  
+  # def get_nonsync_frame(tf)
+  #   if (tf.stack_size > 10)
+  #     check_frames = (0..5).map{|i| tf.prev(i).method}
+  #     if check_frames == 
+  #         %w(synchronize event_processor IFUNC call trace_hook IFUNC)
+  #       return tf.prev(6)
+  #     end
+  #   end
+  #   tf
+  # end
+  
+  # def get_frame_from_thread(th)
+  #   if th == Thread.current
+  #     @threads2frames[th]
+  #   else
+  #     # FIXME: Check to see if we are blocked on entry to debugger.
+  #     # If so, walk back frames.
+  #     tf = get_nonsync_frame(th.threadframe)
+  #     @threads2frames = tf
+  #   end
+  # end
+  
+  # # The dance we have to do to set debugger frame state to
+  # #    `frame', which is in the thread with id `thread_id'. We may
+  # #    need to the hide initial debugger frames.
+  # def find_and_set_debugged_frame(th, position)
+  
+  #   thread = threading._active[thread_id]
+  #   thread_name = thread.getName()
+  #   if (!@settings['dbg_pydbgr'] &&
+  #       thread_name == Mthread.current_thread_name())
+  #     # The frame we came in on ('current_thread_name') is
+  #     # the same as the one we want to switch to. In this case
+  #     # we need to some debugger frames are in this stack so 
+  #     # we need to remove them.
+  #     newframe = Mthread.find_debugged_frame(frame)
+  #     frame = newframe unless newframe
+  #   end
+  #   ## FIXME: else: we might be blocked on other threads which are
+  #   # about to go into the debugger it not for the fact this one got there
+  #   # first. Possibly in the future we want
+  #   # to hide the blocks into threading of that locking code as well. 
+  
+  #   # Set stack to new frame
+  #   @frame, @curindex = Mcmdproc.get_stack(frame, nil, self.proc)
+  #   @proc.stack, @proc.curindex = self.stack, self.curindex
+  
+  #   # @frame_thread_name = thread_name
+  # end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  class Trepan::CmdProcessor
+    def print_location
+      puts "frame location: #{frame.file} #{frame.line}"
+    end
+  end
+
+  require_relative './mock'
+  dbgr, cmd = MockDebugger::setup('exit', false)
+  # require_relative '../lib/trepanning'
+  # Trepan.start(:set_restart => true)
+  proc  = cmd.proc
+  0.upto(proc.stack_size-1) { |i| proc.adjust_frame(i, true) }
+  puts '*' * 10
+  proc.adjust_frame(-1, true)
+  proc.adjust_frame(0, true)
+  puts '*' * 10
+  proc.stack_size.times { proc.adjust_frame(1, false) }
+  puts '*' * 10
+  proc.adjust_frame(proc.stack_size-1, true)
+  proc.stack_size.times { proc.adjust_frame(-1, false) }
+    
+end

data/processor/help.rb

@@ -0,0 +1,94 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+class Trepan
+  # class SubHelp
+  #   def initialize(name, dir)
+  #     @name = name
+  #     @dir  = dir
+  #     load_sub_help_files(dir)
+  #   end
+
+  #   def load_sub_help_files(dir)
+  #     Dir.glob(dir, '*.txt').each do |txt| 
+  #       basename = File.basename(txt, '.txt')
+  #       @list << basename
+  #     end
+  #   end if File.directory?(dir)
+
+  #   def summary_help
+  #     section "List of #{@name} help"
+  #     msg @list
+  #   end
+  # end
+
+  module Help
+
+    def abbrev_stringify(name, min_abbrev)
+      "(#{name[0..min_abbrev-1]})#{name[min_abbrev..-1]}"
+    end
+
+    def summary_help(subcmd)
+      # Set class constant SHORT_HELP to be the first line of HELP
+      # unless it has been defined in the class already.
+      # The below was the simplest way I could find to do this since
+      # we are the super class but want to set the subclass's constant.
+      # defined? didn't seem to work here.
+      c = subcmd.class.constants
+      if c.member?('HELP') and !c.member?('SHORT_HELP')
+        short_help = subcmd.class.const_get('HELP').split("\n")[0].chomp('.')
+        subcmd.class.const_set(:SHORT_HELP, short_help)
+      end
+      
+      '  %-12s -- %s' %
+          [abbrev_stringify(obj_const(subcmd, :NAME), 
+                            obj_const(subcmd, :MIN_ABBREV)),
+           obj_const(subcmd, :SHORT_HELP)]
+    end
+
+    # We were given cmd without a subcommand; cmd is something
+    # like "show", "info" or "set". Generally this means list
+    # all of the subcommands.
+    def summary_list(name, subcmds)
+      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.
+        msg summary_help(subcmds.subcmds[subcmd_name])
+      end
+    end
+
+
+    # Error message when subcommand asked for but doesn't exist
+    def undefined_subcmd(cmd, subcmd)
+      ambig = settings[:abbrev] ? 'or ambiguous ' : ''
+      errmsg(['Undefined %s"%s" subcommand: "%s". ' % [ambig, cmd, subcmd],
+              'Try "help %s *".' % cmd])
+    end
+
+  end
+end
+
+if __FILE__ == $0
+  class TestClass
+    include Trepan::Help
+    HELP       = 'TestClass HELP.
+
+Long description goes here.'
+    MIN_ABBREV = 1
+    NAME       = File.basename(__FILE__)
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
+    def msg(mess)
+      puts mess
+    end
+    def errmsg(mess)
+      puts "***#{mess}"
+    end
+    def initialize
+      puts summary_help(self)
+      undefined_subcmd('foo', 'bar')
+    end
+  end
+  TestClass.new
+end

data/processor/hook.rb

@@ -0,0 +1,134 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'virtual'
+
+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
+      @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) 
+      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
+  hooks.run(5)
+  hook1 = Proc.new {|name, a| puts "#{name} called with #{a}"}
+  hooks = Trepan::CmdProcessor::Hook.new()
+  hooks.insert(-1, 'hook1', hook1)
+  p hooks.list
+  hooks.insert_if_new(-1, 'hook1', hook1)
+  puts '-' * 30
+  p hooks.list
+  hooks.run(10)
+  puts '-' * 30
+  hooks.insert(-1, 'hook2', hook1)
+  hooks.run(20)
+  puts '-' * 30
+  hooks.delete_by_name('hook2')
+  hooks.run(30)
+  puts '-' * 30
+  hooks.delete_by_name('hook1')
+  hooks.run(30)
+  puts '-' * 30
+end