ruby-debug 0.10.0 → 0.10.1

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

@@ -0,0 +1,36 @@
+module Debugger
+  # Implements debugger "source" command.
+  class SourceCommand < Command
+    self.allow_in_control = true
+    
+    def regexp
+      /^\s* so(?:urce)? \s+ (.+) $/x
+    end
+    
+    def execute
+      file = File.expand_path(@match[1]).strip
+      unless File.exist?(file)
+        errmsg "Command file '#{file}' is not found\n"
+        return
+      end
+      if @state and @state.interface
+        @state.interface.command_queue += File.open(file).readlines
+      else
+        Debugger.run_script(file, @state)
+      end
+    end
+    
+    class << self
+      def help_command
+        'source'
+      end
+      
+      def help(cmd)
+        %{
+          source FILE\texecutes a file containing debugger commands
+        }
+      end
+    end
+  end
+  
+end

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

@@ -1,14 +1,31 @@
 module Debugger
-  class NextCommand < Command # :nodoc:
-    self.need_context = true
+  # Mix-in module to assist in command parsing.
+  module SteppingFunctions # :nodoc:
+    def parse_stepping_args(command_name, match)
+      if match[1].nil? 
+          force = Command.settings[:force_stepping]
+      elsif match[1] == '+' 
+        force = true
+      elsif match[1] == '-' 
+        force = false
+      end
+      steps = get_int(match[2], command_name, 1)
+      return [steps, force]
+    end
+  end
+  # Implements debugger "next" command.
+  class NextCommand < Command
+    self.allow_in_post_mortem  = false
+    self.need_context          = true
     
     def regexp
-      /^\s*n(?:ext)?([+])?(?:\s+(.*))?$/
+      /^\s* n(?:ext)? 
+        ([+-])?(?:\s+(\S+))? 
+        \s*$/x
     end
 
     def execute
-      force = @match[1] == '+' || (@match[1].nil? && Command.settings[:force_stepping])
-      steps = get_int(@match[2], "Next", 1)
+      steps, force = parse_stepping_args("Next", @match)
       return unless steps
       @state.context.step_over steps, @state.frame_pos, force
       @state.proceed
@@ -21,23 +38,27 @@ module Debugger
 
       def help(cmd)
         %{
-          n[ext][+]?[ nnn]\tstep over once or nnn times, 
-          \t\t'+' forces to move to another line
+          n[ext][+-]?[ nnn]\tstep over once or nnn times, 
+          \t\t'+' forces to move to another line.
+          \t\t'-' is the opposite of '+' and disables the force_stepping setting.
         }
       end
     end
   end
 
-  class StepCommand < Command # :nodoc:
-    self.need_context = true
+  # Implements debugger "step" command.
+  class StepCommand < Command
+    self.allow_in_post_mortem = false
+    self.need_context         = true
     
     def regexp
-      /^\s*s(?:tep)?([+])?(?:\s+(.*))?$/
+      /^\s* s(?:tep)?
+        ([+-])?(?:\s+(\S+))?
+        \s*$/x
     end
 
     def execute
-      force = @match[1] == '+' || (@match[1].nil? && Command.settings[:force_stepping])
-      steps = get_int(@match[2], "Step", 1)
+      steps, force = parse_stepping_args("Step", @match)
       return unless steps
       @state.context.step(steps, force)
       @state.proceed
@@ -50,66 +71,9 @@ module Debugger
 
       def help(cmd)
         %{
-          s[tep][+]?[ nnn]\tstep (into methods) once or nnn times
-          \t\t'+' forces to move to another line
-        }
-      end
-    end
-  end
-
-  class FinishCommand < Command # :nodoc:
-    self.need_context = true
-    
-    def regexp
-      /^\s*fin(?:ish)?$/
-    end
-
-    def execute
-      if @state.frame_pos == @state.context.stack_size - 1
-        print "\"finish\" not meaningful in the outermost frame.\n"
-      else
-        @state.context.stop_frame = @state.frame_pos
-        @state.frame_pos = 0
-        @state.proceed
-      end
-    end
-
-    class << self
-      def help_command
-        'finish'
-      end
-
-      def help(cmd)
-        %{
-          fin[ish]\treturn to outer frame
-        }
-      end
-    end
-  end
-
-  class ContinueCommand < Command # :nodoc:
-    def regexp
-      /^\s*c(?:ont(?:inue)?)?(?:\s+(.*))?$/
-    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 or hits breakpoint or reaches line nnn 
+          s[tep][+-]?[ nnn]\tstep (into methods) once or nnn times
+          \t\t'+' forces to move to another line.
+          \t\t'-' is the opposite of '+' and disables the force_stepping setting.
         }
       end
     end

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

@@ -1,13 +1,13 @@
 module Debugger
   module ThreadFunctions # :nodoc:
-    def display_context(c)
+    def display_context(c, show_top_frame=true)
       c_flag = c.thread == Thread.current ? '+' : ' '
       c_flag = '$' if c.suspended?
       d_flag = c.ignored? ? '!' : ' '
       print "%s%s", c_flag, d_flag
       print "%d ", c.thnum
       print "%s\t", c.thread.inspect
-      if c.stack_size > 0
+      if c.stack_size > 0 and show_top_frame
         print "%s:%d", c.frame_file(0), c.frame_line(0)
       end
       print "\n"
@@ -15,28 +15,34 @@ module Debugger
     
     def parse_thread_num(subcmd, arg)
       if '' == arg
-        print "'thread %s' needs a thread number\n" % subcmd
+        errmsg "'%s' needs a thread number\n" % subcmd
+        nil
       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
+        get_context(thread_num)
+      end
+    end
+
+    def parse_thread_num_for_cmd(subcmd, arg)
+      c = parse_thread_num(subcmd, arg)
+      return nil unless c
+      case 
+      when nil == c
+        errmsg "No such thread.\n"
+      when @state.context == c
+        errmsg "It's the current thread.\n"
+      when c.ignored?
+        errmsg "Can't #{subcmd} to the debugger thread #{arg}.\n"
+      else # Everything is okay
+        return c
       end
       return nil
     end
   end
 
   class ThreadListCommand < Command # :nodoc:
-    self.control = true
+    self.allow_in_control = true
 
     def regexp
       /^\s*th(?:read)?\s+l(?:ist)?\s*$/
@@ -62,15 +68,16 @@ module Debugger
   end
 
   class ThreadStopCommand < Command # :nodoc:
-    self.control = true
-    self.need_context = true
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.need_context         = true
     
     def regexp
       /^\s*th(?:read)?\s+stop\s*(\S*)\s*$/
     end
 
     def execute
-      c = parse_thread_num("stop", @match[1])
+      c = parse_thread_num_for_cmd("thread stop", @match[1])
       return unless c 
       c.suspend
       display_context(c)
@@ -90,7 +97,8 @@ module Debugger
   end
 
   class ThreadResumeCommand < Command # :nodoc:
-    self.control = true
+    self.allow_in_post_mortem = false
+    self.allow_in_control = true
     self.need_context = true
     
     def regexp
@@ -98,7 +106,7 @@ module Debugger
     end
 
     def execute
-      c = parse_thread_num("resume", @match[1])
+      c = parse_thread_num_for_cmd("thread resume", @match[1])
       return unless c 
       if !c.thread.stop?
         print "Already running."
@@ -125,15 +133,16 @@ module Debugger
   # optional
 
   class ThreadSwitchCommand < Command # :nodoc:
-    self.control = true
-    self.need_context = true
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.need_context         = true
     
     def regexp
       /^\s*th(?:read)?\s*(?:sw(?:itch)?)?\s+(\S+)\s*$/
     end
 
     def execute
-      c = parse_thread_num("switch", @match[1])
+      c = parse_thread_num_for_cmd("thread switch", @match[1])
       return unless c 
       display_context(c)
       c.stop_next = 1

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

@@ -18,18 +18,46 @@ module Debugger
         print "%s = %s\n", v, s
       end
     end
+    def var_class_self
+      obj = debug_eval('self')
+      var_list(obj.class.class_variables, get_binding)
+    end
+  end
+
+  class VarClassVarCommand < Command # :nodoc:
+    def regexp
+      /^\s*v(?:ar)?\s+cl(?:ass)?/
+    end
+
+    def execute
+      unless @state.context
+        print "can't get class variables here.\n"
+        return 
+      end
+      var_class_self
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] cl[ass] \t\t\tshow class variables of self
+        }
+      end
+    end
   end
 
   class VarConstantCommand < Command # :nodoc:
     def regexp
-      /^\s*v(?:ar)?\s+c(?:onst(?:ant)?)?\s+/
+      /^\s*v(?:ar)?\s+co(?:nst(?:ant)?)?\s+/
     end
 
     def execute
       obj = debug_eval(@match.post_match)
-      unless obj.kind_of? Module
-        print "Should be Class/Module: %s\n", @match.post_match
-      else
+      if obj.kind_of? Module
         constants = debug_eval("#{@match.post_match}.constants")
         constants.sort!
         for c in constants
@@ -37,6 +65,8 @@ module Debugger
           value = obj.const_get(c) rescue "ERROR: #{$!}"
           print " %s => %p\n", c, value
         end
+      else
+        print "Should be Class/Module: %s\n", @match.post_match
       end
     end
 

data/cli/ruby-debug/helper.rb

@@ -1,81 +1,8 @@
 module Debugger
 
-  module ColumnizeFunctions
-    # Display a list of strings as a compact set of columns.
-    #
-    #  Each column is only as wide as necessary.
-    #  Columns are separated by two spaces (one was not legible enough).
-    #  Adapted from the routine of the same name in cmd.py
-    def columnize(list, displaywidth=80)
-      if not list.is_a?(Array)
-        return "Expecting an Array, got #{list.class}\n"
-      end
-      if list.size == 0
-        return  "<empty>\n"
-      end
-      nonstrings = []
-      for str in list do
-        nonstrings << str unless str.is_a?(String)
-      end
-      if nonstrings.size > 0
-        return "Nonstrings: %s\n" % nonstrings.map {|non| non.to_s}.join(', ')
-      end
-      if 1 == list.size
-        return "#{list[0]}\n"
-      end
-      # Try every row count from 1 upwards
-      nrows = ncols = 0
-      colwidths = []
-      1.upto(list.size) do 
-        colwidths = []
-        nrows += 1
-        ncols = (list.size + nrows-1) / nrows
-        totwidth = -2
-        # Debugger.debugger if nrows > 1
-        0.upto(ncols-1) do |col|
-          colwidth = 0
-          0.upto(nrows-1) do |row|
-            i = row + nrows*col
-            if i >= list.size
-              break
-            end
-            colwidth = [colwidth, list[i].size].max
-          end
-          colwidths << colwidth
-          totwidth += colwidth + 2
-          if totwidth > displaywidth
-            break
-          end
-        end
-        if totwidth <= displaywidth
-          break
-        end
-      end
-      s = ''
-      0.upto(nrows-1) do |row| 
-        texts = []
-        0.upto(ncols-1) do |col|
-          i = row + nrows*col
-          if i >= list.size
-            x = ""
-          else
-            x = list[i]
-          end
-          texts << x
-        end
-        while texts and texts[-1] == ''
-          texts = texts[0..-2]
-        end
-        0.upto(texts.size-1) do |col|
-          texts[col] = texts[col].ljust(colwidths[col])
-        end
-        s += "%s\n" % texts.join("  ")
-      end
-      return s
-    end
-  end
-
   module ParseFunctions
+    Position_regexp = '(?:(\d+)|(.+?)[:.#]([^.:\s]+))'
+
     # Parse 'str' of command 'cmd' as an integer between
     # min and max. If either min or max is nil, that
     # value has no bound.
@@ -130,5 +57,13 @@ module Debugger
       end
       return bool ? 'on' : 'off'
     end
+
+    # Return true if code is syntactically correct for Ruby.
+    def syntax_valid?(code)
+      eval("BEGIN {return true}\n#{code}", nil, "", 0)
+    rescue Exception
+      false
+    end 
+
   end
 end