rb8-trepanning 0.1.3-universal-ruby-1.9.2

data/processor/running.rb

@@ -0,0 +1,168 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'
+require 'require_relative'
+require_relative 'virtual'
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+
+  attr_accessor :stop_condition  # String or nil. When not nil
+                                 # this has to eval non-nil
+                                 # in order to stop.
+  attr_accessor :stop_events     # Set or nil. If not nil, only
+                                 # events in this set will be
+                                 # considered for stopping. This is
+                                 # like core.step_events (which
+                                 # could be used instead), but it is
+                                 # a set of event names rather than
+                                 # a bitmask and it is intended to
+                                 # be more temporarily changed via
+                                 # "step>" or "step!" commands.
+  attr_accessor :to_method
+  
+  # Does whatever needs to be done to set to continue program
+  # execution.
+  def continue
+    @state.proceed
+  end
+  
+  # # Does whatever setup needs to be done to set to ignore stepping
+  # # to the finish of the current method.
+  # def finish(level_count=0, opts={})
+  #   step(0, opts)
+  #   @next_level        = @frame.stack_size - level_count
+  #   @next_thread       = Thread.current
+  #   @stop_events       = Set.new(%w(return leave yield))
+  
+  #   # Try high-speed (run-time-assisted) method
+  #   @frame.trace_off   = true  # No more tracing in this frame
+  #   @frame.return_stop = true  # don't need to 
+  # end
+  
+  # # Does whatever needs to be done to set to do "step over" or ignore
+  # # stepping into methods called from this stack but step into any in 
+  # # the same level. We do this by keeping track of the number of
+  # # stack frames and the current thread. Elsewhere in "skipping_step?"
+  # # we do the checking.
+  # def next(step_count=1, opts={})
+  #   step(step_count, opts)
+  #   @next_level      = @top_frame.stack_size
+  #   @next_thread     = Thread.current
+  # end
+  
+  # # Does whatever needs to be done to set to step program
+  # # execution.
+  # def step(step_count=1, opts={}, condition=nil)
+  #   continue
+  #   @core.step_count = step_count
+  #   @different_pos   = opts[:different_pos] if 
+  #     opts.keys.member?(:different_pos)
+  #   @stop_condition  = condition
+  #   @stop_events     = opts[:stop_events]   if 
+  #     opts.keys.member?(:stop_events)
+  #   @to_method       = opts[:to_method]
+  # end
+  
+  def quit(cmd='quit')
+    @next_level      = 32000 # I'm guessing the stack size can't
+                             # ever reach this
+    @next_thread     = nil
+    @context.stop_next = 0   # No more event stepping
+    @leave_cmd_loop  = true  # Break out of the processor command loop.
+    @settings[:autoirb] = false
+    ## @cmdloop_prehooks.delete_by_name('autoirb')
+    @commands['exit'].run([cmd])
+  end
+  
+  def parse_next_step_suffix(step_cmd)
+    opts = {}
+    case step_cmd[-1..-1]
+    when '-'
+      opts[:different_pos] = false
+    when '+'
+      opts[:different_pos] = 'nostack'
+    when '='
+      opts[:different_pos] = true
+    when '!'
+      opts[:stop_events] = Set.new(%w(raise))
+    when '<'
+      opts[:stop_events] = Set.new(%w(c-return return))
+    when '>'
+      opts[:stop_events] = Set.new(%w(c-call call))
+      if step_cmd.size > 1 && step_cmd[-2..-2] == '<'
+        opts[:stop_events] = Set.new(%w(c-call c-return call return))
+      else
+        opts[:stop_events] = Set.new(%w(c-call call))
+      end
+    end
+    return opts
+  end
+  
+  def running_initialize
+    @stop_condition  = nil
+    @stop_events     = nil
+    @to_method       = nil
+  end
+  
+  # def stepping_skip?
+  
+  #   return true if @core.step_count < 0
+  
+  #   if @settings[:'debugskip']
+  #     msg "diff: #{@different_pos}, event : #{@event}, #{@stop_events.inspect}" 
+  #     msg "step_count  : #{@core.step_count}" 
+  #     msg "next_level  : #{@next_level},    ssize : #{@stack_size}" 
+  #     msg "next_thread : #{@next_thread},   thread: #{Thread.current}" 
+  #   end
+  
+  #   return true if 
+  #     !frame || (@next_level < @frame.stack_size &&
+  #                Thread.current == @next_thread)
+  
+  #   new_pos = [@frame.source_container, frame_line,
+  #              @stack_size, @current_thread, @event, @frame.pc_offset]
+  
+  #   skip_val = @stop_events && !@stop_events.member?(@event)
+  
+  #   # If the last stop was a breakpoint, don't stop again if we are at
+  #   # the same location with a line event.
+  #   skip_val ||= (@last_pos[4] == 'brkpt' && 
+  #                 @event == 'line' &&
+  #                 @frame.pc_offset == @last_pos[5])
+  
+  #   if @settings[:'debugskip']
+  #     puts "skip: #{skip_val.inspect}, last: #{@last_pos}, new: #{new_pos}" 
+  #   end
+  
+  #   @last_pos[2] = new_pos[2] if 'nostack' == @different_pos
+  #   unless skip_val
+  #     condition_met = 
+  #       if @stop_condition
+  #         puts 'stop_cond' if @settings[:'debugskip']
+  #         debug_eval_no_errmsg(@stop_condition)
+  #       elsif @to_method
+  #         puts "method #{@frame.method} #{@to_method}" if 
+  #           @settings[:'debugskip']
+  #         @frame.method == @to_method
+  #       else
+  #         puts 'uncond' if @settings[:'debugskip']
+  #         true
+  #       end
+  
+  #     msg("condition_met: #{condition_met}, last: #{@last_pos}, " +
+  #          "new: #{new_pos}, different #{@different_pos.inspect}") if 
+  #       @settings[:'debugskip']
+  #     skip_val = ((@last_pos[0..3] == new_pos[0..3] && @different_pos) ||
+  #                 !condition_met)
+  #   end
+  
+  #   @last_pos = new_pos if !@stop_events || @stop_events.member?(@event)
+  
+  #   unless skip_val
+  #     # Set up the default values for the
+  #     # next time we consider skipping.
+  #     @different_pos = @settings[:different]
+  #     @stop_events   = nil
+  #   end
+  
+  #   return skip_val
+  # end
+end

data/processor/stepping.rb

@@ -0,0 +1,18 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'virtual'
+module Trepan
+  class CmdProcessor  < VirtualCmdProcessor
+    def parse_stepping_args(command_name, match)
+      if match[1].nil? 
+          different = @settings[:force_stepping]
+      elsif match[1] == '+' 
+        different = true
+      elsif match[1] == '-' 
+        different = false
+      end
+      steps = get_int(match[2], command_name, 1)
+      return [steps, different]
+    end
+  end
+end

data/processor/subcmd.rb

@@ -0,0 +1,161 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# gdb-like subcommand processing.
+
+module Trepan
+  class Subcmd
+
+    attr_reader :subcmds  # Hash of subcommands. Key is the subcommand name.
+                          # the value is the subcommand object to run.
+    def initialize(cmd)
+      @cmd     = cmd
+      @subcmds = {}
+      @cmdlist = []
+    end
+    
+    # Find subcmd in self.subcmds
+    def lookup(subcmd_prefix, use_regexp=true)
+      compare = if use_regexp 
+                  lambda{|name| name.to_s =~ /^#{subcmd_prefix}/}
+                else
+                  lambda{|name| 0 == name.to_s.index(subcmd_prefix)}
+                end
+      @subcmds.each do |subcmd_name, subcmd|
+        if compare.call(subcmd_name) &&
+            subcmd_prefix.size >= subcmd.class.const_get(:MIN_ABBREV)
+          return subcmd
+        end
+      end
+      return nil
+    end
+
+    # Show short help for a subcommand.
+    def short_help(subcmd_cb, subcmd_name, label=false)
+      entry = self.lookup(subcmd_name)
+      if entry
+        if label
+          prefix = entry.name
+        else
+          prefix = ''
+        end
+        if entry.respond_to?(:short_help)
+          prefix += ' -- ' if prefix 
+          @proc.msg(prefix + entry.short_help)
+        end
+      else
+        @proc.undefined_subcmd("help", subcmd_name)
+      end
+    end
+
+    # Add subcmd to the available subcommands for this object.
+    # It will have the supplied docstring, and subcmd_cb will be called
+    # when we want to run the command. min_len is the minimum length
+    # allowed to abbreviate the command. in_list indicates with the
+    # show command will be run when giving a list of all sub commands
+    # of this object. Some commands have long output like "show commands"
+    # so we might not want to show that.
+    def add(subcmd_cb, subcmd_name=nil)
+      subcmd_name ||= subcmd_cb.name
+      @subcmds[subcmd_name.to_s] = subcmd_cb
+
+      # We keep a list of subcommands to assist command completion
+      @cmdlist << subcmd_name
+    end
+
+    # Run subcmd_name with args using obj for the environent
+    def run( subcmd_name, arg)
+      entry=lookup(subcmd_name)
+      if entry
+        entry['callback'].send(arg)
+      else
+        @proc.undefined_cmd(entry.__class__.name, subcmd_name)
+      end
+    end
+
+    # help for subcommands
+    # Note: format of help is compatible with ddd.
+    def help(*args)
+
+      msg args
+      subcmd_prefix = args[0]
+      if not subcmd_prefix or subcmd_prefix.size == 0
+        @proc.msg(self.doc)
+        @proc.msg("\nList of %s subcommands:\n" % [@name])
+        @list.each do |subcmd_name|
+          subcmd_helper(subcmd_name, obj, true, true)
+        end
+
+        entry = lookup(subcmd_prefix)
+        if entry and entry.respond_to? :help
+          entry.help(args)
+        else
+          @proc.errmsg("Unknown 'help %s' subcommand %s" %
+                       [@name, subcmd_prefix])
+        end
+      end
+    end
+
+    def list
+      @subcmds.keys.sort
+    end
+    
+    # Error message when a subcommand doesn't exist.
+    def undefined_subcmd(cmd, subcmd)
+      @proc.errmsg('Undefined "%s" command: "%s". Try "help".' % 
+                   [cmd, subcmd])
+    end
+  end
+end
+
+# When invoked as main program, invoke the debugger on a script
+if __FILE__ == $0
+
+  require 'rubygems'; require 'require_relative'
+  require_relative 'mock'
+  require_relative 'command/base/cmd'
+
+  class Trepan::TestCommand < Trepan::Command
+    
+    HELP = 'Help string string for testing'
+    CATEGORY = 'data'
+    MIN_ARGS = 0
+    MAX_ARGS = 5
+    NAME_ALIASES = %w(test)
+    
+    def initialize(proc); @proc  = proc end
+    
+    def run(args); puts 'test command run' end
+  end
+  
+  class TestTestingSubcommand
+    HELP = 'Help string for test testing subcommand'
+    
+    def initialize; @name  = 'testing' end
+    
+    SHORT_HELP = 'This is short help for test testing'
+    MIN_ABREV = 4
+    IN_LIST   = true
+    def run(args); puts 'test testing run' end
+  end
+
+  d = MockDebugger::MockDebugger.new
+  testcmd    = Trepan::TestCommand.new(nil)
+  # testcmd.debugger = d
+  # testcmd.proc     = d.core.processor
+  # testcmdMgr = Subcmd.new('test', testcmd)
+  # testsub = TestTestingSubcommand.new
+  # testcmdMgr.add(testsub)
+  
+  # %w(tes test testing testing1).each do |prefix|
+  #   x = testcmdMgr.lookup(prefix)
+  #   puts x ? x.name : 'Non'
+  # end
+  
+  # testcmdMgr.short_help(testcmd, 'testing')
+  # testcmdMgr.short_help(testcmd, 'test', true)
+  # testcmdMgr.short_help(testcmd, 'tes')
+  # puts testcmdMgr.list()
+  # testsub2 = TestTestingSubcommand.new
+  # testsub2.name = 'foobar'
+  # testcmdMgr.add(testsub2)
+  # puts testcmdMgr.list()
+end

data/processor/validate.rb

@@ -0,0 +1,355 @@
+# 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.
+
+require 'rubygems'
+require 'require_relative'
+begin
+  require 'linecache'
+rescue LoadError
+  require 'linecache19'
+end
+
+require_relative '../app/cmd_parse'
+# require_relative '../app/condition'
+# require_relative '../app/file'
+# require_relative '../app/method'
+# require_relative '../app/validate'
+
+## require_relative 'location' # for resolve_file_with_dir
+require_relative 'virtual'
+require_relative 'msg'      # for errmsg, msg
+
+class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+  
+  attr_reader :file_exists_proc  # Like File.exists? but checks using
+                                 # cached files
+
+  ## include Trepanning::Method
+  ## include Trepanning::FileName
+  ## include Trepan::Validate
+  ## include Trepan::ThreadHelper
+  ## include Trepan::Condition
+
+  def confirm(msg, default)
+    @settings[:confirm] ? @intf.confirm(msg, default) : true
+  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 opts[:cmdname]
+        errmsg(("Command '%s' expects an integer at least" +
+                ' %d; got: %d.') %
+               [opts[: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
+  
+  # Parse a breakpoint position. On success return:
+  #   - the Method the position is in
+  #   - the file name - a Fixnum
+  #   - the line number - 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, line, position_type = 
+      parse_position(break_cmd_parse.position)
+    if cm or file or line
+      return [cm, file, line, position_type] + tail
+    end
+    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.
+  # 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
+  
+  include Trepan::CmdParser
+  
+  def get_method(meth)
+    start_binding = 
+      begin
+        @frame.binding
+      rescue
+        binding
+      end
+    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)->(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(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 cm = method?(info.container)
+        ## Add bogus - canonic_file: active-path
+        return [cm, 'bogus', info.position, 
+                info.position_type]
+      else
+        return [nil] * 4
+      end
+    when :file
+      ## filename = canonic_file(info.container)
+        filename = 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 nil, 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 [nil, nil, 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
+  end
+  
+  def parse_method(meth_str)
+    begin 
+      meth_for_string(meth_str, @frame.binding)
+    rescue NameError
+      nil
+    rescue
+      nil
+    end
+  end
+  
+  def validate_initialize
+    ## top_srcdir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    ## @dbgr_script_iseqs, @dbgr_iseqs = filter_scripts(top_srcdir)
+    @file_exists_proc = Proc.new {|filename|
+      if LineCache.cached?(filename) || LineCache.cached_script?(filename) ||
+          (File.readable?(filename) && !File.directory?(filename))
+        true
+        ## else
+        ##  find_load_path(filename)
+      end
+    }
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  # 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)
+  cmdproc  = cmd.proc
+  onoff = %w(1 0 on off)
+  onoff.each { |val| puts "onoff(#{val}) = #{cmdproc.get_onoff(val)}" }
+  cmdproc.frame.instance_variable_set('@binding', binding)
+  %w(1 1E bad 1+1 -5).each do |val| 
+    puts "get_int_noerr(#{val}) = #{cmdproc.get_int_noerr(val).inspect}" 
+  end
+  def foo; 5 end
+  def cmdproc.errmsg(msg)
+    puts msg
+  end
+
+  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("#{__FILE__} #{__LINE__}").inspect
+  # require 'ruby-debug'; Debugger.start; debugger
+  p cmdproc.breakpoint_position('../app/display.rb:24', false)
+
+  puts "To be continued...."
+  exit
+  
+  cmdproc.method?('cmdproc.errmsg')
+  puts '=' * 40
+  ['Array.map', 'Trepan::CmdProcessor.new',
+   'foo', 'cmdproc.errmsg'].each do |str|
+    puts "#{str} should be true: #{cmdproc.method?(str).inspect}"
+  end
+  puts '=' * 40
+  
+  # FIXME:
+  # Array#foo should be false: true
+  # Trepan::CmdProcessor.allocate should be false: true
+  
+  ['food', '.errmsg'].each do |str|
+    puts "#{str} should be false: #{cmdproc.method?(str).inspect}"
+  end
+  puts '-' * 20
+
+  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("#{__LINE__}", true)
+  p cmdproc.breakpoint_position("#{__FILE__}:#{__LINE__}", true)
+  p cmdproc.breakpoint_position("#{__FILE__} #{__LINE__} if 1 == a", true)
+  puts cmdproc.breakpoint_position("cmdproc.errmsg", 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