ruby-debug19 0.11.5

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

@@ -0,0 +1,38 @@
+module Debugger
+
+  # Implements debugger "continue" command.
+  class ContinueCommand < Command
+    self.allow_in_post_mortem = true
+    self.need_context         = false
+    def regexp
+      /^\s* c(?:ont(?:inue)?)? (?:\s+(.*))? $/x
+    end
+
+    def execute
+      if @match[1] && !@state.context.dead?
+        filename = File.expand_path(@state.file)
+        line_number = get_int(@match[1], "Continue", 0, nil, 0)
+        return unless line_number
+        unless LineCache.trace_line_numbers(filename).member?(line_number)
+          errmsg("Line %d is not a stopping point in file \"%s\".\n", 
+                 line_number, filename) 
+          return
+        end
+        @state.context.set_breakpoint(filename, line_number)
+      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

@@ -0,0 +1,107 @@
+module Debugger
+  class RestartCommand < Command # :nodoc:
+    self.allow_in_control = true
+
+    def regexp
+      / ^\s*
+      (?:restart|R)
+      (?:\s+ (\S?.*\S))? \s*
+      $
+      /ix
+    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 = prog_script
+      else 
+        rdebug_script = Debugger::RDEBUG_SCRIPT
+      end
+      begin
+        Dir.chdir(Debugger::INITIAL_DIR)
+      rescue
+        print "Failed to change initial directory #{Debugger::INITIAL_DIR}"
+      end
+      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 == 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]
+          errmsg "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 = rdebug_script + args
+      print "Re exec'ing:\n\t#{cmd}\n"
+      exec cmd
+    rescue Errno::EOPNOTSUPP
+      print "Restart command is not available at this time.\n"
+    end
+
+    class << self
+      def help_command
+        'restart'
+      end
+
+      def help(cmd)
+        %{
+          restart|R [args] 
+          Restart the program. This is is a re-exec - all debugger state
+          is lost. If command arguments are passed those are used.
+        }
+      end
+    end
+  end
+
+  class InterruptCommand < Command # :nodoc:
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.event                = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s*i(?:nterrupt)?\s*$/
+    end
+    
+    def execute
+      unless Debugger.interrupt_last
+        context = Debugger.thread_context(Thread.main)
+        context.interrupt
+      end
+    end
+    
+    class << self
+      def help_command
+        'interrupt'
+      end
+      
+      def help(cmd)
+        %{
+          i[nterrupt]\tinterrupt the program
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Debugger
+  module DisplayFunctions # :nodoc:
+    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:
+    def regexp
+      /^\s*disp(?:lay)?\s+(.+)$/
+    end
+
+    def execute
+      exp = @match[1]
+      @state.display.push [true, exp]
+      print "%d: ", @state.display.size
+      display_expression(exp)
+    end
+
+    class << self
+      def help_command
+        'display'
+      end
+
+      def help(cmd)
+        %{
+          disp[lay] <expression>\tadd expression into display expression list
+        }
+      end
+    end
+  end
+
+  class DisplayCommand < Command # :nodoc:
+    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
+      print_display_expressions
+    end
+
+    class << self
+      def help_command
+        'display'
+      end
+
+      def help(cmd)
+        %{
+          disp[lay]\t\tdisplay expression list
+        }
+      end
+    end
+  end
+
+  class DeleteDisplayCommand < Command # :nodoc:
+
+    def regexp
+      /^\s* undisp(?:lay)? \s* (?:(\S+))?$/x
+    end
+
+    def execute
+      unless pos = @match[1]
+        if confirm("Clear all expressions? (y/n) ")
+          for d in @state.display
+            d[0] = false
+          end
+        end
+      else
+        pos = get_int(pos, "Undisplay")
+        return unless pos
+        if @state.display[pos-1]
+          @state.display[pos-1][0] = nil
+        else
+          errmsg "Display expression %d is not defined.\n", pos
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'undisplay'
+      end
+
+      def help(cmd)
+        %{
+          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

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

@@ -0,0 +1,48 @@
+module Debugger
+  class Edit < Command # :nodoc:
+    self.allow_in_control = true
+    def regexp
+      /^\s* ed(?:it)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1] or @match[1].strip.empty?
+        unless @state.context
+          errmsg "We are not in a state that has an associated file.\n"
+          return 
+        end
+        file = @state.file
+        line_number = @state.line
+      elsif @pos_match = /([^:]+)[:]([0-9]+)/.match(@match[1])
+        file, line_number = @pos_match.captures
+      else
+        errmsg "Invalid file/line number specification: #{@match[1]}\n"
+        return
+      end
+      editor = ENV['EDITOR'] || 'ex'
+      if File.readable?(file)
+        system("#{editor} +#{line_number} #{file}")
+      else
+        errmsg "File \"#{file}\" is not readable.\n"
+      end
+    end
+    
+    class << self
+      def help_command
+        'edit'
+      end
+
+      def help(cmd)
+        %{
+          Edit specified file.
+
+With no argument, edits file containing most recent line listed.
+Editing targets can also be specified in this:
+  FILE:LINENUM, to edit at that line in that file,
+        }
+      end
+    end
+  end
+
+
+end # module Debugger

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

@@ -0,0 +1,202 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module EnableDisableFunctions # :nodoc:
+    def enable_disable_breakpoints(is_enable, args)
+      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
+        errmsg "No breakpoints have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} breakpoints", 1, largest)
+        return nil unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            enabled = ("Enable" == is_enable)
+            if enabled
+              unless syntax_valid?(b.expr)
+                errmsg("Expression \"#{b.expr}\" syntactically incorrect; breakpoint remains disabled.\n")
+                break
+              end
+            end
+            b.enabled = ("Enable" == is_enable)
+            break
+          end
+        end
+      end
+    end
+
+    def enable_disable_display(is_enable, args)
+      if 0 == @state.display.size 
+        errmsg "No display expressions have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} display", 1, @state.display.size)
+        return nil unless pos
+        @state.display[pos-1][0] = ("Enable" == is_enable)
+      end
+    end
+
+  end
+
+  class EnableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 2, "Enable specified breakpoints",
+"Give breakpoint numbers (separated by spaces) as arguments.
+This is used to cancel the effect of the \"disable\" command."
+       ],
+       ['display', 2, 
+        "Enable some expressions to be displayed when program stops",
+"Arguments are the code numbers of the expressions to resume displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* en(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"enable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("enable_#{subcmd.name}", args)
+        else
+          send("enable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def enable_breakpoints(args)
+      enable_disable_breakpoints("Enable", args)
+    end
+    
+    def enable_display(args)
+      enable_disable_display("Enable", args)
+    end
+    
+    class << self
+      def help_command
+        'enable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'enable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Enable some things.
+          This is used to cancel the effect of the "disable" command.
+          -- 
+          List of enable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "enable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+  class DisableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 1, "Disable some breakpoints",
+"Arguments are breakpoint numbers with spaces in between.
+A disabled breakpoint is not forgotten, but has no effect until reenabled."],
+       ['display', 1, "Disable some display expressions when program stops",
+"Arguments are the code numbers of the expressions to stop displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* dis(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"disable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("disable_#{subcmd.name}", args)
+        else
+          send("disable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def disable_breakpoints(args)
+      enable_disable_breakpoints("Disable", args)
+    end
+    
+    def disable_display(args)
+      enable_disable_display("Disable", args)
+    end
+    
+    class << self
+      def help_command
+        'disable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'disable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Disable some things.
+
+          A disabled item is not forgotten, but has no effect until reenabled.
+          Use the "enable" command to have it take effect again.
+          -- 
+          List of disable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "disable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+end # module Debugger