trepanning 0.0.4

data/processor/validate.rb

@@ -0,0 +1,395 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Trepan command input validation routines.  A String type is
+# usually passed in as the argument to validation routines.
+
+require_relative '../app/condition'
+require_relative '../app/file'
+require_relative '../app/thread'
+
+require_relative 'location' # for resolve_file_with_dir
+require_relative 'msg'      # for errmsg, msg
+
+class Trepan
+  class CmdProcessor
+
+    attr_reader :dbgr_script_iseqs
+    attr_reader :dbgr_iseqs
+
+    include Trepanning
+    include Trepan::ThreadHelper
+    include Trepan::Condition
+
+    def confirm(msg, default)
+      @dbgr.intf[-1].confirm(msg, default)
+    end
+
+    # Like cmdfns.get_an_int(), but if there's a stack frame use that
+    # in evaluation.
+    def get_an_int(arg, opts={})
+      ret_value = get_int_noerr(arg)
+      if !ret_value
+        if opts[:msg_on_error]
+          errmsg(opts[:msg_on_error])
+        else
+          errmsg("Expecting an integer, got: #{arg}.")
+        end
+        return nil
+      end
+      if opts[:min_value] and ret_value < opts[:min_value]
+        errmsg("Expecting integer value to be at least %d; got %d." %
+               [opts[:min_value], ret_value])
+        return nil
+      elsif opts[:max_value] and ret_value > opts[:max_value]
+        errmsg("Expecting integer value to be at most %d; got %d." %
+               [opts[:max_value], ret_value])
+        return nil
+      end
+      return ret_value
+    end
+
+    unless defined?(DEFAULT_GET_INT_OPTS)
+      DEFAULT_GET_INT_OPTS = {
+        :min_value => 0, :default => 1, :cmdname => nil, :max_value => nil}
+    end
+
+    # If argument parameter 'arg' is not given, then use what is in
+    # opts[:default]. If String 'arg' evaluates to an integer between
+    # least min_value and at_most, use that. Otherwise report an
+    # error.  If there's a stack frame use that for bindings in
+    # evaluation.
+    def get_int(arg, opts={})
+      
+      return default unless arg
+      opts = DEFAULT_GET_INT_OPTS.merge(opts)
+      val = arg ? get_int_noerr(arg) : opts[:default]
+      unless val
+        if opts[:cmdname]
+          errmsg(("Command '%s' expects an integer; " +
+                  "got: %s.") % [opts[:cmdname], arg])
+        else
+          errmsg('Expecting a positive integer, got: %s' % arg)
+        end
+        return nil
+      end
+      
+      if val < opts[:min_value]
+        if cmdname
+          errmsg(("Command '%s' expects an integer at least" +
+                  ' %d; got: %d.') %
+                 [cmdname, opts[:min_value], opts[:default]])
+        else
+          errmsg(("Expecting a positive integer at least" +
+                  ' %d; got: %d') %
+                 [opts[:min_value], opts[:default]])
+        end
+        return nil
+      elsif opts[:max_value] and val > opts[:max_value]
+        if opts[:cmdname]
+          errmsg(("Command '%s' expects an integer at most" +
+                  ' %d; got: %d.') %
+                 [opts[:cmdname], opts[:max_value], val])
+        else
+          errmsg(("Expecting an integer at most %d; got: %d") %
+                 [opts[:max_value], val])
+        end
+        return nil
+      end
+      return val
+    end
+
+    def get_int_list(args, opts={})
+      args.map{|arg| get_an_int(arg, opts)}.compact
+    end
+    
+    # Eval arg and it is an integer return the value. Otherwise
+    # return nil
+    def get_int_noerr(arg)
+      b = @frame ? @frame.binding : nil
+      val = Integer(eval(arg, b))
+    rescue SyntaxError
+      nil
+    rescue 
+      nil
+    end
+
+    def get_thread_from_string(id_or_num_str)
+      if id_or_num_str == '.'
+        Thread.current
+      elsif id_or_num_str.downcase == 'm'
+        Thread.main
+      else
+        num = get_int_noerr(id_or_num_str)
+        if num
+          get_thread(num)
+        else
+          nil
+        end
+      end
+    end
+
+    # Return the instruction sequence associated with string
+    # OBJECT_STRING or nil if no instruction sequence
+    def object_iseq(object_string)
+      iseqs = find_iseqs(ISEQS__, object_string)
+      # FIXME: do something if there is more than one.
+      if iseqs.size == 1
+         iseqs[-1]
+      elsif debug_eval_no_errmsg("#{object_string}.respond_to?('iseq')")
+        debug_eval_no_errmsg("#{object_string}.iseq")
+      else
+        parts = object_string.split(/[.]/)
+        string = 
+          if parts.size < 2 
+            "method(\"#{object_string}\").iseq"
+          else
+            parts[0..-2].join('.')+".method(\"#{parts[-1]}\").iseq"
+          end
+        debug_eval_no_errmsg(string)
+      end
+    rescue
+      nil
+    end
+
+    # Parse a breakpoint position. Return
+    # - the position - a Fixnum
+    # - the instruction sequence to use
+    # - whether the postion is an offset or a line number
+    # - the condition (by default 'true') to use for this breakpoint
+    # - the condition (by default 'true') to use for this breakpoint
+    def breakpoint_position(args)
+      first = args.shift
+      name, container, position = parse_position(first, nil, true)
+      if container && position
+        iseq = find_iseqs_with_lineno(container[1], position) || object_iseq(first)
+        unless iseq
+          if @frame.iseq && 
+              File.basename(@frame.iseq.source_container[1]) == 
+              File.basename(container[1])
+            iseq = @frame.iseq
+          else
+            errmsg "Unable to find instruction sequence for position #{position} in #{container[1]}"
+            return [nil, nil, nil, true]
+          end
+        end
+        use_offset = false 
+      else
+        iseq = object_iseq(first)
+        position_str = 
+          if iseq
+            # Got name and possibly position
+            name = first
+            if args.empty? 
+              # FIXME: *Still* have a bug stopping at offset 0.
+              # So stop at next offset after 0.
+              # 'o0' 
+              "o#{@frame.iseq.offsetlines.keys.sort[1]}"
+            else
+              args.shift
+            end
+          else
+            iseq = @frame.iseq unless container
+            first
+          end
+        use_offset = 
+          if position_str.size > 0 && position_str[0].downcase == 'o'
+            position_str[0] = ''
+            true
+          else
+            false
+          end
+        opts = {
+          :msg_on_error => 
+          "argument '%s' does not seem to eval to a method or an integer." % 
+          position_str,
+          :min_value => 0
+        }
+        position  = get_an_int(position_str, opts)
+      end
+      condition = 'true'
+      if args.size > 0 && 'if' == args[0] 
+        condition_try = args[1..-1].join(' ')
+        condition = condition_try if valid_condition?(condition_try)
+      end
+      return [position, iseq, use_offset, condition, name]
+    end
+
+    # Return true if arg is 'on' or 1 and false arg is 'off' or 0.
+    # Any other value is raises TypeError.
+    def get_onoff(arg, default=nil, print_error=true)
+      unless arg
+        if !default
+          if print_error
+            errmsg("Expecting 'on', 1, 'off', or 0. Got nothing.")
+          end
+          raise TypeError
+        end
+        return default
+      end
+      darg = arg.downcase
+      return true  if arg == '1' || darg == 'on'
+      return false if arg == '0' || darg =='off'
+
+      errmsg("Expecting 'on', 1, 'off', or 0. Got: %s." % arg.to_s) if
+        print_error
+      raise TypeError
+    end
+
+    def method?(method_string)
+      obj, type, meth = 
+        if method_string =~ /(.+)(#|::|\.)(.+)/
+          [$1, $2, $3]
+        else
+          ['self', '.', method_string]
+        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})")
+    end
+
+    # parse_position(self, arg)->(fn, container, lineno)
+    # 
+    # 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
+      else
+        mf, container, lineno = parse_position_one_arg(arg, old_mod, true, allow_offset)
+      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
+        container = frame_container(@frame, false)
+        filename  = container[1] unless old_mod
+        return nil, [container[0], canonic_file(filename)], lineno
+      end
+
+      # Next see if argument is a file name 
+      found = 
+        if arg[0..0] == File::SEPARATOR
+          LineCache::cached?(arg)
+        else
+          resolve_file_with_dir(arg)
+        end
+      if found
+        return nil, [container && container[0], canonic_file(arg)], 1 
+      else
+        matches = find_scripts(arg)
+        if matches.size > 1
+          if show_errmsg
+            errmsg "#{arg} is matches several files:"
+            errmsg Columnize::columnize(matches.sort, 
+                                        @settings[:width], ' ' * 4, 
+                                        true, true, ' ' * 2).chomp
+          end
+          return nil, nil, nil
+        elsif matches.size == 1
+          LineCache::cache(matches[0])
+          return nil, ['file', matches[0]], 1
+        end
+      end
+
+      # How about a method name with an instruction sequence?
+      iseq = object_iseq(arg)
+      if iseq && iseq.source_container[0] == 'file'
+        filename = iseq.source_container[1]
+        line_no = iseq.offsetlines.values.flatten.min
+        return arg, ['file', canonic_file(filename)], line_no
+      end
+
+      if show_errmsg
+        unless (allow_offset && arg.size > 0 && arg[0].downcase == 'o')
+          errmsg("#{arg} is not a line number, read-in filename or method " +
+                 "we can get location information about")
+        end
+      end
+      return nil, nil, nil
+    end
+    
+    def validate_initialize
+      ## top_srcdir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      ## @dbgr_script_iseqs, @dbgr_iseqs = filter_scripts(top_srcdir)
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  if !(ARGV.size == 1 && ARGV[0] == 'noload')
+    ARGV[0..-1]    = ['noload']
+    load(__FILE__)
+  else    
+    require 'thread_frame'
+    require_relative '../app/mock'
+    require_relative 'main' # Have to include before defining CmdProcessor!
+                            # FIXME
+
+    proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    proc.settings[:directory] = '$cwd'
+    proc.frame_setup(RubyVM::ThreadFrame.current)
+    onoff = %w(1 0 on off)
+    onoff.each { |val| puts "onoff(#{val}) = #{proc.get_onoff(val)}" }
+    %w(1 1E bad 1+1 -5).each do |val| 
+      puts "get_int_noerr(#{val}) = #{proc.get_int_noerr(val).inspect}" 
+    end
+    def foo; 5 end
+    def proc.errmsg(msg)
+      puts msg
+    end
+    puts proc.object_iseq('food').inspect
+    puts proc.object_iseq('foo').inspect
+
+    puts proc.object_iseq('foo@validate.rb').inspect
+    puts proc.object_iseq('proc.object_iseq').inspect
+    
+    puts proc.parse_position_one_arg('tmpdir.rb').inspect
+
+    puts '=' * 40
+    ['Array#map', 'Trepan::CmdProcessor.new',
+     'foo', 'proc.errmsg'].each do |str|
+      puts "#{str} should be true: #{proc.method?(str).inspect}"
+    end
+    puts '=' * 40
+    # require_relative '../lib/trepanning'
+    # dbgr = Trepan.new(:set_restart => true)
+    # dbgr.debugger
+
+    # FIXME:
+    # Array#foo should be false: true
+    # Trepan::CmdProcessor.allocate should be false: true
+
+    ['food', '.errmsg'].each do |str|
+      puts "#{str} should be false: #{proc.method?(str).inspect}"
+    end
+    puts '-' * 20
+    p proc.breakpoint_position(%w(O0))
+    p proc.breakpoint_position(%w(1))
+    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))
+  end
+end

data/test/example/fname with blank.rb

@@ -0,0 +1 @@
+puts "Ha!"

data/test/example/gcd-xx.rb

@@ -0,0 +1,18 @@
+
+# GCD. We assume positive numbers
+def gcd(a, b)
+  # Make: a <= b
+  if a > b
+    a, b = [b, a]
+  end
+
+  return nil if a <= 0
+  addline
+
+  if a == 1 or b-a == 0
+    return a
+  end
+end
+
+a, b = ARGV[0..1].map {|arg| arg.to_i}
+puts "The GCD of %d and %d is %d" % [a, b, gcd(a, b)]

data/test/example/gcd.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+# GCD. We assume positive numbers
+def gcd(a, b)
+  # Make: a <= b
+  if a > b
+    a, b = [b, a]
+  end
+
+  return nil if a <= 0
+
+  if a == 1 or b-a == 0
+    return a
+  end
+  return gcd(b-a, a)
+end
+
+a, b = ARGV[0..1].map {|arg| arg.to_i}
+puts "The GCD of %d and %d is %d" % [a, b, gcd(a, b)]

data/test/example/gcd1.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'thread_frame'
+tf = RubyVM::ThreadFrame.current
+iseq = tf.iseq
+p iseq.child_iseqs
+puts iseq.disassemble
+
+# GCD. We assume positive numbers
+def gcd(a, b)
+  # Make: a <= b
+  if a > b
+    a, b = [b, a]
+  end
+
+  return nil if a <= 0
+
+  if a == 1 or b-a == 0
+    return a
+  end
+  return gcd(b-a, a)
+end
+
+a, b = ARGV[0..1].map {|arg| arg.to_i}
+puts "The GCD of %d and %d is %d" % [a, b, gcd(a, b)]

data/test/example/null.rb

@@ -0,0 +1 @@
+# Nothing here. Move along.

data/test/example/thread1.rb

@@ -0,0 +1,3 @@
+Thread.new do 
+  x = 1
+end.join

data/test/functional/fn_helper.rb

@@ -0,0 +1,119 @@
+require 'thread_frame'
+require 'trace'
+require_relative '../../lib/trepanning'
+require_relative '../../io/string_array'
+
+module FnTestHelper
+  include Trace
+
+  # Synchronous events without C frames or instructions
+  TEST_STEP_EVENT_MASK = LINE_EVENT_MASK | CLASS_EVENT_MASK | CALL_EVENT_MASK |
+    RETURN_EVENT_MASK  
+
+  # Common setup to create a debugger with String Array I/O attached
+  def strarray_setup(debugger_cmds, insn_stepping=false)
+    stringin               = Trepan::StringArrayInput.open(debugger_cmds)
+    stringout              = Trepan::StringArrayOutput.open
+    d_opts                 = {:input  => stringin, :output => stringout,
+                              :nx     => true}
+    d_opts[:core_opts]     = {:step_events => TEST_STEP_EVENT_MASK}
+    d_opts[:core_opts][:step_events] ||= INSN_EVENT_MASK if insn_stepping
+    d                      = Trepan.new(d_opts)
+
+    # Remove vm and switch from unmaskable events to increase predictability
+    # of test results
+    d.core.instance_variable_set('@unmaskable_events', %w(brkpt raise))
+
+    d.settings[:basename]  = true
+    d.settings[:different] = false
+    d.settings[:autoeval]  = false
+    return d
+  end
+
+  unless defined?(TREPAN_PROMPT)
+    TREPAN_PROMPT = /^\(trepan\): /
+    TREPAN_LOC    = /.. \(.+:\d+\)/
+  end
+
+  # Return the caller's line number
+  def get_lineno
+    RubyVM::ThreadFrame.current.prev.source_location[0]
+  end
+
+  def compare_output(right, d, debugger_cmds)
+    # require_relative '../../lib/trepanning'
+    # Trepan.debug(:set_restart => true)
+    got = filter_line_cmd(d.intf[-1].output.output)
+    if got != right
+      got.each_with_index do |got_line, i|
+        if i < right.size and got_line != right[i]
+          # dbgr.debugger
+          puts "! #{got_line}"
+        else
+          puts "  #{got_line}"
+        end
+      end
+      puts '-' * 10
+      right.each_with_index do |right_line, i|
+        if i < got.size and got[i] != right_line
+          # dbgr.debugger
+          puts "! #{right_line}"
+        else
+          puts "  #{right_line}"
+        end
+      end
+    end
+    assert_equal(right, got, caller[0])
+  end
+
+  # Return output with source lines prompt and command removed
+  def filter_line_cmd(a, show_prompt=false)
+    # Remove debugger prompt
+    a = a.map do |s|
+     s =~ TREPAN_PROMPT ? nil : s
+    end.compact unless show_prompt
+
+    # Remove debugger location lines. 
+    # For example: 
+    #   -- (/src/external-vcs/trepan/tmp/gcd.rb:4)
+    # becomes:
+    #   -- 
+    a2 = a.map do |s|
+      s =~ TREPAN_LOC ? s.gsub(/\(.+:\d+\)\n/, '').chomp : s.chomp
+    end
+
+    # Remove VM offset locations. 
+    # For example: 
+    #	VM offset 2 of instruction sequence "block in compare_output".
+    # becomes 
+    #   VM offset 55 of instruction sequence "block in compare_output".
+    a3 = a2.map do |s|
+      s.gsub(/VM offset \d+/, 'VM offset 55')
+    end
+    return a3
+  end
+
+end
+
+# Demo it
+if __FILE__ == $0
+  include FnTestHelper
+  strarray_setup(%w(eh bee see))
+  puts get_lineno()
+  p '-- (/src/external-vcs/trepan/tmp/gcd.rb:4)' =~ TREPAN_LOC
+  p '(trepan): exit' =~ TREPAN_PROMPT
+  output='
+-- (/src/external-vcs/trepan/tmp/gcd.rb:4)
+(trepan): s
+-- (/src/external-vcs/trepan/tmp/gcd.rb:18)
+(trepan): s
+-- (/src/external-vcs/trepan/tmp/gcd.rb:19)
+(trepan): s
+.. (/src/external-vcs/trepan/tmp/gcd.rb:0)
+(trepan): s
+-> (/src/external-vcs/trepan/tmp/gcd.rb:4)
+'.split(/\n/)
+  puts filter_line_cmd(output)
+  puts '-' * 10
+  puts filter_line_cmd(output, true)
+end

data/test/functional/test-break.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'trace'
+require_relative 'fn_helper'
+require_relative '../../app/breakpoint'
+
+class TestBreak < Test::Unit::TestCase
+
+  include FnTestHelper
+
+  def setup
+    Trepanning::Breakpoint::reset
+  end
+
+  def test_break_same_level
+
+    # See that we can stop at a breakpoint
+    cmds = ['set basename on',
+            'break ' + (__LINE__ + 7).to_s, 
+            'continue']
+    d = strarray_setup(cmds)
+    d.start
+    ########### b1 ###############
+    x = 5
+    y = 6
+    z = 7
+    ##############################
+    d.stop
+    out = ['-- ',
+           'x = 5',
+           'basename is on.',
+           "Breakpoint 1 set at line 26 in file test-break.rb,\n" + 
+           "\tVM offset 55 of instruction sequence \"test_break_same_level\".",
+           'xx ',
+           'z = 7']
+    compare_output(out, d, cmds)
+
+    # Try a disabling the breakpoint
+    cmds = ['set basename on',
+            'break ' + (__LINE__ + 8).to_s, 
+            'break ' + (__LINE__ + 8).to_s, 
+            'disable 1',
+            'continue']
+    d = strarray_setup(cmds)
+    d.start
+    ########### b2 ###############
+    x = 7
+    y = 8
+    z = 8+1
+    ##############################
+    d.stop
+    out = ['-- ',
+           'x = 7',
+           'basename is on.',
+           "Breakpoint 1 set at line 48 in file test-break.rb,\n" + 
+           "\tVM offset 55 of instruction sequence \"test_break_same_level\".",
+           "Breakpoint 2 set at line 49 in file test-break.rb,\n" + 
+           "\tVM offset 55 of instruction sequence \"test_break_same_level\".",
+           "Breakpoint 1 disabled.",
+           'xx ',
+           'z = 8+1']
+    compare_output(out, d, cmds)
+
+    # Stepping after a breakpoint should not stay at same location.
+    cmds = ['set basename on',
+            'continue ' + (__LINE__ + 8).to_s, 
+            'continue']
+    dbg = strarray_setup(cmds)
+    dbg.start
+    ########### b3 ###############
+    a = 1
+    b = 2
+    c = 3
+    d = 4
+    e = 5
+    ##############################
+    dbg.stop
+    out = ['-- ',
+           'a = 1',
+           'basename is on.',
+           'xx ',
+           'd = 4' ]
+    compare_output(out, dbg, cmds)
+  end
+    
+end
+