rbx-trepanning 0.0.7-universal-rubinius-1.2 → 0.0.8-universal-rubinius-1.2

data/processor/validate.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 
 # Trepan command input validation routines.  A String type is
 # usually passed in as the argument to validation routines.
@@ -6,10 +6,15 @@
 require 'rubygems'
 require 'require_relative'
 require 'linecache'
+
+require_relative '../app/cmd_parse'
+require_relative '../app/condition'
 require_relative '../app/method'
 require_relative '../app/validate'
-## require_relative '../app/condition'
-## require_relative '../app/file'
+
+require_relative 'location' # for resolve_file_with_dir
+require_relative 'msg'      # for errmsg, msg
+
 class Trepan
   class CmdProcessor
 
@@ -19,7 +24,7 @@ class Trepan
     include Trepanning::Method
     include Trepan::Validate
     ## include Trepan::ThreadHelper
-    ## include Trepan::Condition
+    include Trepan::Condition
 
     def confirm(msg, default)
       @settings[:confirm] ? @dbgr.intf[-1].confirm(msg, default) : true
@@ -129,70 +134,56 @@ class Trepan
       end
     end
 
-    # Parse a breakpoint position. On success return
-    #   - a string "description" 
-    #   - the method the position is in - a CompiledMethod or a String
-    #   - the line - a Fixnum
-    #   - whether the position is an instance or not
-    # On failure, an error message is shown and we return nil.
-    def breakpoint_position(args)
-      ip = nil
-      if args.size == 0
-        args = [frame.line.to_s]
-      end
-      if args[0] == 'main.__script__'
-        if args.size > 2
-          errmsg 'Expecting only a line number'
-          return nil
-        elsif args.size == 2
-          ip, line = line_or_ip(args[1])
-          unless line || ip
-            errmsg ("Expecting a line or an IP offset number")
-            return nil 
+    def position_to_line_and_offset(cm, filename, position, offset_type)
+      case offset_type
+      when :line
+        vm_offset = cm.first_ip_on_line(position, -2)
+        line_no   =  position
+      when :offset
+        line_no   = cm.line_from_ip(position)
+        vm_offset = position
+      when nil
+        vm_offset, line_no = 
+          if cm.lines[0] == -1
+            [cm.lines[2], cm.lines.size > 3 ? cm.lines[3] : cm.lines[1]]
+           else
+            [cm.lines[0], cm.lines[1]]
           end
+      else
+        errmsg "Bad parse offset_type: #{offset_type.inspect}"
+        return [nil, nil]
+      end
+      return [line_no, vm_offset]
+    end
+
+    # Parse a breakpoint position. On success return:
+    #   - the CompileMethod the position is in
+    #   - the line number - a Fixnum
+    #   - vm_offset       - a Fixnum
+    #   - the condition (by default 'true') to use for this breakpoint
+    #   - true condition should be negated. Used in *condition* if/unless
+    def breakpoint_position(position_str, allow_condition)
+      break_cmd_parse = if allow_condition
+                          parse_breakpoint(position_str)
+                        else
+                          parse_breakpoint_no_condition(position_str)
+                        end
+      return [nil] * 5 unless break_cmd_parse
+      tail = [break_cmd_parse.condition, break_cmd_parse.negate]
+      cm, file, position, offset_type = 
+        parse_position(break_cmd_parse.position)
+      if cm
+        line_no, vm_offset = 
+          position_to_line_and_offset(cm, file, position, offset_type)
+        if vm_offset && line_no
+          return [cm, line_no, vm_offset] + tail
         else
-          ip, line = nil, nil
-        end
-        return [args.join(' '), '.', '__script__', line, ip]
-      elsif args.size == 1
-        meth = parse_method(args[0])
-        if meth
-          cm = meth.executable
-          return [args[0], nil, true, cm, cm.lines[1], cm.lines[0]]
-        else
-          m = /([A-Z]\w*(?:::[A-Z]\w*)*)([.#])(\w+[!?=]?)(?:[:]([oO])?(\d+))?/.match(args[0])
-          if m
-            if m[4]
-              return [m[0], m[1], m[2], m[3], nil, m[5] ? m[5].to_i : nil]
-            else
-              return [m[0], m[1], m[2], m[3], (m[4] ? m[4].to_i : nil), nil]
-            end
-          else
-            ip, line = line_or_ip(args[0])
-            unless line || ip
-              errmsg ("Expecting a line or an IP offset number")
-              return nil 
-            end
-            if line
-              meth = find_method_with_line(frame.method, line)
-              unless meth
-                errmsg "Cannot find method location for line #{line}"
-                return nil 
-              end
-              return [meth.name.to_s, nil, '#', meth, line, nil]
-            elsif valid_ip?(frame.method, ip)
-              return [args.join(' '), meth.class, '#', frame.method, nil, ip]
-            else
-              errmsg 'Cannot parse breakpoint location'
-              return nil
-            end
-            
-            return ["#{meth.describe}", nil, '#', meth, line, nil]
-          end
+          errmsg("Unable to set breakpoint in #{cm}")
+          return
         end
       end
-      errmsg 'Cannot parse breakpoint location'
-      return nil
+      errmsg("Unable to get breakpoint position for #{position_str}")
+      return [nil] * 5
     end
 
     # Return true if arg is 'on' or 1 and false arg is 'off' or 0.
@@ -216,95 +207,94 @@ class Trepan
       raise TypeError
     end
 
-    def method?(method_string)
-      obj, type, meth = 
-        if method_string =~ /(.+)(#|::|\.)(.+)/
-          [$1, $2, $3]
-        else
-          ['self', '.', method_string]
+    include CmdParser
+
+    def get_method(meth)
+      start_binding = 
+        begin
+          @frame.binding
+        rescue
+          binding
         end
-      ret = debug_eval_no_errmsg("#{obj}.method(#{meth.inspect})")
-      return true if ret 
-      return debug_eval_no_errmsg("#{obj}.is_a?(Class)") &&
-        debug_eval_no_errmsg("#{obj}.method_defined?(#{meth.inspect})")
+      if meth.kind_of?(String)
+        meth_for_string(meth, start_binding)
+      else
+        begin
+          meth_for_parse_struct(meth, start_binding)
+        rescue NameError
+          errmsg("Can't evaluate #{meth.name} to get a method")
+          return nil
+        end
+      end
+    end
+
+    # FIXME: this is a ? method but we return 
+    # the method value. 
+    def method?(meth)
+      get_method(meth)
     end
 
-    # parse_position(self, arg)->(fn, container, lineno)
-    # 
+    # parse_position(self, arg)->(meth, filename, offset, offset_type)
+    # See app/cmd_parser.kpeg for the syntax of a position which
+    # should include things like:
     # Parse arg as [filename:]lineno | function | module
     # Make sure it works for C:\foo\bar.py:12
-    def parse_position(arg, old_mod=nil, allow_offset = false)
-        colon = arg.rindex(':') 
-        if colon
-          # First handle part before the colon
-          arg1 = arg[0...colon].rstrip
-          lineno_str = arg[colon+1..-1].lstrip
-          mf, container, lineno = parse_position_one_arg(arg1, old_mod, false, allow_offset)
-          return nil, nil, nil unless container
-          filename = canonic_file(arg1) 
-          # Next handle part after the colon
-          val = get_an_int(lineno_str)
-          lineno = val if val
+    def parse_position(info)
+      info = parse_location(info) if info.kind_of?(String)
+      case info.container_type
+      when :fn
+        unless info.container
+          errmsg "Bad function parse #{info.container.inspect}"
+          return
+        end
+        if meth = method?(info.container)
+          cm = meth.executable
+          return [cm, canonic_file(cm.active_path), info.position, 
+                  info.position_type]
         else
-          mf, container, lineno = parse_position_one_arg(arg, old_mod, true, allow_offset)
+          return [nil] * 4
         end
-
-        return mf, container, lineno
-    end
-
-    # parse_position_one_arg(self,arg)->(module/function, container, lineno)
-    #
-    # See if arg is a line number, function name, or module name.
-    # Return what we've found. nil can be returned as a value in
-    # the triple.
-    def parse_position_one_arg(arg, old_mod=nil, show_errmsg=true, allow_offset=false)
-      name, filename = nil, nil, nil
-      begin
-        # First see if argument is an integer
-        lineno    = Integer(arg)
-      rescue
-      else
-        filename  = @frame.file
-        return nil, canonic_file(filename), lineno
-      end
-
-      # Next see if argument is a file name 
-      if LineCache::cached?(arg)
-        return nil, canonic_file(arg), 1 
-      elsif File.readable?(arg)
-        return nil, canonic_file(arg), 1 
-      end
-
-      # How about a method name with an instruction sequence?
-      meth = parse_method(arg)
-      if meth
-        cm = meth.executable
-        return arg, canonic_file(cm.active_path), cm.lines[1]
-      end
-
-      if show_errmsg
-        unless (allow_offset && arg.size > 0 && arg[0].downcase == 'o')
-          errmsg("#{arg} is not a line number, filename or method " +
-                 "we can get location information about")
+      when :file
+        filename = canonic_file(info.container)
+        cm = 
+          if canonic_file(@frame.file) == filename 
+            cm = @frame.method
+            if :line == info.position_type
+              find_method_with_line(cm, info.position)
+            end
+          else 
+            LineCache.compiled_method(filename)
+          end
+        return cm, filename,  info.position, info.position_type
+      when nil
+        if [:line, :offset].member?(info.position_type)
+          filename = @frame.file
+          cm = @frame.method
+          if :line == info.position_type
+            cm = find_method_with_line(cm, info.position)
+          end
+          return [cm, canonic_file(filename), info.position, info.position_type]
+        elsif !info.position_type
+          errmsg "Can't parse #{arg} as a position"
+          return [nil] * 4
+        else
+          errmsg "Unknown position type #{info.position_type} for location #{arg}"
+          return [nil]  * 4
         end
+      else
+        errmsg "Unknown container type #{info.container_type} for location #{arg}"
+        return [nil] * 4
       end
-      return nil, nil, nil
     end
-    
+
     def parse_method(meth_str)
-      # For meth_str = "foo", try via method("foo".to_sym)
-      str = "method(#{meth_str.inspect}.to_sym)"
-      meth = debug_eval_no_errmsg(str)
-      return meth if meth
-      last_dot = meth_str.rindex('.')
-      if last_dot
-        # For meth_str = "a.b.foo",
-        # try via a.b.method("foo".to_sym)
-        try_eval = "#{meth_str[0..last_dot]}method" + 
-          "(#{meth_str[last_dot+1..-1].inspect}.to_sym)"
-        meth = debug_eval_no_errmsg(try_eval)
+      begin 
+        meth_for_string(meth_str, @frame.binding)
+      rescue NameError
+        nil
+      rescue
+        nil
       end
-      return meth
     end
 
     def validate_initialize
@@ -316,24 +306,36 @@ end
 
 if __FILE__ == $0
   # Demo it.
-  require_relative './mock'
+  # FIXME have to pull in main for its initalize routine
+  DIRNAME = File.dirname(__FILE__)
+  load File.join(DIRNAME, 'main.rb')
+
+  require_relative 'mock'
   dbgr, cmd = MockDebugger::setup('exit', false)
-  proc  = cmd.proc
+  cmdproc  = cmd.proc
   onoff = %w(1 0 on off)
-  onoff.each { |val| puts "onoff(#{val}) = #{proc.get_onoff(val)}" }
+  onoff.each { |val| puts "onoff(#{val}) = #{cmdproc.get_onoff(val)}" }
   %w(1 1E bad 1+1 -5).each do |val| 
-    puts "get_int_noerr(#{val}) = #{proc.get_int_noerr(val).inspect}" 
+    puts "get_int_noerr(#{val}) = #{cmdproc.get_int_noerr(val).inspect}" 
   end
   def foo; 5 end
-  def proc.errmsg(msg)
+  def cmdproc.errmsg(msg)
     puts msg
   end
-  puts proc.parse_position_one_arg('tmpdir.rb').inspect
+
+  pos = cmdproc.parse_position('../../rubies/rbx-head/bin/irb')
+  puts pos.inspect
+
+  puts cmdproc.parse_position(__FILE__).inspect
+  puts cmdproc.parse_position('@8').inspect
+  puts cmdproc.parse_position('8').inspect
+  puts cmdproc.parse_position("#{__FILE__} #{__LINE__}").inspect
   
+  cmdproc.method?('cmdproc.errmsg')
   puts '=' * 40
-  ['Array#map', 'Trepan::CmdProcessor.new',
-   'foo', 'proc.errmsg'].each do |str|
-    puts "#{str} should be true: #{proc.method?(str).inspect}"
+  ['Array.map', 'Trepan::CmdProcessor.new',
+   'foo', 'cmdproc.errmsg'].each do |str|
+    puts "#{str} should be true: #{cmdproc.method?(str).inspect}"
   end
   puts '=' * 40
   
@@ -342,15 +344,25 @@ if __FILE__ == $0
   # Trepan::CmdProcessor.allocate should be false: true
   
   ['food', '.errmsg'].each do |str|
-    puts "#{str} should be false: #{proc.method?(str).inspect}"
+    puts "#{str} should be false: #{cmdproc.method?(str).inspect}"
   end
   puts '-' * 20
-  # require_relative '../lib/trepanning'
-  # Trepan.start
-  p proc.breakpoint_position(%w(O0))
-  p proc.breakpoint_position(%w(1))
-  p proc.breakpoint_position(%w(__LINE__))
-  # p proc.breakpoint_position(%w(2 if a > b))
-  p proc.get_int_list(%w(1+0 3-1 3))
-  p proc.get_int_list(%w(a 2 3))
+
+  puts "Trepan::CmdProcessor.allocate is: #{cmdproc.get_method('Trepan::CmdProcessor.allocate')}"
+
+  # require_relative '../lib/trepanning'; debugger
+  # pos = cmdproc.breakpoint_position('../processor/validate.rb', true)
+  # p ['breakpoint validate', pos]
+
+  p cmdproc.breakpoint_position('foo', true)
+  p cmdproc.breakpoint_position('@0', true)
+  p cmdproc.breakpoint_position("#{__LINE__}", true)
+  p cmdproc.breakpoint_position("#{__FILE__}   @0", false)
+  p cmdproc.breakpoint_position("#{__FILE__}:#{__LINE__}", true)
+  p cmdproc.breakpoint_position("#{__FILE__} #{__LINE__} if 1 == a", true)
+  p cmdproc.breakpoint_position("cmdproc.errmsg", false)
+  p cmdproc.breakpoint_position("cmdproc.errmsg:@0", false)
+  ### p cmdproc.breakpoint_position(%w(2 if a > b))
+  p cmdproc.get_int_list(%w(1+0 3-1 3))
+  p cmdproc.get_int_list(%w(a 2 3))
 end

data/rbx-trepanning.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.add_dependency('columnize')
   s.add_dependency('diff-lcs') # For testing only
   s.add_dependency('rbx-require-relative')
-  s.add_dependency('rbx-linecache', '~>1.0')
+  s.add_dependency('rbx-linecache', '~>1.2')
   s.authors      = ['R. Bernstein']
   s.date         = Time.now
   s.description = <<-EOF

data/test/example/debugger-stop.rb

@@ -0,0 +1,16 @@
+# !/usr/bin/env ruby
+# Bug in debugger in 1.9.2 only in that where 
+# stopping where we were inside debugger was stopping
+# inside itself because multiple debugger names in the presence of modules
+# 
+require 'rubygems'; require 'require_relative'
+require_relative '../../lib/trepanning'
+module Foo
+  module_function
+  def five
+    debugger  # Resolves to Module#debugger not Kernel#debugger
+    5
+  end
+end
+debugger
+Foo::five

data/test/functional/test-break-name.rb

@@ -21,7 +21,7 @@ class TestNameBreak < Test::Unit::TestCase
     # Check that we can set breakpoints in parent, sibling and children
     # of sibling returns. We have one more 'continue' than we need
     # just in case something goes wrong.
-    cmds = ['break Object#five', 'break TestNameBreak#five?',
+    cmds = ['break Object.five', 'break TestNameBreak.five?',
             'break TestNameBreak.six=', 
             'continue', 'continue', 'continue', 'continue']
             

data/test/functional/test-eval.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'rubygems'; require 'require_relative'
+require_relative 'fn_helper'
+
+class TestEval < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def test_eval_questionmark
+
+    # See that eval? strips 'if'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    if 3 > 5
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'if 3 > 5', 'eval: 3 > 5', '$d0 = false']
+    compare_output(out, d, cmds)
+    
+    # See that eval? strips 'if' and 'then'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    if 3 > 5 then
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'if 3 > 5 then', 'eval: 3 > 5', '$d0 = false']
+    compare_output(out, d, cmds)
+    
+    # See that eval? strips 'unless'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    unless 3 < 5
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'unless 3 < 5', 'eval: 3 < 5', '$d0 = true']
+    compare_output(out, d, cmds)
+    
+    # See that eval? strips 'unless' and 'then
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    unless 3 < 5 then
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'unless 3 < 5 then', 'eval: 3 < 5', '$d0 = true']
+    compare_output(out, d, cmds)
+    
+    # See that eval? strips 'while'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    while nil
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'while nil', 'eval: nil', '$d0 = nil']
+    compare_output(out, d, cmds)
+    
+    # See that eval? strips 'while' and 'do'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    while nil do
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'while nil do', 'eval: nil', '$d0 = nil']
+    compare_output(out, d, cmds)
+    
+    # See that eval? strips 'until' and 'do'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    until true do
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'until true do', 'eval: true', '$d0 = true']
+    compare_output(out, d, cmds)
+
+    # See that eval? strips 'until'
+    cmds = %w(eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    until true
+      assert false
+    end
+    d.stop
+    out = ['-- ', 'until true', 'eval: true', '$d0 = true']
+    compare_output(out, d, cmds)
+
+    # See that eval? strips 'return'
+    def five
+      return 5
+    end
+    cmds = %w(step eval? continue)
+    d = strarray_setup(cmds)
+    d.start
+    five
+    d.stop
+    out = ['-- ', 'five', '-> ', 'return 5', 'eval: 5', '$d0 = 5']
+    compare_output(out, d, cmds)
+  end
+    
+end
+
+

data/test/functional/test-tbreak.rb

@@ -18,7 +18,7 @@ class TestTBreak < Test::Unit::TestCase
     # Check that temporary breaks are, well, temporary.
     # The last "continue" below isn't used. It to make sure we finish
     # the test even when the breakpoint isn't temporary.
-    cmds = ['tbreak TestTBreak#foo', 'continue', 'continue', 'continue'] 
+    cmds = ['tbreak TestTBreak.foo', 'continue', 'continue', 'continue'] 
     d = strarray_setup(cmds)
     d.start
     ##############################

data/test/integration/helper.rb

@@ -33,7 +33,8 @@ def run_debugger(testname, ruby_file, opts={})
 
   FileUtils.rm(outfile) if File.exist?(outfile)
 
-  cmd = 
+  cmd = opts[:feed_input] ? "#{opts[:feed_input]} |" : ''
+  cmd += 
     if opts[:xdebug]
     "%s -Xdebug '%s' %s >%s 2>&1 <%s" %
         [Trepanning::ruby_path, programfile, opts[:args], outfile, cmdfile]
@@ -45,13 +46,15 @@ def run_debugger(testname, ruby_file, opts={})
         [Trepanning::ruby_path, dbgr_path, cmdfile, opts[:dbgr], 
          programfile, opts[:args], outfile]
     end
-  
+  puts cmd if opts[:verbose]
   system(cmd)
   return false unless 0 == $?.exitstatus 
   if opts[:do_diff]
     expected_lines = File.open(rightfile).readlines()
     got_lines      = File.open(outfile).readlines()
     opts[:filter].call(got_lines, expected_lines) if opts[:filter]
+    # puts "=" * 80
+    # got_lines.map{|line| puts line}
     
     # Seems to be a bug in LCS in that it will return a diff even if two
     # files are the same.

data/test/unit/cmd-helper.rb

@@ -11,7 +11,7 @@ module UnitHelper
 
   module_function
   def common_setup
-    @dbg      = MockDebugger::MockDebugger.new(:nx => true)
+    @dbg      ||= MockDebugger::MockDebugger.new(:nx => true)
     @cmdproc  = Trepan::CmdProcessor.new(@dbg)
     @cmdproc.frame_initialize
     @cmdproc.dbgr  = @dbg