rb8-trepanning 0.1.3-universal-ruby-1.9.2

data/app/complete.rb

@@ -0,0 +1,79 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+module Trepan
+
+  # Command completion methods
+  module Complete
+
+    module_function
+
+    # Return an Array of String found from Array of String
+    # +complete_ary+ which start out with String +prefix+.
+    def complete_token(complete_ary, prefix)
+      complete_ary.select { |cmd| cmd.to_s.start_with?(prefix) }.sort
+    end
+    
+    def complete_token_with_next(complete_hash, prefix, cmd_prefix='')
+      result = []
+      complete_hash.each do |cmd_name, cmd_obj| 
+        result << [cmd_name.to_s[cmd_prefix.size..-1], cmd_obj] if 
+          cmd_name.to_s.start_with?(cmd_prefix + prefix)
+      end
+      result.sort{|a, b| a[0] <=> b[0]}
+    end
+    
+    # Find all starting matches in Hash +aliases+ that start with +prefix+,
+    # but filter out any matches already in +expanded+.
+    def complete_token_filtered(aliases, prefix, expanded)
+      complete_ary = aliases.keys
+      complete_ary.select { |cmd| 
+        cmd.to_s.start_with?(prefix) && ! expanded.member?(aliases[cmd])}.sort
+    end
+
+    # Find all starting matches in Hash +aliases+ that start with +prefix+,
+    # but filter out any matches already in +expanded+.
+    def complete_token_filtered_with_next(aliases, prefix, expanded,
+                                          commands)
+      complete_ary = aliases.keys
+      expanded_ary = expanded.keys
+      result = []
+      complete_ary.each do |cmd| 
+        if cmd.to_s.start_with?(prefix) && 
+            !expanded_ary.member?(aliases[cmd])
+          result << [cmd, commands[aliases[cmd]]] 
+        end
+      end
+      result
+    end
+
+    # Find the next token in str string from start_pos, we return
+    # the token and the next blank position after the token or 
+    # str.size if this is the last token. Tokens are delimited by
+    # white space.
+    def next_token(str, start_pos)
+      look_at = str[start_pos..-1]
+      next_nonblank_pos = start_pos + (look_at =~ /\S/ || 0)
+      next_blank_pos = 
+        if next_match = str[next_nonblank_pos..-1] =~ /\s/
+          next_nonblank_pos + next_match 
+        else
+          str.size
+        end
+      return [next_blank_pos, str[next_nonblank_pos...next_blank_pos]]
+    end
+    
+  end
+end
+
+if __FILE__ == $0
+  include Trepan::Complete
+  hash = {'ab' => 1, 'aac' => 2, 'aa' => 3, 'b' => 4}
+  p complete_token(hash.keys, 'a')
+  p complete_token_with_next(hash, 'a')
+  ##   0         1
+  ##   0123456789012345678
+  x = '  now is  the  time'
+  [0, 2, 5, 8, 9, 13, 19].each do |pos|
+    p next_token(x, pos)
+  end
+end

data/app/default.rb

@@ -0,0 +1,90 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+module Trepan
+  # Default options to Trepan.start
+  DEFAULT_START_SETTINGS = { 
+    :init        => true,  # Set $0 and save ARGV? 
+    :post_mortem => false, # post-mortem debugging on uncaught exception?
+    :tracing     => nil    # Debugger.tracing value. true/false resets,
+                           # nil keeps the prior value
+  } unless defined?(DEFAULT_START_SETTINGS)
+
+  # the port number used for remote debugging
+  PORT = 8989 unless defined?(PORT)
+
+  # What file is used for debugger startup commands.
+  unless defined?(CMD_INITFILE_BASE)
+    CMD_INITFILE_BASE = 
+      if RUBY_PLATFORM =~ /mswin/
+        # Of course MS Windows has to be different
+        HOME_DIR =  (ENV['HOME'] || 
+                     ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
+        'trepan8.ini'
+    else
+        HOME_DIR = ENV['HOME'].to_s
+        '.trepan8rc'
+    end
+  end
+
+  CMD_INITFILE = File.join(HOME_DIR, CMD_INITFILE_BASE) unless
+    defined?(CMD_INITFILE)
+  
+  # Default settings for a Trepan class object
+  DEFAULT_SETTINGS = {
+    :cmdproc_opts    => {},    # Default Trepan::CmdProcessor settings
+    :core_opts       => {},    # Default Trepan::Core settings
+    :delete_restore  => true,  # Delete restore profile after reading? 
+    :initial_dir     => nil,   # If --cd option was given, we save it here.
+    :nx              => false, # Don't run user startup file (e.g. .trepanxrc)
+    :offset          => 0,     # skipping back +offset+ frames. This lets you start
+                               # the debugger straight into callers method.
+
+    # Default values used only when 'server' or 'client'
+    # (out-of-process debugging)
+    :port            => 1955,
+    :host            => 'localhost', 
+
+    :restart_argv    => [],
+    :server          => false  # Out-of-process debugging?
+  } unless defined?(DEFAULT_SETTINGS)
+
+  # Default settings for Trepan run from the command line.
+  DEFAULT_CMDLINE_SETTINGS = {
+    :annotate           => 0,
+    :client             => false,
+    :control            => false,
+    :cport              => DEFAULT_SETTINGS[:port] + 1,
+    :frame_bind         => false,
+    :host               => DEFAULT_SETTINGS[:host],
+    :quit               => true,
+    :rewrite_program    => false,
+    :stop               => true,
+    :nx                 => false,
+    :port               => DEFAULT_SETTINGS[:port],
+    :post_mortem        => false,
+    :readline           => true,  # try to use GNU readline?
+    :restart_script     => nil,
+    :script             => nil,
+    :server             => false,
+    :tracing            => false,
+    :verbose_long       => false,
+    :wait               => false,
+    :cmdfiles           => [],  # initialization command files to run
+    ## :output   => nil,
+    ## Note that at most one of :server or :client can be true.
+  } unless defined?(DEFAULT_CMDLINE_SETTINGS)
+
+  class << self
+    attr_accessor :start_sentinal
+    # If start_sentinal is set, it is a string to look for in caller()
+    # and is used to see if the call stack is truncated. Is also
+    # defined in lib/trepanning.rb
+    start_sentinal = nil;  
+  end
+end
+
+if __FILE__ == $0
+  # Show it:
+  require 'pp'
+  PP.pp(Trepan::CmdProcessor::DEFAULT_SETTINGS)
+end

data/app/display.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Classes to support gdb-like display/undisplay.
+
+require 'rubygems'; require 'require_relative'
+require_relative 'frame'
+
+# return suitable frame signature to key display expressions off of.
+def display_signature(frame)
+  return nil unless frame
+  frame.object_id
+end
+
+# Manage a list of display expressions.
+class DisplayMgr
+  
+  def initialize
+    @next = 0
+    @list = []
+  end
+  
+  def add(frame, arg, fmt=nil)
+    return nil unless frame
+    begin
+      eval(arg, frame.binding)
+    rescue
+      return nil
+    end
+    @next += 1
+    d = Display.new(frame, arg, fmt, @next)
+    @list << d
+    d
+  end
+
+  # List all display items; return 0 if none
+  def all
+    s = []
+    unless @list.empty?
+      s << "Auto-display expressions now in effect:
+Num Enb Expression"
+      @list.each do |display|
+        s << display.format
+      end
+    end
+    s
+  end
+
+  # Delete all display expressions"""
+  def clear
+    @list = []
+  end
+
+  # Delete display expression i
+  def delete_index(display_number)
+    @list.each_with_index do |display, i|
+      if display_number == display.number
+        @list[i..i] = []
+        return true
+      end
+    end
+    false
+  end
+
+  # display any items that are active'''
+  def display(frame)
+    return unless frame
+    s = []
+    sig = display_signature(frame)
+    @list.each do |display|
+      if display.enabled # && display.signature == sig
+        s << display.to_s(frame)
+      end
+    end
+    return s
+  end
+
+  def enable_disable(display_number, b_enable_disable)
+    @list.each do |display|
+      if display_number == display.number
+        display.enabled = b_enable_disable
+        return true
+      end
+    end
+    false
+  end
+end
+
+class Display
+  attr_reader   :number
+  attr_reader   :signature
+  attr_accessor :enabled
+  
+  def initialize(frame, arg, fmt, number)
+    @signature = display_signature(frame)
+    @fmt       = fmt
+    @arg       = arg
+    @enabled   = true
+    @number    = number
+  end
+
+  def to_s(frame)
+    return 'No symbol "' + @arg + '" in current context.' unless frame
+    
+    begin
+      val = eval(@arg, frame.binding)
+    rescue
+      return "No symbol \"#{@arg}\" in current context."
+    end
+    s = "#{self.format(false)} = #{val}"
+    return s
+  end
+
+  # format display item
+  def format(show_enabled=true)
+    what = ''
+    what += @enabled ? ' y ' : ' n ' if 
+      show_enabled
+    what += (@fmt + ' ') if @fmt
+    what += @arg if @arg
+    '%3d: %s' % [@number, what]
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  mgr = DisplayMgr.new
+
+  def print_display(mgr)
+    mgr.all.each {|line| puts line}
+    puts '=' * 40
+  end
+    
+  frame = Rubinius::VM.backtrace(0)[0]
+
+  x = 1
+  mgr.add(frame, 'x > 1')
+  print_display(mgr)
+
+  mgr.enable_disable(1, false)
+  print_display(mgr)
+
+  mgr.enable_disable(1, true)
+  print_display(mgr)
+
+  mgr.clear()
+  print_display(mgr)
+
+end

data/app/eventbuffer.rb

@@ -0,0 +1,147 @@
+#   Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+module Trace
+
+  class EventBuffer
+    EventStruct = Struct.new(:event, :arg, :frame) unless defined?(EventStruct)
+    attr_reader   :buf
+    attr_accessor :marks    # User position mark into buffer. If buffer is limited,
+    attr_reader   :maxsize  # Maximum size of buffer or nil if unlimited.
+    attr_reader   :size     # size of buffer 
+    # then marks will drop out as they disappear from the buffer
+    def initialize(maxsize=nil)
+      @maxsize = maxsize
+      reset
+    end
+    
+    def reset
+      @buf   = []
+      @marks = []
+      @pos   = -1
+      @size  = 0 
+    end
+    
+    # Add a new event dropping off old events if that was declared
+    # marks are also dropped if buffer has a limit.
+    def append(event, frame, arg)
+      item = EventStruct.new(event, arg, frame)
+      @pos = self.succ_pos
+      @marks.shift if @marks[0] == @pos
+      @buf[@pos] = item
+      @size     += 1 unless @maxsize && @size == @maxsize
+    end
+
+    # Add mark for the current event buffer position.
+    def add_mark
+      @marks << @pos
+    end
+
+    # Like add mark, but do only if the last marked position has
+    # changed
+    def add_mark_nodup
+      @marks << @pos unless @marks[-1] == @pos
+    end
+    
+    def each(from=nil, to=nil)
+      from = self.succ_pos unless from
+      to   = @pos unless to
+      if from <= to
+        from.upto(to).each do |pos|
+          yield @buf[pos]
+        end
+      else
+        from.upto(@size-1).each do |pos|
+          yield @buf[pos]
+        end
+        0.upto(@pos).each do |pos|
+          yield @buf[pos]
+        end
+      end
+    end
+    
+    def each_with_index(from=nil, to=nil)
+      from = succ_pos unless from
+      to   = @pos     unless to
+      if from <= to
+        from.upto(to).each do |pos|
+          yield [@buf[pos], pos]
+        end
+      else
+        from.upto(@size-1).each do |pos|
+          yield [@buf[pos], pos]
+        end
+        0.upto(@pos).each do |pos|
+          yield [@buf[pos], pos]
+        end
+      end
+    end
+    
+    def format_entry(item, long_format=true)
+      # require 'rbdbgr'; Debugger.debug
+      mess = "#{item.event} #{item.frame}"
+      # if long_format && item.iseq
+      #   mess += "\n\t" + "VM offset #{item.pc_offset} of #{item.iseq.name}"
+      # end
+      mess
+    end
+
+    # Return the next event buffer position taking into account
+    # that we may have a fixed-sized buffer ring.
+    def succ_pos(inc=1)
+      pos = @pos + inc 
+      @maxsize ? pos % @maxsize : pos 
+    end
+    
+    # Return the next event buffer position taking into account
+    # that we may have a fixed-sized buffer ring.
+    def pred_pos(dec=1)
+      pos = @pos - dec
+      @maxsize ? pos % @maxsize : pos 
+    end
+    
+    # Return the adjusted zeroth position in @buf.
+    def zero_pos
+      if !@maxsize || @buf.size < @maxsize
+        0
+      else 
+        self.succ_pos
+      end
+    end
+    
+  end # EventBuffer
+end # Trace 
+
+if __FILE__ == $0
+  def event_processor(event, frame, arg=nil)
+    begin 
+      @eventbuf.append(event, frame, arg)
+    rescue
+      p $!
+    end
+  end
+  def dump_all
+    puts '-' * 40
+    @eventbuf.each do |e| 
+      puts @eventbuf.format_entry(e) if e
+    end
+  end
+
+  require 'rubygems'; require 'set_trace'
+  @eventbuf = Trace::EventBuffer.new(5)
+  p @eventbuf.zero_pos
+  dump_all
+
+  # trace_filter = Trace::Filter.new
+  # trace_func   = method(:event_processor).to_proc
+  # trace_filter << trace_func
+  # trace_filter.set_trace_func(trace_func)
+  # z=5
+  # z.times do |i|
+  #   x = i
+  #   y = x+2
+  # end
+  # trace_filter.set_trace_func(nil)
+  # p @eventbuf.buf[@eventbuf.zero_pos]
+  # dump_all
+  @eventbuf.reset
+  dump_all
+end