ruby-debug 0.10.0 → 0.10.1

data/cli/ruby-debug/command.rb

@@ -1,16 +1,39 @@
+require 'rubygems'
+require 'columnize'
 require 'ruby-debug/helper'
 
 module Debugger
+  RUBY_DEBUG_DIR = File.expand_path(File.dirname(__FILE__)) unless
+    defined?(RUBY_DEBUG_DIR)
 
   class Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    include Columnize
+
+    # Find param in subcmds. param id downcased and can be abbreviated
+    # to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
     class << self
       def commands
         @commands ||= []
       end
       
       DEF_OPTIONS = {
+        :allow_in_control     => false, 
+        :allow_in_post_mortem => true,
         :event => true, 
-        :control => false, 
         :always_run => 0,
         :unknown => false,
         :need_context => false,
@@ -24,8 +47,7 @@ module Debugger
       end 
 
       def load_commands
-        dir = File.dirname(__FILE__)
-        Dir[File.join(dir, 'commands', '*')].each do |file|
+        Dir[File.join(Debugger.const_get(:RUBY_DEBUG_DIR), 'commands', '*')].each do |file|
           require file if file =~ /\.rb$/
         end
         Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
@@ -134,6 +156,11 @@ module Debugger
 
     protected
 
+    # FIXME: use delegate? 
+    def errmsg(*args)
+      @state.errmsg(*args)
+    end
+
     def print(*args)
       @state.print(*args)
     end

data/cli/ruby-debug/commands/breakpoints.rb

@@ -1,18 +1,12 @@
 module Debugger
   class AddBreakpoint < Command # :nodoc:
-    self.control = true
+    self.allow_in_control = true
     
     def regexp
       / ^\s*
         b(?:reak)?
-        (?: \s+
-        (?:
-          (\d+) |
-          (.+?)[:.#]([^.:\s]+)
-        ))?
-        (?:\s+
-          if\s+(.+)
-        )?
+        (?: \s+ #{Position_regexp})? \s*
+        (?: \s+ (.*))? \s*
         $
       /x
     end
@@ -23,10 +17,26 @@ module Debugger
       else
         _, file, line, expr = @match.captures
       end
+      if expr 
+        if expr !~ /^\s*if\s+(.+)/
+          if file or line
+            errmsg "Expecting 'if' in breakpoint condition; got: #{expr}.\n"
+          else
+            errmsg "Invalid breakpoint location: #{expr}.\n"
+          end
+          return
+        else
+          expr = $1
+        end
+      end
 
-      full_file = nil
+      brkpt_filename = nil
       if file.nil?
-        full_file = @state.file
+        unless @state.context
+          errmsg "We are not in a state that has an associated file.\n"
+          return 
+        end
+        brkpt_filename = @state.file
         file = File.basename(@state.file)
         if line.nil? 
           # Set breakpoint at current line
@@ -38,25 +48,41 @@ module Debugger
         if klass && klass.kind_of?(Module)
           class_name = klass.name if klass
         else
-          print "Unknown class #{file}.\n"
+          errmsg "Unknown class #{file}.\n"
           throw :debug_error
         end
       else
+        # FIXME: This should be done in LineCache.
         file = File.expand_path(file) if file.index(File::SEPARATOR) || \
         File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
-        full_file = file
+        brkpt_filename = file
       end
       
       if line =~ /^\d+$/
         line = line.to_i
-        lines = Debugger.source_for(full_file)
-        if not lines 
-          print "No source file named %s\n", file
-        elsif lines.size < line
-          print "No line %d in file \"%s\"\n", line, file
-        else
-          b = Debugger.add_breakpoint file, line, expr
-          print "Breakpoint %d file %s, line %s\n", b.id, file, line.to_s
+        unless LineCache.cache(brkpt_filename, 
+                                Command.settings[:reload_source_on_change])
+          errmsg("No source file named %s\n", file) 
+          return
+        end
+        last_line = LineCache.size(brkpt_filename)
+        if line > last_line
+          errmsg("There are only %d lines in file \"%s\".\n", last_line, file) 
+          return
+        end
+        unless LineCache.trace_line_numbers(brkpt_filename).member?(line)
+          errmsg("Line %d is not a stopping point in file \"%s\".\n", line, file) 
+          return
+        end
+        unless @state.context
+          errmsg "We are not in a state we can add breakpoints.\n"
+          return 
+        end
+        b = Debugger.add_breakpoint file, line, expr
+        print "Breakpoint %d file %s, line %s\n", b.id, brkpt_filename, line.to_s
+        unless syntax_valid?(expr)
+          errmsg("Expression \"#{expr}\" syntactically incorrect; breakpoint disabled.\n")
+          b.enabled = false
         end
       else
         method = line.intern.id2name
@@ -81,13 +107,17 @@ module Debugger
   end
 
   class DeleteBreakpointCommand < Command # :nodoc:
-    self.control = true
+    self.allow_in_control = true
 
     def regexp
-      /^\s*del(?:ete)?(?:\s+(.*))?$/
+      /^\s *del(?:ete)? (?:\s+(.*))?$/ix
     end
 
     def execute
+      unless @state.context
+        errmsg "We are not in a state we can delete breakpoints.\n"
+        return 
+      end
       brkpts = @match[1]
       unless brkpts
         if confirm("Delete all breakpoints? (y or n) ")
@@ -98,7 +128,7 @@ module Debugger
           pos = get_int(pos, "Delete", 1)
           return unless pos
           unless Debugger.remove_breakpoint(pos)
-            print "No breakpoint number %d\n", pos
+            errmsg "No breakpoint number %d\n", pos
           end
         end
       end

data/cli/ruby-debug/commands/catchpoint.rb

@@ -1,9 +1,9 @@
 module Debugger
   class CatchCommand < Command # :nodoc:
-    self.control = true
+    self.allow_in_control = true
 
     def regexp
-      /^\s*cat(?:ch)?(?:\s+(.+))?$/
+      /^\s* cat(?:ch)? (?:\s+(.+))? $/x
     end
 
     def execute
@@ -12,15 +12,15 @@ module Debugger
           Debugger.catchpoint = nil
           print "Clear catchpoint.\n"
         else
-          Debugger.catchpoint = excn
-          print "Set catchpoint %s.\n", excn
+          binding = @state.context ? get_binding : TOPLEVEL_BINDING
+          unless debug_eval("#{excn}.is_a?(Class)", binding)
+            print "Warning #{excn} is not known to be a Class\n"
+          end
+          Debugger.add_catchpoint(excn)
+          print "Catch exception %s.\n", excn
         end
       else
-        if Debugger.catchpoint
-          print "Catchpoint %s.\n", Debugger.catchpoint
-        else
-          print "No catchpoint.\n"
-        end
+        info_catch
       end
     end
 
@@ -31,10 +31,11 @@ module Debugger
 
       def help(cmd)
         %{
-          cat[ch]\t\t\tshow catchpoint
-          cat[ch] <an Exception>\tset catchpoint to an exception
+          cat[ch]\t\t\tsame as "info catch"
+          cat[ch] <exception-name>\tIntercept <exception-name> when there would otherwise be is no handler 
+for it.
         }
       end
     end
   end
-end
+end

data/cli/ruby-debug/commands/condition.rb

@@ -0,0 +1,49 @@
+module Debugger
+
+  class ConditionCommand < Command # :nodoc:
+
+    def regexp
+      /^\s* cond(?:ition)? (?:\s+(\d+)\s*(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"condition\" must be followed a breakpoint number and expression\n"
+      else
+        breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+        largest = breakpoints.inject(0) do |largest, b| 
+          largest = b.id if b.id > largest
+        end
+        if 0 == largest
+          print "No breakpoints have been set.\n"
+          return
+        end
+        pos = get_int(@match[1], "Condition", 1, largest)
+        return unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            b.expr = @match[2].empty? ? nil : @match[2]
+            break
+          end
+        end
+
+      end
+    end
+    
+    class << self
+      def help_command
+        'condition'
+      end
+
+      def help(cmd)
+        %{
+          Condition breakpoint-number expression
+Specify breakpoint number N to break only if COND is true.
+N is an integer and COND is an expression to be evaluated whenever 
+breakpoint N is reached. If the empty string is used, the condition is removed.
+        }
+      end
+    end
+  end
+
+end # module Debugger

data/cli/ruby-debug/commands/continue.rb

@@ -0,0 +1,32 @@
+module Debugger
+  # Implements debugger "continue" command.
+  class ContinueCommand < Command
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    def regexp
+      /^\s* c(?:ont(?:inue)?)? (?:\s+(.*))? $/x
+    end
+
+    def execute
+      if @match[1] && !@state.context.dead?
+        file = File.expand_path(@state.file)
+        line = get_int(@match[1], "Continue", 0, nil, 0)
+        return unless line
+        @state.context.set_breakpoint(file, line)
+      end
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'continue'
+      end
+
+      def help(cmd)
+        %{
+          c[ont[inue]][ nnn]\trun until program ends, hits a breakpoint or reaches line nnn 
+        }
+      end
+    end
+  end
+end

data/cli/ruby-debug/commands/control.rb

@@ -1,37 +1,6 @@
 module Debugger
-  class QuitCommand < Command # :nodoc:
-    self.control = true
-
-    def regexp
-      /^\s*(?:q(?:uit)?|exit)\s*(\s+unconditionally)?\s*$/
-    end
-
-    def execute
-      if @match[1] or confirm("Really quit? (y/n) ") 
-        Debugger.save_history if Debugger.respond_to? :save_history
-        exit! # exit -> exit!: No graceful way to stop threads...
-      end
-    end
-
-    class << self
-      def help_command
-        %w[quit exit]
-      end
-
-      def help(cmd)
-        %{
-          q[uit] [unconditionally]\texit from debugger. 
-          exit\talias to quit
-
-          Normally we prompt before exiting. However if the parameter
-          "unconditionally" is given, we stop without asking further questions.
-        }
-      end
-    end
-  end
-  
   class RestartCommand < Command # :nodoc:
-    self.control = true
+    self.allow_in_control = true
 
     def regexp
       / ^\s*
@@ -42,40 +11,46 @@ module Debugger
     end
     
     def execute
+      if not defined? Debugger::PROG_SCRIPT
+        errmsg "Don't know name of debugged program\n"
+        return
+      end
+      prog_script = Debugger::PROG_SCRIPT
       if not defined? Debugger::RDEBUG_SCRIPT
         # FIXME? Should ask for confirmation? 
         print "Debugger was not called from the outset...\n"
-        rdebug_script = ''
+        rdebug_script = prog_script
       else 
-        rdebug_script = Debugger::RDEBUG_SCRIPT + " "
+        rdebug_script = Debugger::RDEBUG_SCRIPT
       end
-      prog_script = Debugger::PROG_SCRIPT
       begin
         Dir.chdir(Debugger::INITIAL_DIR)
       rescue
         print "Failed to change initial directory #{Debugger::INITIAL_DIR}"
       end
-      if not File.exists?(prog_script)
-        print "Ruby program #{prog_script} doesn't exist\n"
+      if not File.exist?(File.expand_path(prog_script))
+        errmsg "Ruby program #{prog_script} doesn't exist\n"
         return
       end
-      if not File.executable?(prog_script) and rdebug_script == ''
+      if not File.executable?(prog_script) and rdebug_script == prog_script
         print "Ruby program #{prog_script} doesn't seem to be executable...\n"
         print "We'll add a call to Ruby.\n"
         ruby = begin defined?(Gem) ? Gem.ruby : "ruby" rescue "ruby" end
         rdebug_script = "#{ruby} -I#{$:.join(' -I')} #{prog_script}"
+      else
+        rdebug_script += ' '
       end
       if @match[1]
         argv = [prog_script] + @match[1].split(/[ \t]+/)
       else
         if not defined? Command.settings[:argv]
-          print "Arguments have not been set. Use 'set args' to set them.\n"
+          errmsg "Arguments have not been set. Use 'set args' to set them.\n"
           return
         else
           argv = Command.settings[:argv]
         end
       end
-      args = argv.join(" ")
+      args = argv.join(' ')
 
       # An execv would be preferable to the "exec" below.
       cmd = rdebug_script + args
@@ -101,9 +76,10 @@ module Debugger
   end
 
   class InterruptCommand < Command # :nodoc:
-    self.event = false
-    self.control = true
-    self.need_context = true
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.event                = false
+    self.need_context         = true
     
     def regexp
       /^\s*i(?:nterrupt)?\s*$/

data/cli/ruby-debug/commands/disassemble.RB

@@ -0,0 +1,38 @@
+module Debugger
+
+  require 'pp'
+  require 'nodepp'
+  require 'classtree'
+  require 'parse_tree'
+  class Disassemble < Command # :nodoc:
+    self.allow_in_control = false
+    @@parse_tree = ParseTree.new(true)
+    
+    def regexp
+      /^\s*(dis(?:assemble)?)\s+/
+    end
+
+    def execute
+      expr = @match ? @match.post_match : @input
+      binding = @state.context ? get_binding : TOPLEVEL_BINDING
+      method_str = "method(:#{expr})"
+      if method_obj = debug_eval(method_str, binding)
+        print @@parse_tree.parse_tree_for_method(method_obj.class, 
+                                                 method_str).inspect
+        print "#{method_obj}\n"
+      end
+    end
+
+    class << self
+      def help_command
+        %w|disassemble method-name|
+      end
+
+      def help(cmd)
+          %{
+            dis[assemble] method-name\tdo live unparsing of method name
+          }
+      end
+    end
+  end if false
+end