ruby-debug 0.9.3 → 0.10.0

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

@@ -3,28 +3,24 @@ module Debugger
     def var_list(ary, b = get_binding)
       ary.sort!
       for v in ary
-        print "  %s => %s\n", v, debug_eval(v, b).inspect
-      end
-    end
-
-    def var_locals(locals)
-      locals.keys.sort.each do |name|
-        print "  %s => %s\n", name, locals[name]
-      end
-    end
-    
-    def var_consts(mod)
-      constants = mod.constants
-      constants.sort!
-      for c in constants
-        print " %s => %s\n", c, mod.const_get(c)
+        begin
+          s = debug_eval(v, b).inspect
+        rescue
+          begin
+            s = debug_eval(v, b).to_s
+          rescue
+            s = "*Error in evaluation*"
+          end
+        end
+        if s.size > self.class.settings[:width]
+          s[self.class.settings[:width]-3 .. -1] = "..."
+        end
+        print "%s = %s\n", v, s
       end
     end
   end
 
   class VarConstantCommand < Command # :nodoc:
-    include VarFunctions
-
     def regexp
       /^\s*v(?:ar)?\s+c(?:onst(?:ant)?)?\s+/
     end
@@ -34,7 +30,13 @@ module Debugger
       unless obj.kind_of? Module
         print "Should be Class/Module: %s\n", @match.post_match
       else
-        var_consts(obj)
+        constants = debug_eval("#{@match.post_match}.constants")
+        constants.sort!
+        for c in constants
+          next if c =~ /SCRIPT/
+          value = obj.const_get(c) rescue "ERROR: #{$!}"
+          print " %s => %p\n", c, value
+        end
       end
     end
 
@@ -52,8 +54,6 @@ module Debugger
   end
 
   class VarGlobalCommand < Command # :nodoc:
-    include VarFunctions
-
     def regexp
       /^\s*v(?:ar)?\s+g(?:lobal)?\s*$/
     end
@@ -76,14 +76,12 @@ module Debugger
   end
 
   class VarInstanceCommand < Command # :nodoc:
-    include VarFunctions
-
     def regexp
-      /^\s*v(?:ar)?\s+i(?:nstance)?\s+/
+      /^\s*v(?:ar)?\s+i(?:nstance)?\s*/
     end
 
     def execute
-      obj = debug_eval(@match.post_match)
+      obj = debug_eval(@match.post_match.empty? ? 'self' : @match.post_match)
       var_list(obj.instance_variables, obj.instance_eval{binding()})
     end
 
@@ -101,14 +99,16 @@ module Debugger
   end
 
   class VarLocalCommand < Command # :nodoc:
-    include VarFunctions
-
     def regexp
       /^\s*v(?:ar)?\s+l(?:ocal)?\s*$/
     end
 
     def execute
-      var_locals(@state.context.frame_locals(@state.frame_pos))
+      locals = @state.context.frame_locals(@state.frame_pos)
+      _self = @state.context.frame_self(@state.frame_pos) 
+      locals.keys.sort.each do |name|
+        print "  %s => %p\n", name, locals[name]
+      end
     end
 
     class << self

data/cli/ruby-debug/helper.rb

@@ -0,0 +1,134 @@
+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
+    # Parse 'str' of command 'cmd' as an integer between
+    # min and max. If either min or max is nil, that
+    # value has no bound.
+    def get_int(str, cmd, min=nil, max=nil, default=1)
+      return default unless str
+      begin
+        int = Integer(str)
+        if min and int < min
+          print "%s argument '%s' needs to at least %s.\n" % [cmd, str, min]
+          return nil
+        elsif max and int > max
+          print "%s argument '%s' needs to at most %s.\n" % [cmd, str, max]
+          return nil
+        end
+        return int
+      rescue
+        print "%s argument '%s' needs to be a number.\n" % [cmd, str]
+        return nil
+      end
+    end
+
+    # Return true if arg is 'on' or 1 and false arg is 'off' or 0.
+    # Any other value raises RuntimeError.
+    def get_onoff(arg, default=nil, print_error=true)
+      if arg.nil? or arg == ''
+        if default.nil?
+          if print_error
+            print "Expecting 'on', 1, 'off', or 0. Got nothing.\n"
+            raise RuntimeError
+          end
+          return default
+        end
+      end
+      case arg.downcase
+      when '1', 'on'
+        return true
+      when '0', 'off'
+        return false
+      else
+        if print_error
+          print "Expecting 'on', 1, 'off', or 0. Got: %s.\n" % arg.to_s
+          raise RuntimeError
+        end
+      end
+    end
+
+    # Return 'on' or 'off' for supplied parameter. The parmeter should
+    # be true, false or nil.
+    def show_onoff(bool)
+      if not [TrueClass, FalseClass, NilClass].member?(bool.class)
+        return "??"
+      end
+      return bool ? 'on' : 'off'
+    end
+  end
+end

data/cli/ruby-debug/interface.rb

@@ -1,5 +1,26 @@
 module Debugger  
   class LocalInterface # :nodoc:
+    attr_accessor :histfile
+    attr_accessor :history_save
+    attr_accessor :history_length
+
+    unless defined?(FILE_HISTORY)
+      FILE_HISTORY = ".rdebug_hist"
+    end
+    def initialize()
+      @history_save = true
+      # take gdb's default
+      @history_length = ENV["HISTSIZE"] ? ENV["HISTSIZE"].to_i : 256  
+      @histfile = File.join(ENV["HOME"]||ENV["HOMEPATH"]||".", 
+                            FILE_HISTORY)
+      open(@histfile, 'r') do |file|
+        file.each do |line|
+          line.chomp!
+          Readline::HISTORY << line
+        end
+      end if File.exists?(@histfile)
+    end
+
     def read_command(prompt)
       readline(prompt, true)
     end
@@ -20,20 +41,13 @@ module Debugger
     begin
       require 'readline'
       class << Debugger
-        FILE_HISTORY = ".rdebug_hist"
-        save_file = File.join(ENV["HOME"]||ENV["HOMEPATH"], FILE_HISTORY)
-        open(save_file, 'r') do |file|
-          file.each do |line|
-            line.chomp!
-            Readline::HISTORY << line
-          end
-        end if File.exists?(save_file)
-        
         define_method(:save_history) do
-          open(save_file, 'w') do |file|
-            Readline::HISTORY.to_a.last(500).each do |line|
+          @histfile ||= File.join(ENV["HOME"]||ENV["HOMEPATH"]||".", 
+                                  FILE_HISTORY)
+          open(@histfile, 'w') do |file|
+            Readline::HISTORY.to_a.last(@history_length).each do |line|
               file.puts line unless line.strip.empty?
-            end
+            end if @history_save
           end rescue nil
         end
         public :save_history 
@@ -45,6 +59,8 @@ module Debugger
       end
     rescue LoadError
       def readline(prompt, hist)
+        @histfile = ''
+        @hist_save = false
         STDOUT.print prompt
         STDOUT.flush
         line = STDIN.gets
@@ -56,8 +72,15 @@ module Debugger
   end
 
   class RemoteInterface # :nodoc:
+    attr_accessor :histfile
+    attr_accessor :history_save
+    attr_accessor :history_length
+
     def initialize(socket)
       @socket = socket
+      @history_save = false
+      @history_length = 256
+      @histfile = ''
     end
     
     def read_command(prompt)
@@ -88,19 +111,27 @@ module Debugger
   end
   
   class ScriptInterface # :nodoc:
-    def initialize(file, out)
+    attr_accessor :histfile
+    attr_accessor :history_save
+    attr_accessor :history_length
+    def initialize(file, out, verbose=false)
       @file = file.respond_to?(:gets) ? file : open(file)
       @out = out
+      @verbose = verbose
+      @history_save = false
+      @history_length = 256  # take gdb default
+      @histfile = ''
     end
     
     def read_command(prompt)
       while result = @file.gets
+        puts "# #{result}" if @verbose
         next if result =~ /^\s*#/
         next if result.strip.empty?
         break
       end
       raise IOError unless result
-      result
+      result.chomp!
     end
     
     def confirm(prompt)
@@ -108,7 +139,7 @@ module Debugger
     end
     
     def print(*args)
-      @out.print(*args)
+      @out.printf(*args)
     end
     
     def close

data/cli/ruby-debug/processor.rb

@@ -2,16 +2,28 @@ require 'ruby-debug/interface'
 require 'ruby-debug/command'
 
 module Debugger
+
+  annotate = 0
+  
   class CommandProcessor # :nodoc:
     attr_accessor :interface
     attr_reader   :display
     
+    @@Show_breakpoints_postcmd = ["break", "tbreak", "disable", "enable",
+                                  "condition", "clear", "delete"]
+    @@Show_annotations_preloop = ["step", "continue", "next", "finish"]
+    @@Show_annotations_postcmd = ["down", "frame", "up"]
+    
     def initialize(interface = LocalInterface.new)
       @interface = interface
       @display = []
+      
       @mutex = Mutex.new
       @last_cmd = nil
       @actions = []
+      @last_file = nil   # Filename the last time we stopped
+      @last_line = nil   # line number the last time we stopped
+      @output_annotation_in_progress = false
     end
     
     def interface=(interface)
@@ -21,6 +33,27 @@ module Debugger
       end
     end
     
+    require 'pathname'  # For cleanpath
+    
+    # Regularize file name. 
+    # This is also used as a common funnel place if basename is 
+    # desired or if we are working remotely and want to change the 
+    # basename. Or we are eliding filenames.
+    def self.canonic_file(filename)
+      # For now we want resolved filenames 
+      if Command.settings[:basename]
+        File.basename(filename)
+      else
+        # Cache this?
+        Pathname.new(filename).cleanpath.to_s
+      end
+    end
+
+    def self.print_location_and_text(file, line)
+      print "#{"\032\032" if ENV['EMACS']}#{canonic_file(file)}:#{line}\n" +
+        "#{Debugger.line_at(file, line)}"
+    end
+  
     def self.protect(mname)
       alias_method "__#{mname}", mname
       module_eval %{
@@ -39,13 +72,31 @@ module Debugger
     end
     
     def at_breakpoint(context, breakpoint)
+      if @output_annotation_in_progress
+        print "\032\032\n"
+        @output_annotation_in_progress = false
+      end
+
       n = Debugger.breakpoints.index(breakpoint) + 1
+      print("\032\032%s:%s\n", 
+            CommandProcessor.canonic_file(breakpoint.source), 
+            breakpoint.pos) if ENV['EMACS']
       print "Breakpoint %d at %s:%s\n", n, breakpoint.source, breakpoint.pos
     end
     protect :at_breakpoint
     
     def at_catchpoint(context, excpt)
-      print "Catchpoint at %s:%d: `%s' (%s)\n", context.frame_file(1), context.frame_line(1), excpt, excpt.class
+      if @output_annotation_in_progress
+        print "\032\032\n"
+        @output_annotation_in_progress = false
+      end
+
+      print "\032\032%s:%d\n", 
+      CommandProcessor.canonic_file(context.frame_file(1)), 
+      context.frame_line(1) if ENV['EMACS']
+      print "Catchpoint at %s:%d: `%s' (%s)\n", 
+      CommandProcessor.canonic_file(context.frame_file(1)), 
+      context.frame_line(1), excpt, excpt.class
       fs = context.stack_size
       tb = caller(0)[-fs..-1]
       if tb
@@ -57,18 +108,37 @@ module Debugger
     protect :at_catchpoint
     
     def at_tracing(context, file, line)
-      print "Tracing(%d):%s:%s %s", context.thnum, file, line, Debugger.line_at(file, line)
+      if @output_annotation_in_progress
+        print "\032\032\n"
+        @output_annotation_in_progress = false
+      end
+
+      @last_file = CommandProcessor.canonic_file(file)
+      file = CommandProcessor.canonic_file(file)
+      unless file == @last_file and @last_line == line and 
+          Command.settings[:tracing_plus]
+        print "Tracing(%d):%s:%s %s",
+        context.thnum, file, line, Debugger.line_at(file, line)
+        @last_file = file
+        @last_line = line
+      end
+      always_run(context, file, line, 2)
     end
     protect :at_tracing
 
     def at_line(context, file, line)
-      print "#{"\032\032" if ENV['EMACS']}%s:%d %s", file, line, Debugger.line_at(file, line)
       process_commands(context, file, line)
     end
     protect :at_line
     
     private
-    
+
+    # Callers of this routine should make sure to use comma to
+    # separate format argments rather than %. Otherwise it seems that
+    # if the string you want to print has format specifier, which
+    # could happen if you are trying to show say a source-code line
+    # with "puts" or "print" in it, this print routine will give an
+    # error saying it is looking for more arguments.
     def print(*args)
       @interface.print(*args)
     end
@@ -80,8 +150,10 @@ module Debugger
         "(rdb:%d) " % context.thnum
       end
     end
-    
-    def process_commands(context, file, line)
+
+    # Run these commands, for example display commands or possibly
+    # the list or irb in an "autolist" or "autoirb".
+    def always_run(context, file, line, run_level)
       event_cmds = Command.commands.select{|cmd| cmd.event }
       state = State.new do |s|
         s.context = context
@@ -95,7 +167,18 @@ module Debugger
       @interface.state = state if @interface.respond_to?('state=')
       
       commands = event_cmds.map{|cmd| cmd.new(state) }
-      commands.select{|cmd| cmd.class.always_run }.each{|cmd| cmd.execute }
+      commands.select{|cmd| cmd.class.always_run >= run_level}.each{|cmd| cmd.execute }
+      return state, commands
+    end
+
+    # Handle debugger commands
+    def process_commands(context, file, line)
+      if @output_annotation_in_progress
+        print "\032\032\n"
+        @output_annotation_in_progress = false
+      end
+
+      state, commands = always_run(context, file, line, 1)
       
       splitter = lambda do |str|
         str.split(/;/).inject([]) do |m, v|
@@ -112,35 +195,83 @@ module Debugger
           m
         end
       end
-      
+
+      preloop(commands, context)
+      CommandProcessor.print_location_and_text(file, line)
       while !state.proceed? and input = @interface.read_command(prompt(context))
         catch(:debug_error) do
-          
           if input == ""
             next unless @last_cmd
             input = @last_cmd
           else
             @last_cmd = input
           end
-          
-          splitter[input].each do |input|
-            if cmd = commands.find{ |c| c.match(input) }
-              if context.dead? && cmd.class.need_context
-                print "Command is unavailable\n"
-              else
-                cmd.execute
-              end
-            else
-              unknown_cmd = commands.find{|cmd| cmd.class.unknown }
-              if unknown_cmd
-                unknown_cmd.execute
-              else
-                print "Unknown command\n"
-              end
-            end
+          splitter[input].each do |cmd|
+            one_cmd(commands, context, cmd)
+            postcmd(commands, context, cmd)
           end
         end
       end
+
+      if Debugger.annotate and Debugger.annotate > 2
+        print "\032\032starting\n" 
+        @output_annotation_in_progress = true
+      end
+    end # process_commands
+    
+    def one_cmd(commands, context, input)
+      if cmd = commands.find{ |c| c.match(input) }
+        if context.dead? && cmd.class.need_context
+          print "Command is unavailable\n"
+        else
+          cmd.execute
+        end
+      else
+        unknown_cmd = commands.find{|cmd| cmd.class.unknown }
+        if unknown_cmd
+            unknown_cmd.execute
+        else
+          print "Unknown command\n"
+        end
+      end
+    end
+    
+    def postcmd(commands, context, cmd)
+      if Debugger.annotate and Debugger.annotate > 0
+        # FIXME: need to cannonicalize command names 
+        # e.g. b vs. break
+        # and break out the command name "break 10"
+        # until then we'll refresh always
+        # cmd = @last_cmd unless cmd
+        #if @@Show_breakpoints_postcmd.member?(cmd)
+        annotation('breakpoints', commands, context, "info breakpoints") unless
+          Debugger.breakpoints.empty?
+        annotation('display', commands, context, "display")
+        # end
+        # if @@Show_annotations_postcmd.member?(cmd)
+        annotation('stack', commands, context, "where") if 
+          context.stack_size > 0
+          annotation('variables', commands, context, "info variables")
+        # end
+      end
+    end
+
+    def preloop(commands, context)
+      if Debugger.annotate and Debugger.annotate > 0
+        # if we are here, the stack frames have changed outside the
+        # command loop (e.g. after a "continue" command), so we show
+        # the annotations again
+        annotation('breakpoints', commands, context, "info breakpoints")
+        annotation('stack', commands, context, "where")
+        annotation('variables', commands, context, "info variables")
+        annotation('display', commands, context, "display")
+      end
+    end
+
+    def annotation(label, commands, context, cmd)
+      print "\032\032#{label}\n"
+      one_cmd(commands, context, cmd)
+      print "\032\032\n"
     end
 
     class State # :nodoc: