rb8-trepanning 0.1.3 → 0.1.4

data/processor/validate.rb

@@ -21,280 +21,282 @@ require_relative '../app/cmd_parse'
 require_relative 'virtual'
 require_relative 'msg'      # for errmsg, msg
 
-class Trepan::CmdProcessor < Trepan::VirtualCmdProcessor
+module Trepan
+  class CmdProcessor < VirtualCmdProcessor
   
-  attr_reader :file_exists_proc  # Like File.exists? but checks using
-                                 # cached files
+    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
+    ## 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
-  
+    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}.")
+    # 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
-      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
+      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
-    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
+    unless defined?(DEFAULT_GET_INT_OPTS)
+      DEFAULT_GET_INT_OPTS = {
+        :min_value => 0, :default => 1, :cmdname => nil, :max_value => 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]])
+    # 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
-      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])
+      
+      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 nil
+      return val
     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
+    
+    def get_int_list(args, opts={})
+      args.map{|arg| get_an_int(arg, opts)}.compact
     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
+    
+    # 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
-    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.")
+    
+    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
-        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
+    # 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
-  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
+    
+    # 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
-      if cm = method?(info.container)
-        ## Add bogus - canonic_file: active-path
-        return [cm, 'bogus', info.position, 
-                info.position_type]
+      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
-        return [nil] * 4
+        begin
+          meth_for_parse_struct(meth, start_binding)
+        rescue NameError
+          errmsg("Can't evaluate #{meth.name} to get a method")
+          return nil
+        end
       end
-    when :file
-      ## filename = canonic_file(info.container)
+    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
+        # 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 position type #{info.position_type} for location #{arg}"
-        return [nil]  * 4
+        errmsg "Unknown container type #{info.container_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
+    
+    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
-  
-  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

data/{processor/main.rb → processor.rb}

@@ -5,13 +5,11 @@
 require 'set'
 
 require 'rubygems'; require 'require_relative'
-## %w(default display eventbuf eval load_cmds location frame hook msg 
-##    validate).each do
-# %w(default breakpoint disassemble display eval eventbuf load_cmds location 
-#    frame hook msg running stepping validate).each do
-%w(default display eval eventbuf frame hook load_cmds location msg running validate).each do
+# Other debuggers have in addition: breakpoint disassemble stepping
+%w(default display eval eventbuf frame hook load_cmds location msg running 
+   validate).each do
   |mod_str|
-  require_relative mod_str
+  require_relative File.join('processor', mod_str);
 end
 ## require_relative '../app/brkptmgr'
 
@@ -43,6 +41,7 @@ module Trepan
     attr_accessor :event           # Stop event
     attr_reader   :intf            # Current interface
                                    # Trepan::Core instance)
+    attr_reader   :interfaces      # Array of all interfaces
     attr_accessor :leave_cmd_loop  # Commands set this to signal to leave
                                    # the command loop (which often continues to 
                                    # run the debugged program). 
@@ -65,34 +64,6 @@ module Trepan
                                   # [location, container, stack_size, 
                                   #  current_thread, pc_offset]
 
-    unless defined?(EVENT2ICON)
-      # Event icons used in printing locations.
-      EVENT2ICON = {
-        'brkpt'          => 'xx',
-        'tbrkpt'         => 'x1',
-        'c-call'         => 'C>',
-        'c-return'       => '<C',
-        'step-call'      => '->',
-        'call'           => '->',
-        'class'          => '::',
-        'coverage'       => '[]',
-        'debugger-call'  => ':o',
-        'end'            => '-|',
-        'line'           => '--',
-        'raise'          => '!!',
-        'return'         => '<-',
-        'start'          => '>>',
-        'switch'         => 'sw',
-        'trace-var'      => '$V',
-        'unknown'        => '?!',
-        'vm'             => 'VM',
-        'vm-insn'        => '..',
-      } 
-      # These events are important enough event that we always want to
-      # stop on them.
-      UNMASKABLE_EVENTS = Set.new(['end', 'raise', 'unknown'])
-    end
-
     ## def initialize(dbgr, settings={})
     def initialize(interfaces, settings={})
       @cmd_queue       = []
@@ -134,6 +105,8 @@ module Trepan
         self.send("#{submod}_initialize")
       end
       hook_initialize(commands)
+      unconditional_prehooks.insert_if_new(-1, *@trace_hook) if 
+        @settings[:traceprint]
     end
 
     def compute_prompt
@@ -202,11 +175,7 @@ module Trepan
               @cmd_queue.shift
             end
           if @current_command.empty? 
-            if @last_command && intf.interactive?
-              @current_command = @last_command 
-            else
-              next
-            end
+            next unless @last_command && intf.interactive?;
           end
           next if @current_command[0..0] == '#' # Skip comment lines
           break
@@ -242,6 +211,11 @@ module Trepan
       frame_setup(@context, @state)
 
       @unconditional_prehooks.run
+      if @settings[:traceprint]
+        step
+        return
+      end
+
       if breakpoint?
         delete_breakpoint(@brkpt) if @brkpt.temp?
         @last_pos = [@frame.vm_location, @stack_size, @current_thread, @event] 
@@ -262,7 +236,7 @@ module Trepan
       @prompt = compute_prompt
 
       @leave_cmd_loop = false
-      print_location unless @settings[:traceprint]
+      print_location
       # if 'trace-var' == @event 
       #   msg "Note: we are stopped *after* the above location."
       # end
@@ -283,6 +257,10 @@ module Trepan
       # @event = @core.event
 
       @unconditional_prehooks.run
+      if @settings[:traceprint]
+        step
+        return
+      end
       # if breakpoint?
       #   @last_pos = [@frame.source_container, frame_line,
       #                @stack_size, @current_thread, @event, 
@@ -294,7 +272,7 @@ module Trepan
       @prompt = compute_prompt
 
       @leave_cmd_loop = false
-      print_location unless @settings[:traceprint]
+      print_location
       # if 'trace-var' == @event 
       #   msg "Note: we are stopped *after* the above location."
       # end
@@ -413,7 +391,7 @@ end
 
 if __FILE__ == $0
   $0 = 'foo' # So we don't get here again
-  require_relative '../lib/trepanning'
+  require_relative 'lib/trepanning'
   puts "To be continued...."
   exit
   dbg =  Trepan.new(:nx => true)

data/test/data/trace.cmd

@@ -0,0 +1,6 @@
+# ***************************************************
+# This file is not used, but is here to make it 
+# easy for the helper function.
+# ***************************************************
+continue
+