trepanning 0.1.2 → 0.1.3

data/app/cmd_parse.kpeg

@@ -16,6 +16,19 @@
   # 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
+
+
    }
 #####################################################
 
@@ -185,10 +198,10 @@ position =
 
 location = 
    position 
- | <filename>:file &{ File.exist?(file) } file_pos_sep position:pos {
+ | <filename>:file &{ @file_exists_proc.call(file) } file_pos_sep position:pos {
       Position.new(:file, file, pos.position_type, pos.position)
     }
- | <filename>:file &{ File.exist?(file) } {
+ | <filename>:file &{ @file_exists_proc.call(file) } {
       Position.new(:file, file, nil, nil)
     }
  | class_module_chain?:fn file_pos_sep position:pos {
@@ -215,7 +228,10 @@ breakpoint_stmt = location:loc - if_unless:iu - condition:cond {
 # 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_target | location):loc - (integer:int)? {
+list_special_targets = <'.' | '-'> { text }
+list_stmt = (list_special_targets | location):loc - (integer:int)? {
   List.new(loc, int)
+}
+  | (list_special_targets | location):loc {
+  List.new(loc, nil)
 }

data/app/cmd_parse.rb

@@ -5,6 +5,7 @@ require_relative 'cmd_parser'
 class Trepan
   module CmdParser
 
+    module_function
     # 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
@@ -111,28 +112,28 @@ class Trepan
       end
     end
 
-    def parse_terminal(terminal_name, loc_str)
-      @cp ? @cp.setup_parser(loc_str) : @cp = CmdParse.new(loc_str)
+    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)
-      parse = parse_terminal(:_location, loc_str)
+    def parse_location(loc_str, opts={})
+      parse = parse_terminal(:_location, loc_str, opts)
       parse ? parse.result : nil
     end
 
-    def parse_breakpoint(str)
-      parse = parse_terminal(:_breakpoint_stmt, str)
+    def parse_breakpoint(str, opts={})
+      parse = parse_terminal(:_breakpoint_stmt, str, opts)
       parse ? parse.result : nil
     end
 
-    def parse_breakpoint_no_condition(str)
-      parse = parse_terminal(:_breakpoint_stmt_no_condition, str)
+    def parse_breakpoint_no_condition(str, opts={})
+      parse = parse_terminal(:_breakpoint_stmt_no_condition, str, opts)
       parse ? parse.result : nil
     end
 
-    def parse_list_cmd(str)
-      parse = parse_terminal(:_list_stmt, str)
+    def parse_list(str, opts={})
+      parse = parse_terminal(:_list_stmt, str, opts)
       parse ? parse.result : nil
     end
   end

data/app/cmd_parser.rb

@@ -274,6 +274,7 @@ class CmdParse
 
 ##################################################### 
   # Structure to hold composite method names
+unless defined? SymbolEntry
   SymbolEntry = Struct.new(:type, :name, :chain)
 
 
@@ -287,6 +288,21 @@ class CmdParse
   # 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)
+    }
+  }
+end
+
+  def initialize(str, opts={})
+    @opts = DEFAULT_OPTS.merge(opts)
+    setup_parser(str, opts[:debug])
+    @file_exists_proc = @opts[:file_exists_proc]
+  end
+
+
    
 
 
@@ -1436,7 +1452,7 @@ class CmdParse
     return _tmp
   end
 
-  # location = (position | < filename >:file &{ File.exist?(file) } file_pos_sep position:pos {       Position.new(:file, file, pos.position_type, pos.position)     } | < filename >:file &{ File.exist?(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)     })
+  # 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)     })
   def _location
         
     _save = self.pos
@@ -1458,7 +1474,7 @@ class CmdParse
                   break
                 end
                 _save2 = self.pos
-                _tmp = begin;  File.exist?(file) ; end
+                _tmp = begin;  @file_exists_proc.call(file) ; end
                 self.pos = _save2
                 unless _tmp
                   self.pos = _save1
@@ -1501,7 +1517,7 @@ class CmdParse
                   break
                 end
                 _save4 = self.pos
-                _tmp = begin;  File.exist?(file) ; end
+                _tmp = begin;  @file_exists_proc.call(file) ; end
                 self.pos = _save4
                 unless _tmp
                   self.pos = _save3
@@ -1737,7 +1753,7 @@ class CmdParse
     return _tmp
   end
 
-  # list_special_targets = < "." "-" > { text }
+  # list_special_targets = < ("." | "-") > { text }
   def _list_special_targets
         
     _save = self.pos
@@ -1745,18 +1761,15 @@ class CmdParse
               _text_start = self.pos
           
     _save1 = self.pos
-              while true # sequence
+              while true # choice
                 _tmp = match_string(".")
-                unless _tmp
-                  self.pos = _save1
-                  break
-                end
+                break if _tmp
+                self.pos = _save1
                 _tmp = match_string("-")
-                unless _tmp
-                  self.pos = _save1
-                end
+                break if _tmp
+                self.pos = _save1
                 break
-              end # end sequence
+              end # end choice
 
               if _tmp
                 text = get_text(_text_start)
@@ -1777,53 +1790,93 @@ class CmdParse
     return _tmp
   end
 
-  # list_stmt = (list_special_target | location):loc - integer:int? {   List.new(loc, int) }
+  # list_stmt = ((list_special_targets | location):loc - integer:int? {   List.new(loc, int) } | (list_special_targets | location):loc {   List.new(loc, nil) })
   def _list_stmt
         
     _save = self.pos
-            while true # sequence
+            while true # choice
           
     _save1 = self.pos
-              while true # choice
-                _tmp = apply(:_list_special_target)
-                break if _tmp
-                self.pos = _save1
-                _tmp = apply(:_location)
-                break if _tmp
-                self.pos = _save1
-                break
-              end # end choice
+              while true # sequence
+            
+    _save2 = self.pos
+                while true # choice
+                  _tmp = apply(:_list_special_targets)
+                  break if _tmp
+                  self.pos = _save2
+                  _tmp = apply(:_location)
+                  break if _tmp
+                  self.pos = _save2
+                  break
+                end # end choice
 
-              loc = @result
-              unless _tmp
-                self.pos = _save
-                break
-              end
-              _tmp = apply(:__hyphen_)
-              unless _tmp
-                self.pos = _save
-                break
-              end
-              _save2 = self.pos
-              _tmp = apply(:_integer)
-              int = @result
-              unless _tmp
+                loc = @result
+                unless _tmp
+                  self.pos = _save1
+                  break
+                end
+                _tmp = apply(:__hyphen_)
+                unless _tmp
+                  self.pos = _save1
+                  break
+                end
+                _save3 = self.pos
+                _tmp = apply(:_integer)
+                int = @result
+                unless _tmp
+                  _tmp = true
+                  self.pos = _save3
+                end
+                unless _tmp
+                  self.pos = _save1
+                  break
+                end
+                @result = begin;             
+  List.new(loc, int)
+; end
                 _tmp = true
-                self.pos = _save2
-              end
-              unless _tmp
-                self.pos = _save
+                unless _tmp
+                  self.pos = _save1
+                end
                 break
-              end
-              @result = begin;           
-  List.new(loc, int)
+              end # end sequence
+
+              break if _tmp
+              self.pos = _save
+          
+    _save4 = self.pos
+              while true # sequence
+            
+    _save5 = self.pos
+                while true # choice
+                  _tmp = apply(:_list_special_targets)
+                  break if _tmp
+                  self.pos = _save5
+                  _tmp = apply(:_location)
+                  break if _tmp
+                  self.pos = _save5
+                  break
+                end # end choice
+
+                loc = @result
+                unless _tmp
+                  self.pos = _save4
+                  break
+                end
+                @result = begin;             
+  List.new(loc, nil)
 ; end
-              _tmp = true
-              unless _tmp
-                self.pos = _save
-              end
+                _tmp = true
+                unless _tmp
+                  self.pos = _save4
+                end
+                break
+              end # end sequence
+
+              break if _tmp
+              self.pos = _save
               break
-            end # end sequence
+            end # end choice
 
     set_failed_rule :_list_stmt unless _tmp
     return _tmp
@@ -1862,18 +1915,18 @@ class CmdParse
   Rules[:_line_number] = rule_info("line_number", "integer")
   Rules[:_vm_offset] = rule_info("vm_offset", "\"@\" integer:int {     Position.new(nil, nil, :offset, int)   }")
   Rules[:_position] = rule_info("position", "(vm_offset | line_number:l {    Position.new(nil, nil, :line, l)  })")
-  Rules[:_location] = rule_info("location", "(position | < filename >:file &{ File.exist?(file) } file_pos_sep position:pos {       Position.new(:file, file, pos.position_type, pos.position)     } | < filename >:file &{ File.exist?(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)     })")
+  Rules[:_location] = rule_info("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)     })")
   Rules[:_if_unless] = rule_info("if_unless", "< (\"if\" | \"unless\") > { text }")
   Rules[:_condition] = rule_info("condition", "< /.+/ > { text}")
   Rules[:_breakpoint_stmt_no_condition] = rule_info("breakpoint_stmt_no_condition", "location:loc {   Breakpoint.new(loc, false, 'true') }")
   Rules[:_breakpoint_stmt] = rule_info("breakpoint_stmt", "(location:loc - if_unless:iu - condition:cond {      Breakpoint.new(loc, iu == 'unless', cond) } | breakpoint_stmt_no_condition)")
-  Rules[:_list_special_targets] = rule_info("list_special_targets", "< \".\" \"-\" > { text }")
-  Rules[:_list_stmt] = rule_info("list_stmt", "(list_special_target | location):loc - integer:int? {   List.new(loc, int) }")
+  Rules[:_list_special_targets] = rule_info("list_special_targets", "< (\".\" | \"-\") > { text }")
+  Rules[:_list_stmt] = rule_info("list_stmt", "((list_special_targets | location):loc - integer:int? {   List.new(loc, int) } | (list_special_targets | location):loc {   List.new(loc, nil) })")
 end
 if __FILE__ == $0
   # require 'rubygems'; require_relative '../lib/trepanning';
   
-  cp = CmdParse.new('', true)
+  cp = CmdParse.new('', :debug=>true)
   %w(A::B @@classvar abc01! @ivar @ivar.meth
     Object A::B::C A::B::C::D A::B.c A.b.c.d).each do |name|
     cp.setup_parser(name, true)
@@ -1909,6 +1962,17 @@ if __FILE__ == $0
     res = cp._filename
     p res
     puts cp.string
-    puts cp.result
+    p cp.result
+  end
+  ['.', '-', 'filename', '"this is a filename"',
+   'this\ is\ another\ filename',
+   'C\:filename', '5', '. 5', '5 10'
+   ].each do |name|
+    puts '-' * 10
+    cp.setup_parser(name, {:debug=>true})
+    res = cp._list_stmt
+    p res
+    puts cp.string
+    p cp.result
   end
 end

data/app/complete.rb

@@ -76,4 +76,5 @@ if __FILE__ == $0
   [0, 2, 5, 8, 9, 13, 19].each do |pos|
     p next_token(x, pos)
   end
+  p complete_token(global_variables.map{|g| g.to_s}, '$s')
 end

data/app/core.rb

@@ -169,8 +169,8 @@ class Trepan
     end
     
     # A trace-hook processor for 'trace var'
-    def trace_var_processor(val)
-      frame = RubyVM::ThreadFrame.current.prev
+    def trace_var_processor(var_name, value)
+      frame = RubyVM::ThreadFrame.current.prev(2)
       if 'CFUNC' == frame.type
         # Don't need the C call that got us here.
         prev = frame.prev
@@ -181,7 +181,7 @@ class Trepan
       Thread.current.tracing = true  
       
       @step_count = 0  # Make event processor stop
-      event_processor('trace-var', frame)
+      event_processor('trace-var', frame, [var_name, value])
     end
 
   end

data/app/disassemble.rb

@@ -10,12 +10,18 @@ class Trepan
     def mark_disassembly(disassembly_str, iseq_equal, pc_offset,
                          brkpt_offsets=[], max_width=80, highlight=nil)
 
+      dis_array = disassembly_str.split(/\n/)
       if highlight
-        require_relative '../app/yarv'
-        @highlighter ||= CodeRay::Duo[:yarv, :term]
+        begin
+          require_relative '../app/yarv'
+          @highlighter ||= CodeRay::Duo[:yarv, :term]
+        rescue LoadError
+          dis_array.
+            unshift('** Highlighting requested but CodeRay is not installed.')
+          highlight = false
+        end
       end
 
-      dis_array = disassembly_str.split(/\n/)
       dis_array.map do |line|
         if line =~ /^(.*?)(\s+)(\(\s+\d+\))?$/
           line_begin   = $1
@@ -91,4 +97,8 @@ local table (size: 6, argc: 1 [opts: 0, rest: -1, post: 0, block: -1] s1)
   puts '=' * 40
   require 'pp'
   PP.pp(disassemble_split(dis_string), $stdout)
+  str = mark_disassembly(dis_string, false, 2, [], 70, true).join("\n")
+  puts str
+  puts '=' * 40
+  PP.pp(disassemble_split(dis_string), $stdout)
 end

data/app/file.rb

@@ -72,7 +72,7 @@ module Trepanning
 
   def find_scripts(filename)
     filename_pat = file_match_pat(filename)
-    return SCRIPT_ISEQS__.keys.grep(/#{filename_pat}/)
+    return SCRIPT_LINES__.keys.grep(/#{filename_pat}/)
   end
 
 end
@@ -82,6 +82,7 @@ if __FILE__ == $0
   if !(ARGV.size == 1 && ARGV[0] == 'noload')
     ISEQS__        = {}
     SCRIPT_ISEQS__ = {}
+    SCRIPT_LINES__ = {}
     ARGV[0..-1]    = ['noload']
     load(__FILE__)
   else    

data/app/frame.rb

@@ -158,7 +158,9 @@ class Trepan
 
     def offset_for_return(event)
       raise RuntimeError unless %w(return c-return).member?(event)
-      'return' == event ? 1 : 2
+      # FIXME: C calls have a RubyVM::Env added to the stack.
+      # Where? Why?
+      'return' == event ? 1 : 4
     end
     module_function :offset_for_return
 

data/app/mock.rb

@@ -1,11 +1,14 @@
 # Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
 class Trepan
   attr_accessor :trace_filter # Procs/Methods we ignore.
+  attr_accessor :intf
   def initialize(opts={})
     @trace_filter = []
+    @intf = []
   end
   class MockDebugger
     attr_reader :initial_dir
+    attr_accessor :intf
     def initialize(settings={})
       @initial_dir = '.'
     end