ruby-debug 0.9.3 → 0.10.0

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

@@ -0,0 +1,193 @@
+module Debugger
+  # Mix-in module to showing settings
+  module ShowFunctions # :nodoc:
+    def show_setting(setting_name)
+      case setting_name
+      when /^annotate$/
+        Debugger.annotate ||= 0
+        return ("Annotation level is #{Debugger.annotate}")
+      when /^args$/
+        if Command.settings[:argv] and Command.settings[:argv].size > 0
+          args = Command.settings[:argv][1..-1].join(' ')
+        else
+          args = ''
+        end
+        return "Argument list to give program being debugged when it is started is \"#{args}\"."
+      when /^autolist$/
+        on_off = Command.settings[:autolist] > 0
+        return "autolist is #{show_onoff(on_off)}."
+      when /^autoeval$/
+        on_off = Command.settings[:autoeval]
+        return "autoeval is #{show_onoff(on_off)}."
+      when /^autoreload$/
+        on_off = Command.settings[:reload_source_on_change]
+        return "autoreload is #{show_onoff(on_off)}."
+      when /^autoirb$/
+        on_off = Command.settings[:autoirb] > 0
+        return "autoirb is #{show_onoff(on_off)}."
+      when /^basename$/
+        on_off = Command.settings[:basename]
+        return "basename is #{show_onoff(on_off)}."
+      when /^callstyle$/
+        style = Command.settings[:callstyle]
+        return "Frame call-display style is #{style}."
+      when /^debuggertesting$/
+        on_off = Command.settings[:debuggertesting]
+        return "Currently testing the debugger is #{show_onoff(on_off)}."
+      when /^forcestep$/
+        on_off = self.class.settings[:force_stepping]
+        return "force-stepping is #{show_onoff(on_off)}."
+      when /^fullpath$/
+        on_off = Command.settings[:full_path]
+        return "Displaying frame's full file names is #{show_onoff(on_off)}."
+      when /^history(:?\s+(filename|save|size))?$/
+        args = @match[1].split
+        interface = @state.interface
+        if args[1] 
+          show_save = show_size = show_filename = false
+          prefix = false
+          if args[1] == "save"
+            show_save = true
+          elsif args[1] == "size"
+            show_size = true
+          elsif args[1] == "filename"
+            show_filename = true
+          end
+        else
+          show_save = show_size = show_filename = true
+          prefix = true
+        end
+        s = []
+        if show_filename
+          msg = (prefix ? "filename: " : "") + 
+            "The filename in which to record the command history is " +
+                      "#{interface.histfile.inspect}"
+          s << msg
+        end
+        if show_save
+          msg = (prefix ? "save: " : "") + 
+            "Saving of history save is #{show_onoff(interface.history_save)}."
+          s << msg
+        end
+        if show_size
+          msg = (prefix ? "size: " : "") + 
+            "Debugger history size is #{interface.history_length}"
+          s << msg
+        end
+        return s.join("\n")
+      when /^keep-frame-bindings$/
+        on_off = Debugger.keep_frame_binding?
+        return "keep-frame-bindings is #{show_onoff(on_off)}."
+      when /^linetrace$/
+        on_off = Debugger.tracing
+        return "line tracing is #{show_onoff(on_off)}."
+      when /^linetrace\+$/
+        on_off = Command.settings[:tracing_plus]
+        if on_off
+          return "line tracing style is different consecutive lines."
+        else
+          return "line tracing style is every line."
+        end
+      when /^listsize$/
+        listlines = Command.settings[:listsize]
+        return "Number of source lines to list by default is #{listlines}."
+      when /^port$/
+        return "server port is #{Debugger::PORT}."
+      when /^post-mortem$/
+        on_off = Debugger.post_mortem
+        return "post-mortem handling is #{show_onoff(on_off)}."
+      when /^trace$/
+        on_off = Command.settings[:stack_trace_on_error]
+        return "Displaying stack trace is #{show_onoff(on_off)}."
+      when /^version$/
+        return "ruby-debug #{Debugger::VERSION}"
+      when /^width$/
+        return "width is #{self.class.settings[:width]}."
+      else
+        return "Unknown show subcommand #{setting_name}."
+      end
+    end
+  end
+
+  class ShowCommand < Command # :nodoc:
+    
+    SubcmdStruct=Struct.new(:name, :min, :short_help) unless 
+      defined?(SubcmdStruct)
+    Subcommands = 
+      [
+       ['annotate', 2, "Show annotation level"],
+       ['args', 2, 
+        "Show argument list to give program being debugged when it is started"],
+       ['autoeval', 4, "Show if unrecognized command are evaluated"],
+       ['autolist', 4, "Show if 'list' commands is run on breakpoints"],
+       ['autoirb', 4, "Show if IRB is invoked on debugger stops"],
+       ['autoreload', 4, "Show if source code is reloaded when changed"],
+       ['basename', 1, "Show if basename used in reporting files"],
+       ['callstyle', 2, "Show paramater style used showing call frames"],
+       ['forcestep', 1, "Show if sure 'next/step' forces move to a new line"],
+       ['fullpath', 2, "Show if full file names are displayed in frames"],
+       ['history', 2, "Generic command for showing command history parameters"],
+       ['keep-frame-bindings', 1, "Save frame binding on each call"],
+       ['linetrace', 3, "Show line execution tracing"],
+       ['linetrace+', 10, 
+        "Show if consecutive lines should be different are shown in tracing"],
+       ['listsize', 3, "Show number of source lines to list by default"],
+       ['port', 1, "Show server port"],
+       ['trace', 1, 
+        "Show if a stack trace is displayed when 'eval' raises exception"],
+       ['version', 1, 
+        "Show what version of the debugger this is"],
+       ['width', 1, 
+        "Show the number of characters the debugger thinks are in a line"],
+      ].map do |name, min, short_help| 
+      SubcmdStruct.new(name, min, short_help)
+    end unless defined?(Subcommands)
+    
+    self.control = true
+
+    def regexp
+      /^show (?: \s+ (.+) )?$/xi
+    end
+
+    def execute
+      if not @match[1]
+        print "\"show\" must be followed by the name of an show command:\n"
+        print "List of show subcommands:\n\n"
+        for subcmd in Subcommands do
+          print "show #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+      else
+        subcmd, arg = @match[1].split(/[ \t]+/)
+        subcmd.downcase!
+        for try_subcmd in Subcommands do
+          if (subcmd.size >= try_subcmd.min) and
+              (try_subcmd.name[0..subcmd.size-1] == subcmd)
+            print "%s\n" % show_setting(try_subcmd.name)
+            return
+          end
+        end
+        print "Unknown show command #{subcmd}\n"
+      end
+    end
+
+    class << self
+      def help_command
+        "show"
+      end
+
+      def help(cmd)
+        s = "
+          Generic command for showing things about the debugger.
+
+          -- 
+          List of show subcommands:
+          --  
+        "
+        for subcmd in Subcommands do
+          s += "show #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+end

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

@@ -3,12 +3,13 @@ module Debugger
     self.need_context = true
     
     def regexp
-      /^\s*n(?:ext)?([+-])?(?:\s+(\d+))?$/
+      /^\s*n(?:ext)?([+])?(?:\s+(.*))?$/
     end
 
     def execute
       force = @match[1] == '+' || (@match[1].nil? && Command.settings[:force_stepping])
-      steps = @match[2] ? @match[2].to_i : 1
+      steps = get_int(@match[2], "Next", 1)
+      return unless steps
       @state.context.step_over steps, @state.frame_pos, force
       @state.proceed
     end
@@ -20,7 +21,7 @@ module Debugger
 
       def help(cmd)
         %{
-          n[ext][+][ nnn]\tstep over once or nnn times, 
+          n[ext][+]?[ nnn]\tstep over once or nnn times, 
           \t\t'+' forces to move to another line
         }
       end
@@ -31,12 +32,13 @@ module Debugger
     self.need_context = true
     
     def regexp
-      /^\s*s(?:tep)?([+-])?(?:\s+(\d+))?$/
+      /^\s*s(?:tep)?([+])?(?:\s+(.*))?$/
     end
 
     def execute
       force = @match[1] == '+' || (@match[1].nil? && Command.settings[:force_stepping])
-      steps = @match[2] ? @match[2].to_i : 1
+      steps = get_int(@match[2], "Step", 1)
+      return unless steps
       @state.context.step(steps, force)
       @state.proceed
     end
@@ -48,7 +50,8 @@ module Debugger
 
       def help(cmd)
         %{
-          s[tep][ nnn]\tstep (into methods) once or nnn times
+          s[tep][+]?[ nnn]\tstep (into methods) once or nnn times
+          \t\t'+' forces to move to another line
         }
       end
     end
@@ -86,25 +89,27 @@ module Debugger
 
   class ContinueCommand < Command # :nodoc:
     def regexp
-      /^\s*c(?:ont)?(?:\s+(\d+))?$/
+      /^\s*c(?:ont(?:inue)?)?(?:\s+(.*))?$/
     end
 
     def execute
       if @match[1] && !@state.context.dead?
         file = File.expand_path(@state.file)
-        @state.context.set_breakpoint(file, @match[1].to_i)
+        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
-        'cont'
+        'continue'
       end
 
       def help(cmd)
         %{
-          c[ont][ nnn]\trun until program ends or hits breakpoint or reaches line nnn 
+          c[ont[inue]][ nnn]\trun until program ends or hits breakpoint or reaches line nnn 
         }
       end
     end

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

@@ -12,11 +12,31 @@ module Debugger
       end
       print "\n"
     end
+    
+    def parse_thread_num(subcmd, arg)
+      if '' == arg
+        print "'thread %s' needs a thread number\n" % subcmd
+      else
+        thread_num = get_int(arg, "thread #{subcmd}", 1)
+        return nil unless thread_num
+        c = get_context(thread_num)
+        case 
+        when nil == c
+          print "No such thread.\n"
+        when @state.context == c
+          print "It's the current thread.\n"
+        when c.ignored?
+          print "Can't #{subcmd} to the debugger thread.\n"
+        else # Everything is okay
+          return c
+        end
+      end
+      return nil
+    end
   end
 
   class ThreadListCommand < Command # :nodoc:
     self.control = true
-    include ThreadFunctions
 
     def regexp
       /^\s*th(?:read)?\s+l(?:ist)?\s*$/
@@ -41,29 +61,19 @@ module Debugger
     end
   end
 
-  class ThreadSwitchCommand < Command # :nodoc:
+  class ThreadStopCommand < Command # :nodoc:
     self.control = true
     self.need_context = true
     
-    include ThreadFunctions
-
     def regexp
-      /^\s*th(?:read)?\s+(?:sw(?:itch)?\s+)?(\d+)\s*$/
+      /^\s*th(?:read)?\s+stop\s*(\S*)\s*$/
     end
 
     def execute
-      c = get_context(@match[1].to_i)
-      case
-      when c == @state.context
-        print "It's the current thread.\n"
-      when c.ignored?
-        print "Can't switch to the debugger thread.\n"
-      else
-        display_context(c)
-        c.stop_next = 1
-        c.thread.run
-        @state.proceed
-      end
+      c = parse_thread_num("stop", @match[1])
+      return unless c 
+      c.suspend
+      display_context(c)
     end
 
     class << self
@@ -73,33 +83,29 @@ module Debugger
 
       def help(cmd)
         %{
-          th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
+          th[read] stop <nnn>\t\tstop thread nnn
         }
       end
     end
   end
 
-  class ThreadStopCommand < Command # :nodoc:
+  class ThreadResumeCommand < Command # :nodoc:
     self.control = true
     self.need_context = true
     
-    include ThreadFunctions
-
     def regexp
-      /^\s*th(?:read)?\s+stop\s+(\d+)\s*$/
+      /^\s*th(?:read)?\s+resume\s*(\S*)\s*$/
     end
 
     def execute
-      c = get_context(@match[1].to_i)
-      case
-      when c == @state.context
-        print "It's the current thread.\n"
-      when c.ignored?
-        print "Can't stop the debugger thread.\n"
-      else
-        c.suspend
-        display_context(c)
+      c = parse_thread_num("resume", @match[1])
+      return unless c 
+      if !c.thread.stop?
+        print "Already running."
+        return
       end
+      c.resume
+      display_context(c)
     end
 
     class << self
@@ -109,23 +115,30 @@ module Debugger
 
       def help(cmd)
         %{
-          th[read] stop <nnn>\t\tstop thread nnn
+          th[read] resume <nnn>\t\tresume thread nnn
         }
       end
     end
   end
 
-  class ThreadCurrentCommand < Command # :nodoc:
+  # Thread switch Must come after "Thread resume" because "switch" is
+  # optional
+
+  class ThreadSwitchCommand < Command # :nodoc:
+    self.control = true
     self.need_context = true
     
-    include ThreadFunctions
-
     def regexp
-      /^\s*th(?:read)?\s+c(?:ur(?:rent)?)?\s*$/
+      /^\s*th(?:read)?\s*(?:sw(?:itch)?)?\s+(\S+)\s*$/
     end
 
     def execute
-      display_context(@state.context)
+      c = parse_thread_num("switch", @match[1])
+      return unless c 
+      display_context(c)
+      c.stop_next = 1
+      c.thread.run
+      @state.proceed
     end
 
     class << self
@@ -135,35 +148,21 @@ module Debugger
 
       def help(cmd)
         %{
-          th[read] c[ur[rent]]\t\tshow current thread
+          th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
         }
       end
     end
   end
 
-  class ThreadResumeCommand < Command # :nodoc:
-    self.control = true
+  class ThreadCurrentCommand < Command # :nodoc:
     self.need_context = true
     
-    include ThreadFunctions
-
     def regexp
-      /^\s*th(?:read)?\s+resume\s+(\d+)\s*$/
+      /^\s*th(?:read)?\s*(?:cur(?:rent)?)?\s*$/
     end
 
     def execute
-      c = get_context(@match[1].to_i)
-      case
-      when c == @state.context
-        print "It's the current thread.\n"
-      when c.ignored?
-        print "Can't resume the debugger thread.\n"
-      when !c.thread.stop?
-        print "Already running."
-      else
-        c.resume
-        display_context(c)
-      end
+      display_context(@state.context)
     end
 
     class << self
@@ -173,7 +172,7 @@ module Debugger
 
       def help(cmd)
         %{
-          th[read] resume <nnn>\t\tresume thread nnn
+          th[read] [cur[rent]]\t\tshow current thread
         }
       end
     end