trepanning 0.1.0 → 0.1.1

data/Makefile

@@ -0,0 +1,13 @@
+# I'll admit it -- I'm an absent-minded old-timer who has trouble
+# learning new tricks.
+.PHONY: all test
+
+all: test
+
+check: 
+	rake test
+test: 
+	rake test
+
+%: 
+	rake $@

data/NEWS

@@ -1,3 +1,33 @@
+March 15, 2011  (0.0.6)
+- Revise breakpoint location parsing
+  * Add: break <location> if/unless <condition>
+  * Add: step until <condition>
+  * VM offsets are now specified via @ rather than o or O
+  * Filenames can be quoted and blanks and characters inside escaped
+- Document command syntax by adding it as a new category with sub help
+- More controlled parsing of method names 
+- Add eval (no args) and eval? to run current source line or source line
+  eval? strips:
+   * leading "if", "elsif", "while", "until" "return" or "case", or "unless"
+   * trailing "then", "do"
+- Save and restore some debugger state across a restart
+- Redo command completion
+
+Feb 15, 2011  (0.0.5)
+- "disassemble" command: allow disassembly of specified line numbers
+- GNU Readline: 
+  * Start GNU readline tab (command) completion. 
+  * Save and restore command history
+  * add --readline and --no-readline options to trepanx
+- Macros can return more than one command now
+- help 
+  * "help macros" shows all macro names
+  * "help aliases" shows all alias names
+  * "help *" lists macros and aliases now
+- start "info line"
+- "info file" has/shows File::stat()'s mtime and ctime 
+- be able to pass --verbose to ruby to rake
+
 Feb 1, 2011 (0.1.0)
 * Add Remote debugging interface. Add options --server --port
 * Add Syntax highlighting on Ruby and YARV listings and locations

data/Rakefile

@@ -3,10 +3,11 @@
 require 'rubygems'
 
 ROOT_DIR = File.dirname(__FILE__)
+Gemspec_filename='trepanning.gemspec'
 require File.join %W(#{ROOT_DIR} app options)
 
 def gemspec
-  @gemspec ||= eval(File.read('.gemspec'), binding, '.gemspec')
+  @gemspec ||= eval(File.read(Gemspec_filename), binding, Gemspec_filename)
 end
 
 require 'rake/gempackagetask'
@@ -14,16 +15,16 @@ desc "Build the gem"
 task :package=>:gem
 task :gem=>:gemspec do
   Dir.chdir(ROOT_DIR) do
-    sh "gem build .gemspec"
+    sh "gem build #{Gemspec_filename}"
     FileUtils.mkdir_p 'pkg'
-    FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+    FileUtils.mv gemspec.file_name, 'pkg'
   end
 end
 
 desc "Install the gem locally"
 task :install => :gem do
   Dir.chdir(ROOT_DIR) do
-    sh %{gem install --local pkg/#{gemspec.name}-#{gemspec.version}}
+    sh %{gem install --local pkg/#{gemspec.file_name}}
   end
 end
 
@@ -47,14 +48,16 @@ def run_standalone_ruby_files(list)
   puts '*' * 40
   list.each do |ruby_file|
     system(RUBY_PATH, ruby_file)
+    p $?.exitstatus
+    break if $?.exitstatus != 0 && !opts[:continue]
   end
 end
 
 def run_standalone_ruby_file(directory, opts={})
-  puts ('*' * 10) + ' ' + directory + ' ' + ('*' * 10)
+  puts(('*' * 10) + ' ' + directory + ' ' + ('*' * 10))
   Dir.chdir(directory) do
     Dir.glob('*.rb').each do |ruby_file|
-      puts ('-' * 20) + ' ' + ruby_file + ' ' + ('-' * 20)
+      puts(('-' * 20) + ' ' + ruby_file + ' ' + ('-' * 20))
       system(RUBY_PATH, ruby_file)
       break if $?.exitstatus != 0 && !opts[:continue]
     end
@@ -70,19 +73,19 @@ desc 'Test units - the smaller tests'
 Rake::TestTask.new(:'test:unit') do |t|
   t.test_files = FileList['test/unit/**/test-*.rb']
   # t.pattern = 'test/**/*test-*.rb' # instead of above
-  t.verbose = true
+  t.options = '--verbose' if $VERBOSE
 end
 
 desc 'Test functional - the medium-sized tests'
 Rake::TestTask.new(:'test:functional') do |t|
   t.test_files = FileList['test/functional/**/test-*.rb']
-  t.verbose = true
+  t.options = '--verbose' if $VERBOSE
 end
 
 desc 'Test integration - end-to-end blackbox tests'
 Rake::TestTask.new(:'test:integration') do |t|
   t.test_files = FileList['test/integration/**/test-*.rb']
-  t.verbose = true
+  t.options = '--verbose' if $VERBOSE
 end
 
 desc 'Test everything - unit tests for now.'
@@ -100,7 +103,7 @@ task :test do
   raise "Test failures" unless exceptions.empty?
 end
 
-desc "Run each library Ruby file in standalone mode."
+desc "Run each Ruby app file in standalone mode."
 task :'check:app' do
   run_standalone_ruby_file(File.join(%W(#{ROOT_DIR} app)))
 end
@@ -110,6 +113,14 @@ task :'check:commands' do
   run_standalone_ruby_file(File.join(%W(#{ROOT_DIR} processor command)))
 end
 
+desc "Run each of the sub-sub commands in standalone mode."
+task :'check:sub:commands' do
+  p "#{ROOT_DIR}/processor/command/*_subcmd/*_subcmd/*.rb"
+  Dir.glob("#{ROOT_DIR}/processor/command/*_subcmd").each do |sub_dir|
+    run_standalone_ruby_file(sub_dir)
+  end
+end
+
 desc "Run each of the sub-sub commands in standalone mode."
 task :'check:subsub:commands' do
   subsub_files = FileList["#{ROOT_DIR}/processor/command/*_subcmd/*_subcmd/*.rb"]
@@ -131,10 +142,28 @@ task :'check:unit' do
   run_standalone_ruby_file(File.join(%W(#{ROOT_DIR} test unit)))
 end
 
+desc "Run functional tests in standalone mode."
 task :'check:functional' do
   run_standalone_ruby_file(File.join(%W(#{ROOT_DIR} test functional)))
 end
 
+desc "Run command parser grammar."
+task :'check:cmd_parse' do
+  sh "kpeg --test --debug #{File.join(ROOT_DIR, %w(app cmd_parse.kpeg))}"
+end
+
+desc "Generate command parser."
+task :'cmd_parse' do
+  require 'tmpdir'
+  temp_file = 
+    File.join(Dir.tmpdir, 
+              Dir::Tmpname.make_tmpname(['cmd_parser_', '.rb'], nil))
+
+  sh("kpeg --name CmdParse --verbose --stand-alone  " + 
+     "#{File.join(ROOT_DIR, %w(app cmd_parse.kpeg))} " + 
+     "--output #{temp_file}")
+end
+
 task :'check:integration' do
   run_standalone_ruby_file(File.join(%W(#{ROOT_DIR} test integration)))
 end
@@ -161,14 +190,15 @@ Rake::RDocTask.new("rdoc") do |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title    = "Trepanning #{Trepan::VERSION} Documentation"
 
-  rdoc.rdoc_files.include('lib/*.rb', 'app/*.rb', 'bin/trepan')
+  rdoc.rdoc_files.include(%w(lib/*.rb 
+                          app/*.rb intf/*.rb io/*.rb
+                          bin/trepan
+                         ))
 end
+
 desc "Same as rdoc"
 task :doc => :rdoc
 
-desc "Remove built files"
-task :clean => [:clobber_package, :clobber_rdoc]
-
 task :clobber_package do
   FileUtils.rm_rf File.join(ROOT_DIR, 'pkg')
 end
@@ -177,3 +207,9 @@ task :clobber_rdoc do
   FileUtils.rm_rf File.join(ROOT_DIR, 'doc')
 end
 
+task :rm_patch_residue do
+  FileUtils.rm_rf FileList['**/*.{rej,orig}'].to_a
+end
+
+desc "Remove built files"
+task :clean => [:clobber_package, :clobber_rdoc, :rm_patch_residue]

data/app/.gitignore

@@ -0,0 +1 @@
+/*~

data/app/breakpoint.rb

@@ -19,6 +19,9 @@ class Trepan
     attr_reader   :offset    # Fixnum. Offset into an instruction
                              # sequence for the location of the
                              # breakpoint
+    attr_reader   :negate    # Boolean. Negate sense of condition. Used in 
+                             # break if .. and break unless ..
+                             # breakpoint
     attr_reader   :type      # String. 'line' if breakpoint requested
                              # at "line" boundary or 'offset'
                              # requested at a specific offset
@@ -29,6 +32,7 @@ class Trepan
       :enabled   => 'true',
       :ignore    =>  0,
       :temp      =>  false,
+      :negate    =>  false,
       :type      => 'line',
     } unless defined?(BRKPT_DEFAULT_SETTINGS)
     
@@ -59,11 +63,12 @@ class Trepan
         @id = @@next_id 
         @@next_id += 1
       end
-      set
+      raise RuntimeError,
+      "Unable to set breakpoint in #{iseq.name} at offset #{offset}" unless set
     end
 
     def condition?(bind)
-      if eval(@condition, bind)
+      if @negate != eval(@condition, bind)
         if @ignore > 0
           @ignore -= 1
           return false

data/app/brkptmgr.rb

@@ -8,11 +8,23 @@ class Trepan
     attr_reader :set
 
     def initialize
+      clear
+    end
+
+    def clear
       @list = []
       @next_id = 1
       @set = Set.new
     end
 
+    # Remove all breakpoints that we have recorded
+    def finalize
+      @list.each do |bp|
+        bp.remove!
+      end
+      clear
+    end
+
     def <<(brkpt)
       @list << brkpt
       @set.add(set_key(brkpt))

data/app/cmd_parse.citrus

@@ -0,0 +1,167 @@
+# -*- Ruby -*-
+grammar MethodName
+  rule upcase_letter
+    [A-Z]
+  end 
+  rule downcase_letter
+    [a-z]
+  end
+  rule suffix_letter
+    [=!?]
+  end    
+  rule letter
+    upcase_letter | downcase_letter
+  end
+  rule id_symbol
+    letter | '_' | [0-9]
+  end
+
+  # Examples: 
+  # var1
+  # my_var? 
+  rule variable_identifier
+    ((downcase_letter | '_') id_symbol* suffix_letter?)
+    { 
+      SymbolEntry = Struct.new(:type, :name, :chain)
+      def value
+         SymbolEntry.new(:variable, self.to_s)
+      end   
+    }
+  end 
+
+  # Examples: 
+  # MY_CONSTANT
+  # MyConstant_01
+  rule constant_identifier
+    (upcase_letter id_symbol*)
+    { 
+      def value
+         SymbolEntry.new(:constant, self.to_s)
+      end   
+    }
+  end 
+
+  # Examples:
+  # $global_variable
+  # We won't try for funny global names like $$, $? $:, $', etc
+  rule global_identifier
+    ('$' (constant_identifier | variable_identifier))
+    {
+      def value
+         SymbolEntry.new(:global, self.to_s)
+      end   
+    }     
+  end 
+
+  # Examples: 
+  #   Foo
+  #   foo
+  rule local_identifier
+    (constant_identifier | variable_identifier)
+    {
+      def value
+         SymbolEntry.new(:instance, self.to_s)
+      end   
+    }     
+  end 
+
+  # Example: @foo
+  rule instance_identifier
+    ('@' local_identifier )
+    {
+      def value
+         SymbolEntry.new(:instance, self.to_s)
+      end   
+    }     
+  end 
+
+
+  # Example: @@foo
+  rule classvar_identifier
+    ('@@' local_identifier )
+    {
+      def value
+         SymbolEntry.new(:classvar, self.to_s)
+      end   
+    }     
+  end 
+  rule identifier
+    global_identifier | instance_identifier | classvar_identifier |
+    local_identifier 
+  end 
+
+  # I think strict Ruby rules are that once one goes from :: to .
+  # There is no going back. That is, A.B::C is invalid. 
+  # 
+  # Also I think method names can't be constants. But such 
+  # subtleties we'll handle in semantic analysis.
+  rule class_module_chain
+    ( ( parent:(local_identifier) symbol:('::'|'.')
+        child:(class_module_chain) )
+     | (parent:(local_identifier) ) )
+    {
+      def value
+        let = self.to_s[0..0]
+        type = (let.capitalize == let) ? :constant : :variable
+        SymbolEntry.new(type, self.to_s, [parent, child, symbol.to_s])
+      end   
+    }
+  end
+
+  ##############################################################
+  # Location-specific things. This is used in conjunction with
+  # method-like things above.
+  rule sp
+    [ \t]+
+  end 
+
+  rule file_pos_sep
+    sp | ':'
+  end 
+
+
+  rule integer
+    [0-9]+ { to_i }
+  end 
+
+  rule vm_offset 
+    ('@' integer) 
+  {
+   Position = Struct.new(:type, :value) unless defined?(Position)
+   Position.new(:offset, integer.value)
+  }
+  end
+
+  rule line_number 
+    ([0-9]+)
+  {
+    Position = Struct.new(:type, :value) unless defined?(Position)
+    Position.new(:line, to_i)
+  }
+  end  
+
+  # Examples:
+  #  @43
+  #  5
+  rule position
+    (vm_offset | line_number)
+  end  
+
+  rule location
+   (class_module_chain? file_pos_sep position
+     | position | meth2:(class_module_chain))
+   {
+    Location = Struct.new(:method_name, :position) unless defined?(Location)
+    pos_val = position ? position.value : nil
+    meth_val = 
+        if class_module_chain
+          class_module_chain.value
+        else        
+          # p ['++++2', meth2, meth2.class]
+          meth2 ? meth2.value : nil
+        end
+    Location.new(meth_val, pos_val)
+   }
+  end
+
+end

data/app/cmd_parse.kpeg

@@ -0,0 +1,221 @@
+# -*- Ruby -*-
+
+%% {
+##################################################### 
+  # Structure to hold composite method names
+  SymbolEntry = Struct.new(:type, :name, :chain)
+
+
+  # Structure to hold position information
+  Position = Struct.new(:container_type, :container,
+                       :position_type,  :position)
+
+  # Structure to hold breakpoint information
+  Breakpoint = Struct.new(:position, :negate, :condition)
+
+  # Structure to hold list information
+  List = Struct.new(:position, :num)
+
+   }
+#####################################################
+
+      upcase_letter = /[A-Z]/
+    downcase_letter = /[a-z]/
+      suffix_letter = /[=!?]/ 
+             letter = upcase_letter
+                    | downcase_letter
+          id_symbol = letter | "_" | [0-9]
+
+
+# An variable or a method identifier
+# Examples: 
+#   var1
+#   my_var? 
+# But not: Variable or @var
+vm_identifier = < (downcase_letter | "_") id_symbol* suffix_letter? >
+    { 
+      SymbolEntry.new(:variable, text)
+    }
+
+# Examples: 
+#   var1
+# But not: my_var?, my_var! 
+variable_identifier = < (downcase_letter | "_") id_symbol* >
+    { 
+      SymbolEntry.new(:variable, text)
+    }
+
+# Examples: 
+#   MY_CONSTANT
+#   MyConstant_01
+# But not:
+#   MyConstant_01?
+constant_identifier = < upcase_letter id_symbol* >
+    { 
+      SymbolEntry.new(:constant, text)
+    }
+
+# Examples:
+#   $global_variable
+# We won't try for funny global names like $$, $? $:, $', etc
+global_identifier = < "$" (constant_identifier | variable_identifier) >
+    {
+      SymbolEntry.new(:global, text)
+    }
+
+# Examples: 
+#   Foo
+#   foo
+# But not:
+#   foo!, @foo, Class.foo
+local_internal_identifier = constant_identifier | variable_identifier
+
+# Examples: 
+#   Foo, foo, foo!
+#   foo
+# But not:
+#   @foo, Class.foo
+local_identifier = constant_identifier | vm_identifier
+
+# Example: @foo
+instance_identifier = < '@' local_identifier >
+    {
+      SymbolEntry.new(:instance, text)
+    }     
+
+
+# Example: @@foo
+classvar_identifier = ('@@' local_identifier:id )
+    {
+     SymbolEntry.new(:classvar, id)
+    }     
+
+identifier = global_identifier 
+       | instance_identifier 
+       | classvar_identifier 
+       | local_identifier 
+
+id_separator = < '::'|'.' > { text }
+
+# Like of class_module_chain *after* the first name. So we don't
+# allow sigils in the initial id. That is we don't allow:
+#   Class.@name1.@@name2.$name3  
+# But we do allow final sigils:
+#   class.name!, class.name=
+internal_class_module_chain = 
+    < local_internal_identifier:parent id_separator:sep  
+      internal_class_module_chain:child >
+      {
+         SymbolEntry.new(parent.type, text, [parent, child, sep])
+      }
+    | local_identifier
+
+
+# I think strict Ruby rules are that once one goes from :: to .
+# There is no going back. That is, A.B::C is invalid. 
+# 
+# Also I think method names can't be constants. But such 
+# subtleties we'll handle when we process the final structure.
+# Examples:
+#  Object, A::B, A.b @@foo.bar, $foo.bar.baz? 
+
+class_module_chain = 
+    < identifier:parent id_separator:sep  internal_class_module_chain:child >
+       {
+         SymbolEntry.new(parent.type, text, [parent, child, sep])
+      }
+    | identifier
+
+##############################################################
+# Location-specific things. This is used in conjunction with
+# method-like things above.
+          sp     = /[ \t]/
+           -     = sp+
+     dbl_escapes = "\\\"" { '"' }
+                 | "\\n"  { "\n" }
+                 | "\\t"  { "\t" }
+                 | "\\\\" { "\\" }
+     escapes    = "\\\"" { '"' }
+                 | "\\n"  { "\n" }
+                 | "\\t"  { "\t" }
+                 | "\\ "  { " " }
+                 | "\\:"  { ":" }
+                 | "\\\\" { "\\" }
+   dbl_seq       = < /[^\\"]+/ > { text }
+   dbl_not_quote = (dbl_escapes | dbl_seq)+:ary { ary }
+      dbl_string = "\"" dbl_not_quote:ary "\"" { ary.join }
+not_space_colon  = escapes 
+                 | < /[^ \t\n:]/ > { text }
+not_space_colons = ( not_space_colon )+:ary { ary.join }
+    filename    = dbl_string | not_space_colons
+file_pos_sep    = sp+ | ':'
+     integer    = </[0-9]+/> { text.to_i }
+ line_number    = integer
+
+vm_offset = '@' integer:int
+  {
+    Position.new(nil, nil, :offset, int)
+  }
+
+# Examples:
+#  @43
+#  5
+position = 
+  vm_offset 
+  | line_number:l { 
+  Position.new(nil, nil, :line, l) 
+}
+
+# Examples:
+#   Myclass.fn @5  # bytecode offset 5 of fn
+#   Myclass.fn:@5  # same as above
+#   Myclass.fn 5   # line number 5 of fn
+# Note: Myclass.fn could be either a filename or a method name
+
+# The below ordering is important. 
+# 1. Numbers can't be method names they are first. If there's a 
+#    file with that name, later we'll allow quoting to indicate filename.
+# 2. filename:position can't also be a method so that's next
+# 3. It is possible a filename can be a method name, but we
+#    test using File.exist? so we want to put this first.
+#    Later "quoting" will skip the File.exist?
+# 4. Class module *with* a position is next and has to be before
+#    without a position, else we would stop early before handling
+#    the position.
+
+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)
+    }
+
+if_unless = <"if" | "unless"> { text }
+condition = </.+/> { text}
+
+breakpoint_stmt_no_condition = location:loc  {
+  Breakpoint.new(loc, false, 'true')
+}
+
+# Note that the first word "break" is handled in the command.
+# Also, "break" with nothing else is handled there as well
+breakpoint_stmt = location:loc - if_unless:iu - condition:cond {
+     Breakpoint.new(loc, iu == 'unless', cond)
+}
+ | breakpoint_stmt_no_condition
+
+# 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.new(loc, int)
+}