rb8-trepanning 0.1.3-universal-ruby-1.9.2

data/processor/default.rb

@@ -0,0 +1,56 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../app/default' # for Trepan::HOME_DIR etc.
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  DEFAULT_SETTINGS = {
+    :abbrev        => true,       # Allow abbreviations of debugger commands?
+    :autoeval      => true,       # Ruby eval non-debugger commands
+    :autoirb       => false,      # Go into IRB in debugger command loop
+    :autolist      => false,      # Run 'list' 
+    
+    :basename      => false,      # Show basename of filenames only
+    :callstyle     => :last,      # 
+    :confirm       => true,       # Confirm potentially dangerous operations?
+    :different     => 'nostack',  # stop *only* when  different position? 
+    
+    :debugdbgr     => false,      # Debugging the debugger
+    :debugexcept   => true,       # Internal debugging of command exceptions
+    :debugmacro    => false,      # debugging macros
+    :debugskip     => false,      # Internal debugging of step/next skipping
+    :directory     =>             # last-resort path-search for files
+                  '$cdir:$cwd',   # that are not fully qualified.
+
+    :hidestack     => nil,        # Fixnum. How many hidden outer
+                                  # debugger stack frames to hide?
+                                  # nil or -1 means compute value. 0
+                                  # means hide none. Less than 0 means show
+                                  # all stack entries.
+    :hightlight    => false,      # Use terminal highlight? 
+      
+    :maxlist       => 10,         # Number of source lines to list 
+    :maxstack      => 10,         # backtrace limit
+    :maxstring     => 150,        # Strings which are larger than this
+                                  # will be truncated to this length when
+                                  # printed
+    :maxwidth       => (ENV['COLUMNS'] || '80').to_i,
+    :prompt         => 'trepan8', # core part of prompt. Additional info like
+                                  # debug nesting and thread name is fixed
+                                  # and added on.
+    :reload         => false,     # Reread source file if we determine
+                                  # it has changed?
+    :save_cmdfile  => nil,        # If set, debugger command file to be
+                                  # used on restart
+    :timer         => false,      # show elapsed time between events
+    :traceprint    => false,      # event tracing printing
+    :tracebuffer   => false,      # save events to a trace buffer.
+    :user_cmd_dir  => File.join(Trepan::HOME_DIR, 'trepan8', 'command'),
+                                  # User command directory
+  } unless defined? DEFAULT_SETTINGS
+end
+
+if __FILE__ == $0
+  # Show it:
+  require 'pp'
+  PP.pp(Trepan::CmdProcessor::DEFAULT_SETTINGS)
+end

data/processor/display.rb

@@ -0,0 +1,17 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../app/display'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  attr_reader   :displays
+
+  def display_initialize
+    @displays = DisplayMgr.new
+  end
+  
+  def run_eval_display(args={})
+    for line in @displays.display(@frame) do 
+      msg(line)
+    end
+  end
+end

data/processor/eval.rb

@@ -0,0 +1,113 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'
+require 'require_relative'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  def debug_eval(str, max_fake_filename=15)
+    begin
+      debug_eval_with_exception(str, max_fake_filename)
+    rescue SyntaxError, StandardError, ScriptError => e
+      exception_dump(e, @settings[:stack_trace_on_error], $!.backtrace)
+      nil
+    end
+  end
+
+  def debug_eval_with_exception(str, max_fake_filename=15)
+    filename, b = get_binding_and_filename(str, max_fake_filename)
+    eval(str, b, filename)
+  end
+
+  def debug_eval_no_errmsg(str, max_fake_filename=15)
+    begin
+      debug_eval_with_exception(str, max_fake_filename)
+    rescue SyntaxError, StandardError, ScriptError => e
+      nil
+    end
+  end
+
+  def eval_code(str, max_fake_filename=nil)
+    obj = debug_eval(str, max_fake_filename)
+    
+    # idx = @user_variables
+    # @user_variables += 1
+    
+    # str = "$d#{idx}"
+    # Rubinius::Globals[str.to_sym] = obj
+    # msg "#{str} = #{obj.inspect}"
+    msg "#{obj.inspect}"
+    obj
+  end
+
+  def exception_dump(e, stack_trace, backtrace)
+    str = "#{e.class} Exception:\n\t#{e.message}"
+    if stack_trace
+      str += "\n" + backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+    end
+    msg str
+    # throw :debug_error
+  end
+
+  def fake_eval_filename(str, maxlen = 15)
+    fake_filename = 
+      if maxlen < str.size
+        # FIXME: Guard against \" in positions 13..15?
+        str.inspect[0..maxlen-1] + '"...'
+      else
+        str.inspect
+      end
+    "(eval #{fake_filename})"
+  end
+  
+  def get_binding_and_filename(str, maxlen)
+    b = 
+      begin
+        @frame.binding
+      rescue
+        TOPLEVEL_BINDING
+      end
+    filename = fake_eval_filename(str, maxlen)
+    return [filename, b]
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  cmdp = Trepan::CmdProcessor.new([])
+  puts cmdp.fake_eval_filename('x = 1; y = 2')
+  puts cmdp.fake_eval_filename('x = 1; y = 2', 7)
+
+  def cmdp.errmsg(msg)
+    puts "** #{msg}"
+  end
+  def cmdp.msg(msg)
+    puts "** #{msg}"
+  end
+  begin 
+    1/0
+  rescue Exception => exc
+    cmdp.exception_dump(exc, true, $!.backtrace)
+    puts '=' * 40
+  end
+
+  x = 10
+
+  require 'rubygems'; require 'require_relative'
+  puts "To be continued..."
+  exit
+  require_relative '../app/frame'
+  frame = Trepan::Frame.new(context)
+  cmdp.instance_variable_set('@frame', frame)
+  cmdp.instance_variable_set('@settings', {:stack_trace_on_error => true})
+  def cmdp.errmsg(mess) ; puts mess end
+  # require_relative '../lib/trepanning'
+  # Trepan.start
+  puts cmdp.debug_eval('x = "#{x}"')
+  puts '=' * 40
+  puts cmdp.debug_eval('x+')
+  puts cmdp.debug_eval_no_errmsg('y+')
+  puts '=' * 40
+  puts cmdp.debug_eval('x+')
+  puts cmdp.debug_eval('y = 1; x+', 4)
+end

data/processor/eventbuf.rb

@@ -0,0 +1,105 @@
+# 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'
+begin
+  require 'linecache'
+rescue LoadError
+  require 'linecache19'
+end
+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,172 @@
+# 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 = frame
+      @frame.index = frame_num
+      prefix = "--> ##{frame_num} " 
+      unless @settings[:traceprint]
+        msg("#{prefix}%s" %
+            @frame.describe(:basename  => settings[:basename],
+                            :maxwidth  => settings[:maxwidth] - prefix.size,
+                            :callstyle => settings[:callstyle]))
+      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
+  
+  # Initializes the thread and frame variables: @frame, @top_frame, 
+  # @frame_index, @current_thread, and @threads2frames
+  def frame_setup(context, state)
+    @frame = @top_frame = Trepan::Frame.new(context)
+    @frame.index        = 0
+    @current_thread     = @frame.thread
+    @context            = context
+    @state              = state
+    @line_no            = @frame.line
+    
+    @threads2frames   ||= {} 
+    @threads2frames[@current_thread] = @top_frame
+    @stack_size         = @frame.stack_size
+    ## FIXME: reinstate
+    ## set_hide_level
+  end
+  
+  # Remove access to thread and frame variables
+  def frame_teardown
+    @top_frame = @frame = @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 += @frame.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.index = frame_num
+    [@frame, frame_num]
+  end
+  
+  def parent_frame
+    unless @frame.index + 1 < @frame.stack_size
+      errmsg "Unable to find parent frame at level #{@frame.index+1}"
+      return nil
+    end
+    @frame.index += 1
+    @frame
+  end
+  
+  def set_hide_level
+    max_stack_size = @frame.stack_size
+    @hide_level = 
+      if !@settings[:hidelevel] || @settings[:hidelevel] < 0
+        @settings[:hidelevel] = @hidelevels[@current_thread] =  
+          find_main_script(@frame) || 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
+end
+
+if __FILE__ == $0
+  # Demo it.
+  class Trepan::CmdProcessor
+    def print_location
+      puts "frame location: #{frame.file} #{frame.line}"
+    end
+  end
+
+  require_relative './mock'
+  puts "To be continued..."
+  exit
+  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