ruby-debug 0.10.0 → 0.10.1

data/cli/ruby-debug/interface.rb

@@ -1,13 +1,43 @@
 module Debugger  
-  class LocalInterface # :nodoc:
+  class Interface # :nodoc:
+
+    # Common routine for reporting debugger error messages.
+    # Derived classed may want to override this to capture output.
+    def errmsg(*args)
+      if Debugger.annotate.to_i > 2
+        aprint 'error-begin'
+        print(*args)
+        aprint ''
+      else
+        print '*** '
+        print(*args)
+      end
+    end
+    
+    # Format msg with gdb-style annotation header
+    def afmt(msg, newline="\n")
+      "\032\032#{msg}#{newline}"
+    end
+
+    def aprint(msg)
+      print afmt(msg)
+    end
+
+  end
+
+  class LocalInterface < Interface # :nodoc:
+    attr_accessor :command_queue
     attr_accessor :histfile
     attr_accessor :history_save
     attr_accessor :history_length
+    attr_accessor :restart_file
 
     unless defined?(FILE_HISTORY)
       FILE_HISTORY = ".rdebug_hist"
     end
     def initialize()
+      super
+      @command_queue = []
       @history_save = true
       # take gdb's default
       @history_length = ENV["HISTSIZE"] ? ENV["HISTSIZE"].to_i : 256  
@@ -18,7 +48,8 @@ module Debugger
           line.chomp!
           Readline::HISTORY << line
         end
-      end if File.exists?(@histfile)
+      end if File.exist?(@histfile)
+      @restart_file = nil
     end
 
     def read_command(prompt)
@@ -35,24 +66,36 @@ module Debugger
     
     def close
     end
+
+    # Things to do before quitting
+    def finalize
+      if Debugger.method_defined?("annotate") and Debugger.annotate.to_i > 2
+        print "\032\032exited\n\n" 
+      end
+      if Debugger.respond_to?(:save_history)
+        Debugger.save_history 
+      end
+    end
     
     private
-    
     begin
       require 'readline'
       class << Debugger
         define_method(:save_history) do
-          @histfile ||= File.join(ENV["HOME"]||ENV["HOMEPATH"]||".", 
+          iface = self.handler.interface
+          iface.histfile ||= File.join(ENV["HOME"]||ENV["HOMEPATH"]||".", 
                                   FILE_HISTORY)
-          open(@histfile, 'w') do |file|
-            Readline::HISTORY.to_a.last(@history_length).each do |line|
+          open(iface.histfile, 'w') do |file|
+            Readline::HISTORY.to_a.last(iface.history_length).each do |line|
               file.puts line unless line.strip.empty?
-            end if @history_save
+            end if defined?(iface.history_save) and iface.history_save
           end rescue nil
         end
         public :save_history 
       end
-      Debugger.debug_at_exit { Debugger.save_history }
+      Debugger.debug_at_exit do 
+        finalize if respond_to?(:finalize)
+      end
       
       def readline(prompt, hist)
         Readline::readline(prompt, hist)
@@ -72,15 +115,29 @@ module Debugger
   end
 
   class RemoteInterface # :nodoc:
+    attr_accessor :command_queue
     attr_accessor :histfile
     attr_accessor :history_save
     attr_accessor :history_length
+    attr_accessor :restart_file
 
     def initialize(socket)
+      @command_queue = []
       @socket = socket
       @history_save = false
       @history_length = 256
       @histfile = ''
+      # Do we read the histfile?
+#       open(@histfile, 'r') do |file|
+#         file.each do |line|
+#           line.chomp!
+#           Readline::HISTORY << line
+#         end
+#       end if File.exist?(@histfile)
+      @restart_file = nil
+    end
+    
+    def finalize
     end
     
     def read_command(prompt)
@@ -110,11 +167,14 @@ module Debugger
     end
   end
   
-  class ScriptInterface # :nodoc:
+  class ScriptInterface < Interface # :nodoc:
+    attr_accessor :command_queue
     attr_accessor :histfile
     attr_accessor :history_save
     attr_accessor :history_length
     def initialize(file, out, verbose=false)
+      super()
+      @command_queue = []
       @file = file.respond_to?(:gets) ? file : open(file)
       @out = out
       @verbose = verbose
@@ -123,6 +183,9 @@ module Debugger
       @histfile = ''
     end
     
+    def finalize
+    end
+    
     def read_command(prompt)
       while result = @file.gets
         puts "# #{result}" if @verbose

data/cli/ruby-debug/processor.rb

@@ -3,16 +3,60 @@ require 'ruby-debug/command'
 
 module Debugger
 
-  annotate = 0
-  
-  class CommandProcessor # :nodoc:
+  # Should this be a mixin?
+  class Processor # :nodoc
     attr_accessor :interface
-    attr_reader   :display
+
+    # Format msg with gdb-style annotation header
+    def afmt(msg, newline="\n")
+      "\032\032#{msg}#{newline}"
+    end
     
-    @@Show_breakpoints_postcmd = ["break", "tbreak", "disable", "enable",
-                                  "condition", "clear", "delete"]
-    @@Show_annotations_preloop = ["step", "continue", "next", "finish"]
-    @@Show_annotations_postcmd = ["down", "frame", "up"]
+    def aprint(msg)
+      print afmt(msg) if Debugger.annotate.to_i > 2
+    end
+
+    # FIXME: use delegate? 
+    def errmsg(*args)
+      @interface.errmsg(*args)
+    end
+
+    # 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
+    
+  end
+
+  class CommandProcessor < Processor # :nodoc:
+    attr_reader   :display
+
+    # FIXME: get from Command regexp method.
+    @@Show_breakpoints_postcmd = [
+                                  /^\s*b(?:reak)?/, 
+                                  /^\s* cond(?:ition)? (?:\s+(\d+)\s*(.*))?$/ix,
+                                  /^\s*del(?:ete)?(?:\s+(.*))?$/ix,
+                                  /^\s* dis(?:able)? (?:\s+(.*))?$/ix,
+                                  /^\s* en(?:able)? (?:\s+(.*))?$/ix,
+                                  # "tbreak", "clear", 
+                                 ]
+    @@Show_annotations_run     = [
+                                  /^\s*c(?:ont(?:inue)?)?(?:\s+(.*))?$/,
+                                  /^\s*fin(?:ish)?$/,
+                                  /^\s*n(?:ext)?([+-])?(?:\s+(.*))?$/,
+                                  /^\s*s(?:tep)?([+-])?(?:\s+(.*))?$/
+                                ]
+
+    @@Show_annotations_postcmd = [
+                                  /^\s* down (?:\s+(.*))? .*$/x,
+                                  /^\s* f(?:rame)? (?:\s+ (.*))? \s*$/x,
+                                  /^\s* u(?:p)? (?:\s+(.*))?$/x
+                                 ]
     
     def initialize(interface = LocalInterface.new)
       @interface = interface
@@ -20,10 +64,11 @@ module Debugger
       
       @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
+      @debugger_breakpoints_were_empty = false # Show breakpoints 1st time
+      @debugger_displays_were_empty = true # No display 1st time
+      @debugger_context_was_dead = true # Assume we haven't started.
     end
     
     def interface=(interface)
@@ -50,8 +95,15 @@ module Debugger
     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)}"
+      file_line = "%s:%s\n%s" % [canonic_file(file), line, 
+                                 Debugger.line_at(file, line)]
+      # FIXME: use annotations routines
+      if Debugger.annotate.to_i > 2
+        file_line = "\032\032source #{file_line}"
+      elsif ENV['EMACS']
+        file_line = "\032\032#{file_line}"
+      end
+      print file_line
     end
   
     def self.protect(mname)
@@ -72,31 +124,23 @@ module Debugger
     end
     
     def at_breakpoint(context, breakpoint)
-      if @output_annotation_in_progress
-        print "\032\032\n"
-        @output_annotation_in_progress = false
-      end
-
+      aprint 'stopped' if Debugger.annotate.to_i > 2
       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
+      file = CommandProcessor.canonic_file(breakpoint.source)
+      line = breakpoint.pos
+      if Debugger.annotate.to_i > 2
+        print afmt("source #{file}:#{line}")
+      end
+      print "Breakpoint %d at %s:%s\n", n, file, line
     end
     protect :at_breakpoint
     
     def at_catchpoint(context, excpt)
-      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
+      aprint 'stopped' if Debugger.annotate.to_i > 2
+      file = CommandProcessor.canonic_file(context.frame_file(0))
+      line = context.frame_line(0)
+      print afmt("%s:%d" % [file, line]) if ENV['EMACS']
+      print "Catchpoint at %s:%d: `%s' (%s)\n", file, line, excpt, excpt.class
       fs = context.stack_size
       tb = caller(0)[-fs..-1]
       if tb
@@ -108,11 +152,8 @@ module Debugger
     protect :at_catchpoint
     
     def at_tracing(context, file, line)
-      if @output_annotation_in_progress
-        print "\032\032\n"
-        @output_annotation_in_progress = false
-      end
-
+      return if defined?(Debugger::RDEBUG_FILE) && 
+        Debugger::RDEBUG_FILE == file # Don't trace ourself
       @last_file = CommandProcessor.canonic_file(file)
       file = CommandProcessor.canonic_file(file)
       unless file == @last_file and @last_line == line and 
@@ -131,30 +172,33 @@ module Debugger
     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)
+    def at_return(context, file, line)
+      context.stop_frame = -1
+      process_commands(context, file, line)
     end
     
+    private
+
+    # The prompt shown before reading a command.
     def prompt(context)
-      if context.dead?
-        "(rdb:post-mortem) "
-      else
-        "(rdb:%d) " % context.thnum
-      end
+      p = '(rdb:%s) ' % (context.dead?  ? 'post-mortem' : context.thnum)
+      p = afmt("pre-prompt")+p+"\n"+afmt("prompt") if 
+        Debugger.annotate.to_i > 2
+      return p
     end
 
     # Run these commands, for example display commands or possibly
     # the list or irb in an "autolist" or "autoirb".
+    # We return a list of commands that are acceptable to run bound
+    # to the current state.
     def always_run(context, file, line, run_level)
       event_cmds = Command.commands.select{|cmd| cmd.event }
+
+      # Remove some commands in post-mortem
+      event_cmds = event_cmds.find_all do |cmd| 
+        cmd.allow_in_post_mortem
+      end if context.dead?
+
       state = State.new do |s|
         s.context = context
         s.file    = file
@@ -166,18 +210,17 @@ module Debugger
       end
       @interface.state = state if @interface.respond_to?('state=')
       
-      commands = event_cmds.map{|cmd| cmd.new(state) }
-      commands.select{|cmd| cmd.class.always_run >= run_level}.each{|cmd| cmd.execute }
+      # Bind commands to the current state.
+      commands = event_cmds.map{|cmd| cmd.new(state)}
+
+      commands.select do |cmd| 
+        cmd.class.always_run >= run_level
+      end.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|
@@ -195,10 +238,16 @@ 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))
+      while !state.proceed? 
+        input = if @interface.command_queue.empty?
+                  @interface.read_command(prompt(context))
+                else
+                  @interface.command_queue.shift
+                end
+        break unless input
         catch(:debug_error) do
           if input == ""
             next unless @last_cmd
@@ -212,11 +261,7 @@ module Debugger
           end
         end
       end
-
-      if Debugger.annotate and Debugger.annotate > 2
-        print "\032\032starting\n" 
-        @output_annotation_in_progress = true
-      end
+      postloop(commands, context)
     end # process_commands
     
     def one_cmd(commands, context, input)
@@ -236,56 +281,93 @@ module Debugger
       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
+    def preloop(commands, context)
+      aprint('stopped') if Debugger.annotate.to_i > 2
+      if context.dead?
+        unless @debugger_context_was_dead
+          if Debugger.annotate.to_i > 2
+            aprint('exited') 
+            print "The program finished.\n" 
+          end
+          @debugger_context_was_dead = true
+        end
       end
-    end
 
-    def preloop(commands, context)
-      if Debugger.annotate and Debugger.annotate > 0
+      if Debugger.annotate.to_i > 2
         # 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")
+        breakpoint_annotations(commands, context)
+        display_annotations(commands, context)
         annotation('stack', commands, context, "where")
-        annotation('variables', commands, context, "info variables")
-        annotation('display', commands, context, "display")
+        annotation('variables', commands, context, "info variables") unless
+          context.dead?
+      end
+    end
+    
+    def postcmd(commands, context, cmd)
+      if Debugger.annotate.to_i > 0
+        cmd = @last_cmd unless cmd
+        breakpoint_annotations(commands, context) if
+          @@Show_breakpoints_postcmd.find{|pat| cmd =~ pat}
+        display_annotations(commands, context)
+        if @@Show_annotations_postcmd.find{|pat| cmd =~ pat}
+          annotation('stack', commands, context, "where") if 
+            context.stack_size > 0
+          annotation('variables', commands, context, "info variables") unless
+            context.dead?
+        end
+        if not context.dead? and @@Show_annotations_run.find{|pat| cmd =~ pat}
+          aprint 'starting'  if Debugger.annotate.to_i > 2
+
+          @debugger_context_was_dead = false
+        end
       end
     end
 
+    def postloop(commands, context)
+    end
+
     def annotation(label, commands, context, cmd)
-      print "\032\032#{label}\n"
+      print afmt(label)
       one_cmd(commands, context, cmd)
+      ### FIXME ANNOTATE: the following line should be deleted
       print "\032\032\n"
     end
 
+    def breakpoint_annotations(commands, context)
+      unless Debugger.breakpoints.empty? and @debugger_breakpoints_were_empty
+        annotation('breakpoints', commands, context, "info breakpoints") 
+        @debugger_breakpoints_were_empty = Debugger.breakpoints.empty?
+      end
+    end
+
+    def display_annotations(commands, context)
+      return if display.empty?
+#       have_display = display.find{|d| d[0]} 
+#       return unless have_display and @debugger_displays_were_empty
+#       @debugger_displays_were_empty = have_display
+      annotation('display', commands, context, "display")
+    end
+
     class State # :nodoc:
       attr_accessor :context, :file, :line, :binding
       attr_accessor :frame_pos, :previous_line, :display
       attr_accessor :interface, :commands
 
       def initialize
+        super()
         @frame_pos = 0
         @previous_line = nil
         @proceed = false
         yield self
       end
 
+      # FIXME: use delegate? 
+      def errmsg(*args)
+        @interface.errmsg(*args)
+      end
+
       def print(*args)
         @interface.print(*args)
       end
@@ -304,21 +386,29 @@ module Debugger
     end
   end
   
-  class ControlCommandProcessor # :nodoc:
+  class ControlCommandProcessor < Processor # :nodoc:
     def initialize(interface)
+      super()
       @interface = interface
-    end
-    
-    def print(*args)
-      @interface.print(*args)
+      @debugger_context_was_dead = true # Assume we haven't started.
     end
     
     def process_commands
-      control_cmds = Command.commands.select{|cmd| cmd.control }
+      control_cmds = Command.commands.select do |cmd| 
+        cmd.allow_in_control 
+      end
       state = State.new(@interface, control_cmds)
       commands = control_cmds.map{|cmd| cmd.new(state) }
-      
-      while input = @interface.read_command("(rdb:ctrl) ")
+
+      unless @debugger_context_was_dead
+        if Debugger.annotate.to_i > 2
+          aprint 'exited'  
+          print "The program finished.\n" 
+        end
+        @debugger_context_was_dead = true
+      end
+
+      while input = @interface.read_command(prompt(nil))
         catch(:debug_error) do
           if cmd = commands.find{|c| c.match(input) }
             cmd.execute
@@ -334,7 +424,16 @@ module Debugger
     ensure
       @interface.close
     end
-    
+
+    # The prompt shown before reading a command.
+    # Note: have an unused 'context' parameter to match the local interface.
+    def prompt(context)
+      p = '(rdb:ctrl) '
+      p = afmt("pre-prompt")+p+"\n"+afmt("prompt") if 
+        Debugger.annotate.to_i > 2
+      return p
+    end
+
     class State # :nodoc:
       attr_reader :commands, :interface
       
@@ -346,6 +445,10 @@ module Debugger
       def proceed
       end
       
+      def errmsg(*args)
+        @interface.print(*args)
+      end
+      
       def print(*args)
         @interface.print(*args)
       end
@@ -362,6 +465,6 @@ module Debugger
         print "No filename given.\n"
         throw :debug_error
       end
-    end
+    end # State
   end
 end