rbx-trepanning 0.2.0-universal-rubinius-2.0

data/app/brkptmgr.rb

@@ -0,0 +1,153 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'set'
+require 'rubygems'; require 'require_relative'
+require_relative 'breakpoint'
+class Trepan
+  class BreakpointMgr
+
+    attr_reader :list
+    attr_reader :set
+
+    def initialize
+      clear
+    end
+
+    def clear
+      @list = []
+      @set = Set.new
+    end
+
+    # Remove all breakpoints that we have recorded
+    def finalize
+      @list.each do |bp|
+        bp.related_bp.each { |bp| bp.remove! }
+        bp.remove!
+      end
+      clear
+    end
+
+    def <<(brkpt)
+      @list << brkpt
+      @set.add(set_key(brkpt))
+    end
+
+    def [](index)
+      raise TypeError, 
+      "index #{index} should be a Fixnum, is #{index.class}" unless
+        index.is_a?(Fixnum)
+      @list.detect {|bp| bp.id == index }
+    end
+
+    alias detect []
+
+    def delete(index)
+      bp = detect(index)
+      if bp
+        delete_by_brkpt(bp)
+        return bp
+      else
+        return nil
+      end
+    end
+
+    def delete_by_brkpt(delete_bp)
+      @list = @list.reject{|candidate| candidate == delete_bp}
+      @set  = Set.new(@list.map{|bp| set_key(bp)})
+      delete_bp.remove! unless @set.member?(set_key(delete_bp))
+      return delete_bp
+    end
+
+    def add(*args)
+      brkpt = Trepan::Breakpoint.new(*args)
+      @list << brkpt
+      @set.add(set_key(brkpt))
+      return brkpt
+    end
+
+    def empty?
+      @list.empty?
+    end
+
+    def line_breaks(cm)
+      result = {}
+      @list.each do |bp|
+        if bp.method == cm
+          result[bp.line] = bp 
+        end
+      end
+      result
+    end
+
+    def find(meth, ip)
+      @list.detect do |bp| 
+        if bp.enabled? && bp.ip == ip
+          begin
+            return bp ## if bp.condition?(bind)
+          rescue
+          end 
+        end
+      end
+    end
+
+    def max
+      @list.map{|bp| bp.id}.max || 0
+    end
+
+    # Key used in @set to list unique instruction-sequence offsets.
+    def set_key(bp)
+      [bp.method, bp.ip]
+    end
+
+    def size
+      @list.size
+    end
+
+    def reset
+      @list.each{|bp| bp.remove!}
+      @list = []
+      @set  = Set.new
+    end
+
+  end
+end
+if __FILE__ == $0
+  def bp_status(brkpts, i)
+    puts "list size: #{brkpts.list.size}"
+    puts "set size: #{brkpts.set.size}"
+    puts "max: #{brkpts.max}"
+    p brkpts
+    puts "--- #{i} ---"
+  end
+
+  meth = Rubinius::CompiledMethod.of_sender
+
+  brkpts = Trepan::BreakpointMgr.new
+  ObjectSpace.define_finalizer(brkpts, Proc.new {|arg| brkpts.finalize })
+  brkpts.add("<start>", meth, 0, 0, 1)
+  p brkpts[2]
+  bp_status(brkpts, 1)
+  # offset = frame.pc_offset
+  b2 = Trepan::Breakpoint.new("<2nd one>", meth, 0, 5, 2)
+  brkpts << b2
+  p brkpts.find(b2.method, b2.ip)
+  p brkpts[2]
+  puts '--- 2 ---'
+  ## p brkpts.line_breaks(iseq.source_container)
+  p brkpts.delete(2)
+  p brkpts[2]
+  bp_status(brkpts, 3)
+
+  # Two of the same breakpoints but delete 1 and see that the
+  # other still stays
+  b2 = Trepan::Breakpoint.new("<dup brkpt>", meth, 0, 0, 0)
+  brkpts << b2
+  bp_status(brkpts, 4)
+  b3 = Trepan::Breakpoint.new("<dup brkpt>", meth, 0, 0, 0)
+  brkpts << b3
+  bp_status(brkpts, 5)
+  brkpts.delete_by_brkpt(b2)
+  bp_status(brkpts, 6)
+  brkpts.delete_by_brkpt(b3)
+  bp_status(brkpts, 7)
+  brkpts.finalize
+end

data/app/client.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011, 2012 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'default'                # default debugger settings
+require_relative '../lib/trepanning'      # main Trepan object & initialization
+require_relative '../interface/comcodes'  # communication codes
+
+module Trepanning
+  include Trepanning::RemoteCommunication
+  def start_client(options)
+    puts "Client option given"
+    user_opts = {}
+    %w(readline).each do |opt|
+      user_opts[opt.to_sym] = options[opt.to_sym]
+    end
+    dbgr = Trepan.new(:client      => true,
+                      :cmdfiles    => [],
+                      :initial_dir => options[:chdir],
+                      :nx          => true,
+                      :host        => options[:host],
+                      :port        => options[:port],
+                      :user_opts   => user_opts
+                      )
+    intf = dbgr.intf[-1]
+    while true
+      begin
+        control_code, line = intf.read_remote
+      rescue EOFError, Errno::EPIPE
+        puts "Remote debugged process closed connection"
+        break
+      end
+      # p [control_code, line]
+      case control_code
+      when PRINT
+
+        # FIXME: don't know why server sometimes adds a gratuituous space.
+        # the space is added somewhere inside TCPSocket.print
+        line = line[0..-2] if line.end_with?("\n ")
+
+        print line
+      when CONFIRM_TRUE
+        response = intf.confirm(line, true)
+        intf.write_remote(CONFIRM_REPLY, response ? 'Y' : 'N')
+      when CONFIRM_FALSE
+        response = intf.confirm(line, true)
+        intf.write_remote(CONFIRM_REPLY, response ? 'Y' : 'N')
+      when PROMPT
+        # Printing of prompt has been handled already by PRINT.
+        begin
+          command = intf.read_command(line)
+        rescue EOFError
+          puts "user-side EOF. Quitting..."
+          break
+        end
+        begin 
+          intf.write_remote(COMMAND, command)
+        rescue Errno::EPIPE
+          puts "Remote debugged process died"
+          break
+        end
+      when QUIT
+        break
+      when RESTART
+        break
+      else
+        $stderr.puts "** Unknown control code: #{control_code}"
+      end
+    end
+  end
+  module_function :start_client
+end

data/app/cmd_parse.kpeg

@@ -0,0 +1,242 @@
+# -*- Ruby -*-
+
+%% {
+##################################################### 
+  # Structure to hold composite method names
+  SymbolEntry = Struct.new(:type, :name, :chain)
+
+
+  # Structure to hold position information
+  Position = Struct.new(:container_type, :container,
+                       :position_type,  :position)
+
+  # Structure to hold breakpoint information
+  Breakpoint = Struct.new(:position, :negate, :condition)
+
+  # Structure to hold list information
+  List = Struct.new(:position, :num)
+
+  DEFAULT_OPTS = {
+    :debug=>false, 
+    :file_exists_proc => Proc.new{|filename|
+        File.readable?(filename) && !File.directory?(filename)
+    }
+  }
+  def initialize(str, opts={})
+    @opts = DEFAULT_OPTS.merge(opts)
+    setup_parser(str, opts[:debug])
+    @file_exists_proc = @opts[:file_exists_proc]
+  end
+
+
+   }
+#####################################################
+
+      upcase_letter = /[A-Z]/
+    downcase_letter = /[a-z]/
+      suffix_letter = /[=!?]/ 
+             letter = upcase_letter
+                    | downcase_letter
+          id_symbol = letter | "_" | [0-9]
+
+
+# An variable or a method identifier
+# Examples: 
+#   var1
+#   my_var? 
+# But not: Variable or @var
+vm_identifier = < (downcase_letter | "_") id_symbol* suffix_letter? >
+    { 
+      SymbolEntry.new(:variable, text)
+    }
+
+# Examples: 
+#   var1
+# But not: my_var?, my_var! 
+variable_identifier = < (downcase_letter | "_") id_symbol* >
+    { 
+      SymbolEntry.new(:variable, text)
+    }
+
+# Examples: 
+#   MY_CONSTANT
+#   MyConstant_01
+# But not:
+#   MyConstant_01?
+constant_identifier = < upcase_letter id_symbol* >
+    { 
+      SymbolEntry.new(:constant, text)
+    }
+
+# Examples:
+#   $global_variable
+# We won't try for funny global names like $$, $? $:, $', etc
+global_identifier = < "$" (constant_identifier | variable_identifier) >
+    {
+      SymbolEntry.new(:global, text)
+    }
+
+# Examples: 
+#   Foo
+#   foo
+# But not:
+#   foo!, @foo, Class.foo
+local_internal_identifier = constant_identifier | variable_identifier
+
+# Examples: 
+#   Foo, foo, foo!
+#   foo
+# But not:
+#   @foo, Class.foo
+local_identifier = constant_identifier | vm_identifier
+
+# Example: @foo
+instance_identifier = < '@' local_identifier >
+    {
+      SymbolEntry.new(:instance, text)
+    }     
+
+
+# Example: @@foo
+classvar_identifier = ('@@' local_identifier:id )
+    {
+     SymbolEntry.new(:classvar, id)
+    }     
+
+identifier = global_identifier 
+       | instance_identifier 
+       | classvar_identifier 
+       | local_identifier 
+
+id_separator = < '::'|'.' > { text }
+
+# Like of class_module_chain *after* the first name. So we don't
+# allow sigils in the initial id. That is we don't allow:
+#   Class.@name1.@@name2.$name3  
+# But we do allow final sigils:
+#   class.name!, class.name=
+internal_class_module_chain = 
+    < local_internal_identifier:parent id_separator:sep  
+      internal_class_module_chain:child >
+      {
+         SymbolEntry.new(parent.type, text, [parent, child, sep])
+      }
+    | local_identifier
+
+
+# I think strict Ruby rules are that once one goes from :: to .
+# There is no going back. That is, A.B::C is invalid. 
+# 
+# Also I think method names can't be constants. But such 
+# subtleties we'll handle when we process the final structure.
+# Examples:
+#  Object, A::B, A.b @@foo.bar, $foo.bar.baz? 
+
+class_module_chain = 
+    < identifier:parent id_separator:sep  internal_class_module_chain:child >
+       {
+         SymbolEntry.new(parent.type, text, [parent, child, sep])
+      }
+    | identifier
+
+##############################################################
+# Location-specific things. This is used in conjunction with
+# method-like things above.
+          sp     = /[ \t]/
+           -     = sp+
+     dbl_escapes = "\\\"" { '"' }
+                 | "\\n"  { "\n" }
+                 | "\\t"  { "\t" }
+                 | "\\\\" { "\\" }
+     escapes    = "\\\"" { '"' }
+                 | "\\n"  { "\n" }
+                 | "\\t"  { "\t" }
+                 | "\\ "  { " " }
+                 | "\\:"  { ":" }
+                 | "\\\\" { "\\" }
+   dbl_seq       = < /[^\\"]+/ > { text }
+   dbl_not_quote = (dbl_escapes | dbl_seq)+:ary { ary }
+      dbl_string = "\"" dbl_not_quote:ary "\"" { ary.join }
+not_space_colon  = escapes 
+                 | < /[^ \t\n:]/ > { text }
+not_space_colons = ( not_space_colon )+:ary { ary.join }
+    filename    = dbl_string | not_space_colons
+file_pos_sep    = sp+ | ':'
+     integer    = </[0-9]+/> { text.to_i }
+     sinteger    = </[+-]?[0-9]+/> { text.to_i }
+ line_number    = integer
+
+vm_offset = '@' integer:int
+  {
+    Position.new(nil, nil, :offset, int)
+  }
+
+# Examples:
+#  @43
+#  5
+position = 
+  vm_offset 
+  | line_number:l { 
+  Position.new(nil, nil, :line, l) 
+}
+
+file_colon_line = file_no_colon:file &{ File.exist?(file) } ':' position:pos { 
+  Position.new(:file, file, pos.position_type, pos.position) 
+}
+
+# Examples:
+#   Myclass.fn @5  # bytecode offset 5 of fn
+#   Myclass.fn:@5  # same as above
+#   Myclass.fn 5   # line number 5 of fn
+# Note: Myclass.fn could be either a filename or a method name
+
+# The below ordering is important. 
+# 1. Numbers can't be method names they are first. If there's a 
+#    file with that name, later we'll allow quoting to indicate filename.
+# 2. filename:position can't also be a method so that's next
+# 3. It is possible a filename can be a method name, but we
+#    test using File.exist? so we want to put this first.
+#    Later "quoting" will skip the File.exist?
+# 4. Class module *with* a position is next and has to be before
+#    without a position, else we would stop early before handling
+#    the position.
+
+location = 
+   position 
+ | <filename>:file &{ @file_exists_proc.call(file) } file_pos_sep position:pos {
+      Position.new(:file, file, pos.position_type, pos.position)
+    }
+ | <filename>:file &{ @file_exists_proc.call(file) } {
+      Position.new(:file, file, nil, nil)
+    }
+ | class_module_chain?:fn file_pos_sep position:pos {
+      Position.new(:fn, fn, pos.position_type, pos.position)
+    }
+ | class_module_chain?:fn  {
+      Position.new(:fn, fn, nil, nil)
+    }
+
+if_unless = <"if" | "unless"> { text }
+condition = </.+/> { text}
+
+breakpoint_stmt_no_condition = location:loc  {
+  Breakpoint.new(loc, false, 'true')
+}
+
+# Note that the first word "break" is handled in the command.
+# Also, "break" with nothing else is handled there as well
+breakpoint_stmt = location:loc - if_unless:iu - condition:cond {
+     Breakpoint.new(loc, iu == 'unless', cond)
+}
+ | breakpoint_stmt_no_condition
+
+# Note that the first word "list", "list>" or handled in
+# the command.  Also, "list" with nothing else is
+# handled there as well
+list_special_targets = <'.' | '-'> { text }
+list_stmt = (list_special_targets | location):loc - (sinteger:int)? {
+  List.new(loc, int)
+}
+  | (list_special_targets | location):loc {
+  List.new(loc, nil)
+}

data/app/cmd_parse.rb

@@ -0,0 +1,209 @@
+# use_grammar.rb
+require 'rubygems'
+require 'require_relative'
+require_relative 'cmd_parser'
+
+class Trepan
+  module CmdParser
+
+    # Given a KPeg parse object, return the method of that parse or raise a
+    # Name error if we can't find a method. parent_class is the parent class of
+    # the object we've found so far and "binding" is used if we need
+    # to use eval to find the method.
+    def resolve_method(m, bind, parent_class = nil)
+      name = m.name
+      # DEBUG p  name
+      errmsg = nil
+      if m.type == :constant
+        begin
+          if parent_class
+            klass = parent_class.const_get(m.chain[0].name)
+          else
+            errmsg = "Constant #{m} is not a class or module"
+            raise NameError, errmsg unless m.chain[0]
+            klass = eval(m.chain[0].name, bind)
+          end
+          errmsg = "Constant #{klass} is not a class or module" unless
+          raise NameError, errmsg unless
+            klass.kind_of?(Class) or klass.kind_of?(Module)
+          m = m.chain[1]
+          if klass.instance_methods.member?('binding')
+            bind = klass.bind
+          elsif klass.private_instance_methods.member?('binding')
+            bind = klass.send(:binding)
+          else
+            bind = nil
+          end
+          resolve_method(m, bind, klass)
+        rescue NameError 
+          errmsg ||= "Can't resolve constant #{name}"
+          raise NameError, errmsg
+        end
+      else
+        is_class = 
+          begin
+            m.chain && m.chain[0] && 
+              Class == eval("#{m.chain[0].name}.class", bind) 
+          rescue 
+            false
+          end
+        if is_class
+          # Handles stuff like:
+          #    x = File
+          #    x.basename
+          # Above, we tested we get a class back when we evalate m.chain[0]
+          # below. So it is safe to run the eval.
+          klass = eval("#{m.chain[0].name}", bind)
+          resolve_method(m.chain[1], klass.send(:binding), klass)
+        else
+          begin
+            errmsg = "Can't get method for #{name.inspect}"
+            if m.chain && m.chain[0]
+              parent_obj = eval("#{m.chain[0].name}", bind) if !parent_class && bind
+            end
+            parent = parent_class || parent_obj
+            meth = 
+              if parent
+                errmsg << "in #{parent}"
+                lookup_name = m.chain && m.chain[1] ? m.chain[1].name : name
+                if parent.respond_to?('instance_methods') && 
+                    parent.instance_methods.member?(lookup_name)
+                  parent.instance_method(lookup_name)
+                elsif parent.respond_to?('methods')
+                  parent.method(lookup_name)
+                end
+              elsif m.chain && m.chain[1]
+                eval("#{m.chain[0].name}.method(#{lookup_name.name.inspect})", bind)
+              else
+                eval("self.method(#{name.inspect})", bind)
+              end
+            return meth
+          rescue
+            raise NameError, errmsg
+          end
+        end
+      end
+    end
+
+    # Return the method by evaluating parse_struct.
+    # nil is returned if we can't parse str
+    def meth_for_parse_struct(parse_struct, start_binding)
+      resolve_method(parse_struct, start_binding)
+    end
+
+    # Parse str and return the method associated with that.
+    # nil is returned if we can't parse str
+    def meth_for_string(str, start_binding)
+      @cp ? @cp.setup_parser(str) : @cp = CmdParse.new(str)
+      begin 
+        if @cp._class_module_chain
+          # Did we match all of it?
+          if @cp.result.name == str.strip
+            meth_for_parse_struct(@cp.result, start_binding)
+          else
+            nil
+          end
+        else
+          # FIXME: change to raise ParseError? 
+          nil
+        end
+      rescue NameError
+        return nil
+      end
+    end
+
+    def parse_terminal(terminal_name, loc_str, opts={})
+      @cp ? @cp.setup_parser(loc_str) : @cp = CmdParse.new(loc_str, opts)
+      @cp.send(terminal_name) ? @cp : nil
+    end
+
+    def parse_location(loc_str, opts={})
+      parse = parse_terminal(:_location, loc_str, opts)
+      parse ? parse.result : nil
+    end
+
+    def parse_breakpoint(str, opts={})
+      parse = parse_terminal(:_breakpoint_stmt, str, opts)
+      parse ? parse.result : nil
+    end
+
+    def parse_breakpoint_no_condition(str, opts={})
+      parse = parse_terminal(:_breakpoint_stmt_no_condition, str, opts)
+      parse ? parse.result : nil
+    end
+
+    def parse_list(str, opts={})
+      parse = parse_terminal(:_list_stmt, str, opts)
+      parse ? parse.result : nil
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  %w(a a1 $global __FILE__ Constant 0 1e10 a.b).each do |name|
+    cp = CmdParse.new(name)
+    if cp._identifier && cp.result.name == name
+      p [cp.string, cp.result, 'succeeded']
+    else
+      puts "#{name} failed"
+    end
+  end
+  
+  %w(Object  A::B  A::B::C  A::B::C::D  A::B.c  A.b.c.d  A(5)
+     Rubinius::VariableScope::method_visibility
+     ).each do |name|
+    cp = CmdParse.new(name)
+    if cp._class_module_chain && cp.result.name == name
+      p [cp.string, cp.result, 'succeeded']
+    else
+      puts "#{name} failed"
+    end
+  end
+
+  def five; 5 end
+  include Trepan::CmdParser
+  p meth_for_string('Array.map', binding)
+  p meth_for_string('Rubinius::VM.backtrace', binding)
+  %w(five
+     Array.map
+     Rubinius::VM.backtrace
+     Kernel.eval
+     Kernel::eval).each do |str|
+    meth = meth_for_string(str, binding)
+    p meth
+  end
+  module Testing
+    def testing; 5 end
+    module_function :testing
+  end
+  p meth_for_string('Testing.testing', binding)  
+  p meth_for_string('File.basename', binding)  
+  x = File
+  # require_relative '../lib/trepanning'
+  # debugger
+  p meth_for_string('x.basename', binding)  
+  def x.five; 5; end
+  p  meth_for_string('x.five', binding)  
+  p x.five
+
+  p parse_terminal(:_line_number, '5').result
+  p parse_terminal(:_vm_offset, '@5').result
+
+  # Location stuff
+  ['fn', 'fn 5', 'fn @5', '@5', '5',
+    '../test/example/test\ fname\ with\ blank.rb'].each do |location|
+    p parse_location(location)
+  end
+
+  # require_relative '../lib/trepanning'; debugger
+  # parse_location('../test/example/test\ fname\ with\ blank.rb')
+
+  # Location stuff
+  ['fn if a > b', 'fn 5 unless c > d', 'fn:5 if x', '@5', '5'].each do |str|
+    p parse_breakpoint(str)
+  end
+
+
+end
+