trepanning 0.0.4

data/processor/eventbuf.rb

@@ -0,0 +1,131 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# For recording hook events in a buffer for review later. Make use of
+# Trace::Buffer for this prupose.
+require 'trace'
+require 'linecache'
+
+class Trepan
+  class CmdProcessor
+
+    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)
+      container = 
+        if item.source_container[0] == 'file'
+          item.source_container[1]
+        else
+          item.source_container
+        end
+    
+      location = 
+        if 1 == item.source_location.size 
+          item.source_location[0]
+        else
+          item.source_location
+        end
+
+      same_loc = (container == last_container && location == last_location)
+      mess = "#{item.event} "
+      mess +=
+        if %w(c-return return).member?(item.event)
+          "#{item.method} => #{item.arg.inspect}" + (same_loc ? '' : "\n\t")
+        elsif 'c-call' == item.event
+          "#{item.method} "
+        else
+          "#{item.type} #{item.method} "
+        end
+      mess += "#{container} at line #{location}" unless same_loc
+
+      if item.iseq # && long_format
+        mess += "\n\tVM offset #{item.pc_offset}"
+      end
+      unless same_loc
+        text = LineCache::getline(container, location, @reload_on_change)
+        mess += ":\n  #{text.chomp}" if text
+      end
+      return container, location, 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
+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,230 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'tempfile'
+require 'linecache'
+require_relative '../app/frame'
+class Trepan
+  class CmdProcessor
+
+    attr_reader   :current_thread
+    attr_accessor :frame           # ThreadFrame, current frame
+    attr_accessor :frame_index     # frame index in a "where" command
+    attr_accessor :hide_level      # 
+    attr_accessor :hidelevels      # 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 :remap_container # Hash[container] -> file container
+                                   # Gives us a way to map non-file
+                                   # container objects to a file
+                                   # container for display.
+    attr_accessor :remap_iseq      # Hash[iseq] -> file container
+
+    attr_accessor :top_frame       # top frame of current thread. Since
+                                   # right now the ThreadFrame method has "prev" 
+                                   # but no way to move in the other direction.
+                                   # So we store the 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 = frame
+        @frame_index = frame_num
+        frame_eval_remap if 'EVAL' == @frame.type
+        print_location
+        @line_no = frame_line() - 1
+        @frame
+      else
+        nil
+      end
+    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
+
+    # If frame type is EVAL, set up to remap the string to a temporary file.
+    def frame_eval_remap
+      to_str = Trepan::Frame::eval_string(@frame)
+      return nil unless to_str.is_a?(String)
+
+      # All systems go!
+      unless @remap_iseq.member?(@frame.iseq.sha1)
+        tempfile = Tempfile.new(['eval-', '.rb'])
+        tempfile.open.puts(to_str)
+
+        @remap_iseq[@frame.iseq.sha1] = ['file', tempfile.path]
+        tempfile.close
+        LineCache::cache(tempfile.path)
+      end
+      return true
+    end
+
+    def frame_line
+      if @event == 'vm-insn' && @frame.iseq
+        pc_offset = @frame.pc_offset
+        return 0 unless pc_offset
+        @frame.iseq.offset2lines(pc_offset)[0]
+      else
+        (@frame.source_location && @frame.source_location[0]) || 0
+      end
+    end
+
+    # Initializes the thread and frame variables: @frame, @top_frame, 
+    # @frame_index, @current_thread, and @threads2frames
+    def frame_setup(frame_thread)
+      @frame_index        = 0
+      @frame = @top_frame = frame_thread
+      @current_thread     = @frame.thread
+      @stack_size         = @frame.stack_size
+
+      @threads2frames   ||= {} 
+      @threads2frames[@current_thread] = @top_frame
+      @hide_level         = 
+        if @settings[:debugstack]
+          0
+        else
+          @hidelevels[@current_thread]
+        end
+      
+      frame_eval_remap if 'EVAL' == @frame.type
+    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(0) # Set default value to 0
+      @hide_level      = 0
+    end
+
+    def get_frame(frame_num, absolute_pos)
+      stack_size = @top_frame.stack_size - @hide_level
+
+      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 = @top_frame.prev(frame_num)
+      while 'IFUNC' == frame.type && frame.prev
+        frame = frame.prev
+        frame_num += 1
+      end
+
+      [frame, frame_num]
+    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
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require 'thread_frame'
+  require_relative '../app/mock'
+  require_relative 'main'   # Have to include before defining CmdProcessor!
+                            # FIXME
+  class Trepan::CmdProcessor
+    def errmsg(msg)
+      puts msg
+    end
+    def print_location
+      puts "#{@frame.source_container} #{frame.source_location[0]}"
+    end
+  end
+
+  proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+  proc.frame_setup(RubyVM::ThreadFrame.current)
+  proc.hidelevels = {}
+  puts "stack size: #{proc.top_frame.stack_size}"
+  0.upto(proc.top_frame.stack_size) { |i| proc.adjust_frame(i, true) }
+  puts '*' * 10
+  proc.adjust_frame(-1, true)
+  proc.adjust_frame(0, true)
+  puts '*' * 10
+  proc.top_frame.stack_size.times { proc.adjust_frame(1, false) }
+  proc.adjust_frame(proc.top_frame.stack_size-1, true)
+  proc.top_frame.stack_size.times { proc.adjust_frame(-1, false) }
+    
+end

data/processor/help.rb

@@ -0,0 +1,72 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  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)
+      msg "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)
+      errmsg(('Undefined "%s" subcommand: "%s". ' + 
+              'Try "help %s *".') % [cmd, subcmd, 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,128 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  class CmdProcessor
+    # 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) 
+        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['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)}]
+    end
+
+  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

data/processor/load_cmds.rb

@@ -0,0 +1,102 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Trepan::CmdProcess that loads up debugger commands from builtin and
+# user directories.
+# Sets @commands, @aliases, @macros
+class Trepan
+  class CmdProcessor
+
+    attr_reader   :aliases         # Hash[String] of command names
+                                   # indexed by alias name
+    attr_reader   :commands        # Hash[String] of command objects
+                                   # indexed by name
+    attr_reader   :macros          # Hash[String] of Proc objects 
+                                   # indexed by macro name.
+    
+    # "initialize" for multi-file class. Called from main.rb's "initialize".
+    def load_cmds_initialize
+      @commands = {}
+      @aliases = {}
+      @macros = {}
+
+      cmd_dirs = [ File.join(File.dirname(__FILE__), 'command') ]
+      cmd_dirs <<  @settings[:user_cmd_dir] if @settings[:user_cmd_dir]
+      cmd_dirs.each do |cmd_dir| 
+          load_debugger_commands(cmd_dir) if File.directory?(cmd_dir)
+        end
+    end
+
+    # Loads in debugger commands by require'ing each ruby file in the
+    # 'command' directory. Then a new instance of each class of the 
+    # form Trepan::xxCommand is added to @commands and that array
+    # is returned.
+
+    def load_debugger_commands(cmd_dir)
+      Dir.glob(File.join(cmd_dir, '*.rb')).each do |rb| 
+        require rb
+      end if File.directory?(cmd_dir)
+      # Instantiate each Command class found by the above require(s).
+      ### p Trepan::Command.constants ## REMOVE ME
+      Trepan::Command.constants.grep(/.Command$/).each do |command|
+        # Note: there is probably a non-eval way to instantiate the
+        # command, but I don't know it. And eval works.
+        new_cmd = "Trepan::Command::#{command}.new(self)"
+        cmd = self.instance_eval(new_cmd)
+
+        # Add to list of commands and aliases.
+        cc = cmd.class
+        cmd_name = cc.const_get(:NAME)
+        if cc.constants.member?(:ALIASES)
+          aliases= cc.const_get(:ALIASES)  
+          aliases.each {|a| @aliases[a] = cmd_name}
+        end
+        @commands[cmd_name] = cmd
+      end
+    end
+
+    # Looks up cmd_array[0] in @commands and runs that. We do lots of 
+    # validity testing on cmd_array.
+    def run_cmd(cmd_array)
+      unless cmd_array.is_a?(Array)
+        errmsg "run_cmd argument should be an Array, got: #{cmd_array.class}"
+        return
+      end
+      if cmd_array.detect{|item| !item.is_a?(String)}
+        errmsg "run_cmd argument Array should only contain strings. " + 
+          "Got #{cmd_array.inspect}"
+        return
+      end
+      if cmd_array.empty?
+        errmsg "run_cmd Array should have at least one item. " + 
+          "Got: #{cmd_array.inspect}"
+        return
+      end
+      cmd_name = cmd_array[0]
+      if @commands.member?(cmd_name)
+        @commands[cmd_name].run(cmd_array)
+      end
+    end
+  end
+end
+if __FILE__ == $0
+  cmdproc = Trepan::CmdProcessor.new
+  cmddir = File.join(File.dirname(__FILE__), 'command')
+  cmdproc.instance_variable_set('@settings', {})
+  cmdproc.load_cmds_initialize
+  require 'columnize'
+  puts Columnize.columnize(cmdproc.commands.keys.sort)
+  puts '=' * 20
+  puts Columnize.columnize(cmdproc.aliases.keys.sort)
+  puts '=' * 20
+
+  def cmdproc.errmsg(mess)
+    puts "** #{mess}"
+  end
+
+  def cmdproc.msg(mess)
+    puts mess
+  end
+
+  cmdproc.run_cmd('foo')  # Invalid - not an Array
+  cmdproc.run_cmd([])     # Invalid - empty Array
+  cmdproc.run_cmd(['list', 5])  # Invalid - nonstring arg
+end