rbx-trepanning 0.2.0-universal-rubinius-2.0

data/app/complete.rb

@@ -0,0 +1,79 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+class 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) }.map{|cmd| cmd.to_s}.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/condition.rb

@@ -0,0 +1,22 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  module Condition
+    def valid_condition?(str)
+      begin
+        Rubinius::Compiler.compile_string(str)
+      rescue SyntaxError
+        return nil
+      rescue
+        nil
+      end
+    end
+    module_function :valid_condition?
+  end
+end
+if __FILE__ == $0
+  include Trepan::Condition
+  p valid_condition?('a+2')
+  puts '-' * 20
+  p valid_condition?('1+')
+  puts '-' * 20
+end

data/app/default.rb

@@ -0,0 +1,71 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# A place for the default settings
+class Trepan
+
+  # I am not sure if we need to sets of hashes, but we'll start out
+  # that way.
+
+  # 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    => Rubinius::OS_ARGV,
+                               # Command run when "restart" is given.
+    :server          => false, # Out-of-process debugging?
+    :skip_loader     => false, # If run via -Xdebug or trepanx
+                               # command-line we need this to skip
+                               # over some initial Rubinius loader
+                               # commands.
+  } unless defined?(DEFAULT_SETTINGS)
+
+  # Default settings for Trepan run from the command line.
+  DEFAULT_CMDLINE_SETTINGS = {
+    :cmdfiles => [],  # Initialization command files to run
+    :client   => false, # Attach to out-of-process program?
+    :nx       => false, # Don't run user startup file (e.g. .trepanxrc)
+    :output   => nil,
+    :port     => DEFAULT_SETTINGS[:port],
+    :host     => DEFAULT_SETTINGS[:host], 
+    :server   => false, # Out-of-process debugging?
+    :readline => true,  # Try to use GNU Readline?
+    # Note that at most one of :server or :client can be true.
+  } unless defined?(DEFAULT_CMDLINE_SETTINGS)
+
+  DEFAULT_DEBUG_STR_SETTINGS = {
+    :core_opts => {
+      :cmdproc_opts => {:different => false}},
+    :hide_stack => true,
+  } unless defined?(DEFAULT_DEBUG_STR_SETTINGS)
+
+  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
+      'trepanx.ini'
+    else
+      HOME_DIR = ENV['HOME'].to_s
+      '.trepanxrc'
+    end unless defined?(CMD_INITFILE_BASE)
+  CMD_INITFILE = File.join(HOME_DIR, CMD_INITFILE_BASE) unless
+    defined?(CMD_INITFILE)
+end
+
+if __FILE__ == $0
+  # Show it:
+  require 'pp'
+  PP.pp(Trepan::DEFAULT_SETTINGS)
+  puts '=' * 30
+  PP.pp(Trepan::DEFAULT_CMDLINE_SETTINGS)
+end

data/app/display.rb

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011, 2013 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.vm_location.constant_scope
+end
+
+# Manage a list of display expressions.
+class DisplayMgr
+  
+  def initialize
+    @next = 0
+    @list = []
+  end
+  
+  def [](index)
+    raise TypeError, 
+    "index #{index} should be a Fixnum, is #{index.class}" unless
+      index.is_a?(Fixnum)
+    @list.detect {|disp| disp.number == index }
+  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
+
+  def max
+    @list.map{|disp| disp.number}.max
+  end
+
+  def nums
+    @list.map{|disp| disp.number}
+  end
+
+  def size
+    @list.size
+  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 disable
+    @enabled = false
+  end
+
+  def disabled?
+    !@enabled
+  end
+
+  def enable
+    @enabled = true
+  end
+
+  def enabled?
+    @enabled
+  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')
+  puts "Number of displays %s" % mgr.size
+  puts "Max Number  %d" % mgr.max
+  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

data/app/file.rb

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# Things related to file/module status
+
+module Trepanning
+  module FileName
+    def find_load_path(filename)
+      cl = Rubinius::CodeLoader.new(filename)
+      if cl.verify_load_path(filename)
+        path = cl.instance_variable_get('@load_path')
+        path.end_with?(filename) ? filename : nil
+      else
+        nil
+      end
+    end
+  end
+end
+if __FILE__ == $0
+  include Trepanning::FileName
+  require 'tmpdir.rb'
+  [__FILE__, 'tmpdir.rb'].each do |name|
+    p find_load_path(name)
+  end
+end

data/app/frame.rb

@@ -0,0 +1,120 @@
+# Copyright (C) 2010-2011, 2013 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+
+  # Call-Stack frame methods
+  class Frame
+    def initialize(dbgr, number, vm_location)
+      @debugger = dbgr
+      @number = number
+      @vm_location = vm_location
+    end
+
+    attr_reader :number, :vm_location
+
+    def run(code, filename=nil)
+      eval(code, self.binding, filename)
+    end
+
+    def binding
+      @binding ||= Binding.setup(@vm_location.variables,
+                                 @vm_location.method,
+                                 @vm_location.constant_scope)
+    end
+
+    def describe(opts = {})
+      if method.required_args > 0
+        locals = []
+        0.upto(method.required_args-1) do |arg|
+          locals << method.local_names[arg].to_s
+        end
+
+        arg_str = locals.join(", ")
+      else
+        arg_str = ""
+      end
+
+      loc = @vm_location
+
+      if loc.is_block
+        if arg_str.empty?
+          recv = "{ } in #{loc.describe_receiver}#{loc.name}"
+        else
+          recv = "{|#{arg_str}| } in #{loc.describe_receiver}#{loc.name}"
+        end
+      else
+        if arg_str.empty?
+          recv = loc.describe
+        else
+          recv = "#{loc.describe}(#{arg_str})"
+        end
+      end
+
+      filename = loc.method.active_path
+      filename = File.basename(filename) if opts[:basename]
+      str = "#{recv} at #{filename}:#{loc.line}"
+      if opts[:show_ip]
+        str << " (@#{loc.ip})"
+      end
+
+      str
+    end
+
+    def file
+      @vm_location.file
+    end
+
+    def ip
+      @vm_location.ip
+    end
+
+    def next_ip
+      @vm_location.next_ip
+    end
+
+    def line
+      line_no = @vm_location.line
+      line_no == 0 ? ISeq::tail_code_line(method, next_ip) : line_no
+    end
+
+    def local_variables
+      method.local_names
+    end
+
+    # Return true if frame1 and frame2 are at the same place.
+    # We use this for example in detecting tail recursion.
+    def location_equal(other_frame)
+      # if self && other_frame 
+      #   puts(self.vm_location.line, other_frame.vm_location.line, 
+      #        self.vm_location.ip, other_frame.vm_location.ip, 
+      #        self.vm_location.method.active_path, other_frame.vm_locaion.method.actionve_path)
+      # end
+      self && other_frame && self.vm_location.line == other_frame.vm_location.line &&
+        self.vm_location.ip == other_frame.vm_location.ip && 
+        self.vm_location.method.active_path == other_frame.vm_location.method.active_path
+    end
+
+    def method
+      @vm_location.method
+    end
+
+    def scope
+      @vm_location.variables
+    end
+
+    def stack_size
+      @debugger.vm_locations.size
+    end
+
+    def eval?
+      static = @vm_location.constant_scope
+      static && static.script && static.script.eval_source
+    end
+
+    def eval_string
+      return nil unless eval?
+      static = @vm_location.constant_scope
+      static.script.eval_source
+    end
+
+  end
+end