ruby-debug 0.9.3 → 0.10.0

data/cli/ruby-debug.rb

@@ -9,11 +9,25 @@ module Debugger
   self.handler = CommandProcessor.new
   
   # the port number used for remote debugging
-  PORT = 8989
+  PORT = 8989 unless defined?(PORT)
 
+  # What file is used for debugger startup commands.
+  unless defined?(INITFILE)
+    if RUBY_PLATFORM =~ /mswin/
+      # Of course MS Windows has to be different
+      INITFILE = 'rdebug.ini'
+      HOME_DIR =  (ENV['HOME'] || 
+                   ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
+    else
+      INITFILE = '.rdebugrc'
+      HOME_DIR = ENV['HOME'].to_s
+    end
+  end
+  
   class << self
     # in remote mode, wait for the remote connection 
     attr_accessor :wait_connection
+    attr_accessor :annotate
     
     attr_reader :thread, :control_thread
 
@@ -105,13 +119,29 @@ module Debugger
       socket.close
     end
     
+    # Runs normal debugger initialization scripts
+    # Reads and executes the commands from init file (if any) in the
+    # current working directory.  This is only done if the current
+    # directory is different from your home directory.  Thus, you can
+    # have more than one init file, one generic in your home directory,
+    #  and another, specific to the program you are debugging, in the
+    # directory where you invoke ruby-debug.
+    def run_init_script(out = handler.interface)
+      cwd_script_file  = File.expand_path(File.join(".", INITFILE))
+      run_script(cwd_script_file, out) if File.exists?(cwd_script_file)
+
+      home_script_file = File.expand_path(File.join(HOME_DIR, INITFILE))
+      run_script(home_script_file, out) if File.exists?(home_script_file) and 
+        cwd_script_file != home_script_file
+    end
+
     #
     # Runs a script file
     #
     def run_script(file, out = handler.interface)
-      interface = ScriptInterface.new(file, out)
+      interface = ScriptInterface.new(File.expand_path(file), out)
       processor = ControlCommandProcessor.new(interface)
       processor.process_commands
     end
   end
-end
+end

data/cli/ruby-debug/command.rb

@@ -1,4 +1,7 @@
+require 'ruby-debug/helper'
+
 module Debugger
+
   class Command # :nodoc:
     class << self
       def commands
@@ -8,10 +11,10 @@ module Debugger
       DEF_OPTIONS = {
         :event => true, 
         :control => false, 
-        :always_run => false,
+        :always_run => 0,
         :unknown => false,
         :need_context => false,
-      }
+      } unless defined?(DEF_OPTIONS)
       
       def inherited(klass)
         DEF_OPTIONS.each do |o, v|
@@ -25,6 +28,9 @@ module Debugger
         Dir[File.join(dir, 'commands', '*')].each do |file|
           require file if file =~ /\.rb$/
         end
+        Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
+          include mod
+        end
       end
       
       def method_missing(meth, *args, &block)
@@ -49,16 +55,32 @@ module Debugger
       private :settings_map
       
       def settings
-        unless @settings
+        unless true and defined? @settings and @settings
           @settings = Object.new
           map = settings_map
-          class << @settings; self end.send(:define_method, :[]) do |name|
-            raise "No such setting #{name}" unless map.has_key?(name)
-            map[name][:getter].call
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          else
+            c.send(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
           end
-          class << @settings; self end.send(:define_method, :[]=) do |name, value|
-            raise "No such setting #{name}" unless map.has_key?(name)
-            map[name][:setter].call(value)
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          else
+            c.send(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
           end
         end
         @settings
@@ -82,10 +104,25 @@ module Debugger
       end
     end
 
-    register_setting_var(:stack_trace_on_error, false)
-    register_setting_var(:frame_full_path, true)
-    register_setting_var(:frame_class_names, false)
+    register_setting_var(:basename, false)  # use basename in showing files? 
+    register_setting_var(:callstyle, :last)
+    register_setting_var(:debuggertesting, false)
     register_setting_var(:force_stepping, false)
+    register_setting_var(:full_path, true)
+    register_setting_var(:listsize, 10)    # number of lines in list command
+    register_setting_var(:stack_trace_on_error, false)
+    register_setting_var(:tracing_plus, false) # different linetrace lines?
+    
+    # width of line output. Use COLUMNS value if it exists and is 
+    # not too rediculously large.
+    width = ENV['COLUMNS'].to_i 
+    width = 80 unless width > 10
+    register_setting_var(:width, width)  
+
+    if not defined? Debugger::ARGV
+      Debugger::ARGV = ARGV.clone
+    end
+    register_setting_var(:argv, Debugger::ARGV)
     
     def initialize(state)
       @state = state

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

@@ -5,11 +5,11 @@ module Debugger
     def regexp
       / ^\s*
         b(?:reak)?
-        \s+
+        (?: \s+
         (?:
           (\d+) |
           (.+?)[:.#]([^.:\s]+)
-        )
+        ))?
         (?:\s+
           if\s+(.+)
         )?
@@ -19,35 +19,50 @@ module Debugger
 
     def execute
       if @match[1]
-        pos, _, _, expr = @match.captures
+        line, _, _, expr = @match.captures
       else
-        _, file, pos, expr = @match.captures
+        _, file, line, expr = @match.captures
       end
-      
+
+      full_file = nil
       if file.nil?
+        full_file = @state.file
         file = File.basename(@state.file)
-      else
-        if pos !~ /^\d+$/
-          klass = debug_silent_eval(file)
-          if klass && !klass.kind_of?(Module)
-            print "Unknown class #{file}\n"
-            throw :debug_error
-          end
-          file = klass.name if klass
+        if line.nil? 
+          # Set breakpoint at current line
+          line = @state.line.to_s
+        end
+      elsif line !~ /^\d+$/
+        # See if "line" is a method/function name
+        klass = debug_silent_eval(file)
+        if klass && klass.kind_of?(Module)
+          class_name = klass.name if klass
         else
-          file = File.expand_path(file) if file.index(File::SEPARATOR) || \
-            File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
+          print "Unknown class #{file}.\n"
+          throw :debug_error
         end
+      else
+        file = File.expand_path(file) if file.index(File::SEPARATOR) || \
+        File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
+        full_file = file
       end
       
-      if pos =~ /^\d+$/
-        pos = pos.to_i
+      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
+        end
       else
-        pos = pos.intern.id2name
+        method = line.intern.id2name
+        b = Debugger.add_breakpoint class_name, method, expr
+        print "Breakpoint %d at %s::%s\n", b.id, class_name, method.to_s
       end
-      
-      b = Debugger.add_breakpoint file, pos, expr
-      print "Set breakpoint %d at %s:%s\n", b.id, file, pos.to_s
     end
 
     class << self
@@ -65,58 +80,26 @@ module Debugger
     end
   end
 
-  class BreakpointsCommand < Command # :nodoc:
-    self.control = true
-
-    def regexp
-      /^\s*b(?:reak)?$/
-    end
-
-    def execute
-      unless Debugger.breakpoints.empty?
-        print "Breakpoints:\n"
-        Debugger.breakpoints.sort_by{|b| b.id }.each do |b|
-          if b.expr.nil?
-            print "  %d %s:%s\n", b.id, b.source, b.pos
-          else
-            print "  %d %s:%s if %s\n", b.id, b.source, b.pos, b.expr
-          end
-        end
-      else
-        print "No breakpoints\n"
-      end
-    end
-
-    class << self
-      def help_command
-        'break'
-      end
-
-      def help(cmd)
-        %{
-          b[reak]\tlist breakpoints
-        }
-      end
-    end
-  end
-
   class DeleteBreakpointCommand < Command # :nodoc:
     self.control = true
 
     def regexp
-      /^\s*del(?:ete)?(?:\s+(\d+))?$/
+      /^\s*del(?:ete)?(?:\s+(.*))?$/
     end
 
     def execute
-      pos = @match[1]
-      unless pos
-        if confirm("Clear all breakpoints? (y/n) ")
+      brkpts = @match[1]
+      unless brkpts
+        if confirm("Delete all breakpoints? (y or n) ")
           Debugger.breakpoints.clear
         end
       else
-        pos = pos.to_i
-        unless Debugger.remove_breakpoint(pos)
-          print "Breakpoint %d is not defined\n", pos
+        brkpts.split(/[ \t]+/).each do |pos|
+          pos = get_int(pos, "Delete", 1)
+          return unless pos
+          unless Debugger.remove_breakpoint(pos)
+            print "No breakpoint number %d\n", pos
+          end
         end
       end
     end
@@ -128,7 +111,7 @@ module Debugger
 
       def help(cmd)
         %{
-          del[ete][ nnn]\tdelete some or all breakpoints
+          del[ete][ nnn...]\tdelete some or all breakpoints
         }
       end
     end

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

@@ -3,11 +3,11 @@ module Debugger
     self.control = true
 
     def regexp
-      /^\s*(?:q(?:uit)?|exit)\s*$/
+      /^\s*(?:q(?:uit)?|exit)\s*(\s+unconditionally)?\s*$/
     end
 
     def execute
-      if confirm("Really quit? (y/n) ")
+      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
@@ -20,8 +20,11 @@ module Debugger
 
       def help(cmd)
         %{
-          q[uit]\texit from debugger, 
+          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
@@ -32,25 +35,50 @@ module Debugger
 
     def regexp
       / ^\s*
-      (restart|R)
-      (\s+ \S+ .*)?
+      (?:restart|R)
+      (?:\s+ (\S?.*\S))? \s*
       $
-      /x
+      /ix
     end
     
     def execute
-      if not defined? Debugger::RDEBUG_SCRIPT or not defined? Debugger::ARGV
-        print "We are not in a context we can restart from.\n"
+      if not defined? Debugger::RDEBUG_SCRIPT
+        # FIXME? Should ask for confirmation? 
+        print "Debugger was not called from the outset...\n"
+        rdebug_script = ''
+      else 
+        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"
         return
       end
-      if @match[2]
-        args = Debugger::PROG_SCRIPT + " " + @match[2]
+      if not File.executable?(prog_script) and rdebug_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}"
+      end
+      if @match[1]
+        argv = [prog_script] + @match[1].split(/[ \t]+/)
       else
-        args = Debugger::ARGV.join(" ")
+        if not defined? Command.settings[:argv]
+          print "Arguments have not been set. Use 'set args' to set them.\n"
+          return
+        else
+          argv = Command.settings[:argv]
+        end
       end
+      args = argv.join(" ")
 
       # An execv would be preferable to the "exec" below.
-      cmd = Debugger::RDEBUG_SCRIPT + " " + args
+      cmd = rdebug_script + args
       print "Re exec'ing:\n\t#{cmd}\n"
       exec cmd
     rescue Errno::EOPNOTSUPP
@@ -100,4 +128,4 @@ module Debugger
       end
     end
   end
-end
+end

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

@@ -3,11 +3,24 @@ module Debugger
     def display_expression(exp)
       print "%s = %s\n", exp, debug_silent_eval(exp).to_s
     end
+    
+    def active_display_expressions?
+      @state.display.select{|d| d[0]}.size > 0
+    end
+
+    def print_display_expressions
+      n = 1
+      for d in @state.display
+        if d[0]
+          print "%d: ", n
+          display_expression(d[1])
+        end
+        n += 1
+      end
+    end
   end
 
   class AddDisplayCommand < Command # :nodoc:
-    include DisplayFunctions
-
     def regexp
       /^\s*disp(?:lay)?\s+(.+)$/
     end
@@ -33,22 +46,21 @@ module Debugger
   end
 
   class DisplayCommand < Command # :nodoc:
-    self.always_run = true
-    include DisplayFunctions
+    def self.always_run 
+      Debugger.annotate = 0 unless Debugger.annotate
+      if Debugger.annotate > 1 
+        0
+      else
+        2
+      end
+    end
     
     def regexp
       /^\s*disp(?:lay)?$/
     end
 
     def execute
-      n = 1
-      for d in @state.display
-        if d[0]
-          print "%d: ", n
-          display_expression(d[1])
-        end
-        n += 1
-      end
+      print_display_expressions
     end
 
     class << self
@@ -65,10 +77,9 @@ module Debugger
   end
 
   class DeleteDisplayCommand < Command # :nodoc:
-    include DisplayFunctions
 
     def regexp
-      /^\s*undisp(?:lay)?(?:\s+(\d+))?$/
+      /^\s* undisp(?:lay)? \s* (?:(\S+))?$/x
     end
 
     def execute
@@ -79,9 +90,10 @@ module Debugger
           end
         end
       else
-        pos = pos.to_i
+        pos = get_int(pos, "Undisplay")
+        return unless pos
         if @state.display[pos-1]
-          @state.display[pos-1][0] = false
+          @state.display[pos-1][0] = nil
         else
           print "Display expression %d is not defined\n", pos
         end
@@ -95,9 +107,14 @@ module Debugger
 
       def help(cmd)
         %{
-          undisp[lay][ nnn]\tdelete one particular or all display expressions
+          undisp[lay][ nnn]
+          Cancel some expressions to be displayed when program stops.
+          Arguments are the code numbers of the expressions to stop displaying.
+          No argument means cancel all automatic-display expressions.
+          "delete display" has the same effect as this command.
+          Do "info display" to see current list of code numbers.
         }
       end
     end
   end
-end
+end