ruby-debug 0.4.5-mswin32 → 0.5-mswin32

data/bin/rdebug

@@ -6,14 +6,15 @@ require "ostruct"
 require 'ruby-debug'
 
 options = OpenStruct.new(
-  'server' => false,
-  'client' => false,
-  'host'   => nil,
-  'port'   => Debugger::PORT,
-  'cport'  => Debugger::PORT + 1,
-  'wait'   => false,
-  'nostop' => false,
-  'script' => nil
+  'server'      => false,
+  'client'      => false,
+  'host'        => nil,
+  'port'        => Debugger::PORT,
+  'cport'       => Debugger::PORT + 1,
+  'wait'        => false,
+  'nostop'      => false,
+  'post_mortem' => false,
+  'script'      => nil
 )
 
 opts = OptionParser.new do |opts|
@@ -26,6 +27,7 @@ EOB
   opts.on("-s", "--server", "Listen for remote connections") {options.server = true}
   opts.on("-w", "--wait", "Wait for a client connection, implies -s option") {options.wait = true}
   opts.on("-n", "--nostop", "Do not stop when a client connects, implies -s option") {options.nostop = true}
+  opts.on("-m", "--post-mortem", "Activate post-mortem mode") {options.post_mortem = true}
   opts.on("-c", "--client", "Connect to remote debugger") {options.client = true}
   opts.on("-h", "--host HOST", "Host name used for remote debugging") {|options.host|}
   opts.on("-p", "--port PORT", Integer, "Port used for remote debugging") {|options.port|}
@@ -75,13 +77,14 @@ else
   Debugger.wait_connection = options.wait
   load "#{ENV["HOME"]}/.rdebugrc" if File.exists?("#{ENV["HOME"]}/.rdebugrc")
   if options.server
-    Debugger.start_remote(options.host, [options.port, options.cport])
+    Debugger.start_remote(options.host, [options.port, options.cport], options.post_mortem)
     Debugger.debug_load ARGV.shift
   else
     Debugger.start
     if options.script
       Debugger.run_script(options.script)
     end
+    Debugger.post_mortem if options.post_mortem
     debugger 2
     Debugger.debug_load ARGV.shift
   end

data/ext/ruby_debug.c

@@ -4,7 +4,7 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.4.5"
+#define DEBUG_VERSION "0.5"
 
 #define CTX_FL_MOVED        (1<<1)
 #define CTX_FL_SUSPEND      (1<<2)
@@ -57,6 +57,7 @@ static VALUE breakpoints = Qnil;
 static VALUE catchpoint  = Qnil;
 static VALUE tracing     = Qfalse;
 static VALUE locker      = Qnil;
+static VALUE post_mortem = Qfalse;
 
 static VALUE mDebugger;
 static VALUE cThreadsTable;
@@ -472,7 +473,8 @@ check_breakpoint_expression(VALUE breakpoint, VALUE binding)
 static void
 debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 {
-    VALUE thread, context, binding, breakpoint;
+    VALUE thread, context, breakpoint;
+    VALUE binding = Qnil;
     debug_context_t *debug_context;
     VALUE file = Qnil, line = Qnil;
     int breakpoint_index = -1;
@@ -621,6 +623,16 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         VALUE ancestors;
         VALUE expn_class, aclass;
         int i;
+        
+        if(post_mortem == Qtrue && self)
+        {
+            binding = create_binding(self);
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_binding"), binding);
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_file"), file);
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_line"), line);
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_binding"), binding);
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_frames"), rb_obj_dup(debug_context->frames));
+        }
 
         expn_class = rb_obj_class(ruby_errinfo);
         if( !NIL_P(rb_class_inherited_p(expn_class, rb_eSystemExit)) )
@@ -639,7 +651,8 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             if(rb_str_cmp(rb_mod_name(aclass), catchpoint) == 0)
             {
                 rb_funcall(context, idAtCatchpoint, 1, ruby_errinfo);
-                binding = self? create_binding(self) : Qnil;
+                if(self && binding == Qnil)
+                    binding = create_binding(self);
                 call_at_line(context, debug_context->thnum, binding, file, line);
                 break;
             }
@@ -703,7 +716,7 @@ debug_start(VALUE self)
     }
     
     if(rb_block_given_p())
-        return rb_ensure(rb_yield, Qnil, debug_stop_i, self);
+        return rb_ensure(rb_yield, self, debug_stop_i, self);
     return result;
 }
 
@@ -1002,7 +1015,7 @@ debug_resume(VALUE self)
  *   call-seq:
  *      Debugger.tracing -> bool
  *   
- *   Returns +true+ is a global tracing is activated.
+ *   Returns +true+ if the global tracing is activated.
  */
 static VALUE
 debug_tracing(VALUE self)
@@ -1014,7 +1027,7 @@ debug_tracing(VALUE self)
  *   call-seq:
  *      Debugger.tracing = bool
  *   
- *   Sets a global tracing flag.
+ *   Sets the global tracing flag.
  */
 static VALUE
 debug_set_tracing(VALUE self, VALUE value)
@@ -1023,12 +1036,40 @@ debug_set_tracing(VALUE self, VALUE value)
     return value;
 }
 
+/*
+ *   call-seq:
+ *      Debugger.post_mortem? -> bool
+ *   
+ *   Returns +true+ if post-moterm debugging is enabled.
+ */
+static VALUE
+debug_post_mortem(VALUE self)
+{
+    return post_mortem;
+}
+
+/*
+ *   call-seq:
+ *      Debugger.post_mortem = bool
+ *   
+ *   Sets post-moterm flag.
+ *   FOR INTERNAL USE ONLY.
+ */
+static VALUE
+debug_set_post_mortem(VALUE self, VALUE value)
+{
+    debug_check_started();
+
+    post_mortem = RTEST(value) ? Qtrue : Qfalse;
+    return value;
+}
+
 /*
  *   call-seq:
  *      Debugger.debug_load(file) -> nil
  *   
  *   Same as Kernel#load but resets current context's frames. 
- *   FOR INTERNAL USE ONLY.
+ *   FOR INTERNAL USE ONLY. Use Debugger.post_mortem method instead.
  */
 static VALUE
 debug_debug_load(VALUE self, VALUE file)
@@ -1556,6 +1597,8 @@ Init_ruby_debug()
     rb_define_module_function(mDebugger, "debug_load", debug_debug_load, 1);
     rb_define_module_function(mDebugger, "skip", debug_skip, 0);
     rb_define_module_function(mDebugger, "debug_at_exit", debug_at_exit, 0);
+    rb_define_module_function(mDebugger, "post_mortem?", debug_post_mortem, 0);
+    rb_define_module_function(mDebugger, "post_mortem=", debug_set_post_mortem, 1);
     
     cThreadsTable = rb_define_class_under(mDebugger, "ThreadsTable", rb_cObject);
     

data/lib/ruby-debug.rb

@@ -81,12 +81,13 @@ module Debugger
     #
     # Starts a remote debugger.
     #
-    def start_remote(host = nil, port = PORT)
+    def start_remote(host = nil, port = PORT, post_mortem = false)
       return if @thread
       return if started?
 
       self.interface = nil
       start
+      self.post_mortem if post_mortem
 
       require "socket"
       
@@ -169,21 +170,23 @@ module Debugger
     private :stop_main_thread
 
     def source_for(file) # :nodoc:
-      unless File.exists?(file)
-        return (source == true ? nil : source)
-      end
-      
-      if SCRIPT_LINES__[file].nil? || SCRIPT_LINES__[file] == true
-        SCRIPT_LINES__[file] = File.readlines(file)
-      end
-      
-      change_time = test(?M, file)
-      SCRIPT_TIMESTAMPS__[file] ||= change_time
-      if @reload_source_on_change && SCRIPT_TIMESTAMPS__[file] < change_time
-        SCRIPT_LINES__[file] = File.readlines(file)
+      Dir.chdir File.dirname($0) do
+        unless File.exists?(file)
+          return (SCRIPT_LINES__[file] == true ? nil : SCRIPT_LINES__[file])
+        end
+
+        if SCRIPT_LINES__[file].nil? || SCRIPT_LINES__[file] == true
+          SCRIPT_LINES__[file] = File.readlines(file)
+        end
+
+        change_time = test(?M, file)
+        SCRIPT_TIMESTAMPS__[file] ||= change_time
+        if @reload_source_on_change && SCRIPT_TIMESTAMPS__[file] < change_time
+          SCRIPT_LINES__[file] = File.readlines(file)
+        end
+
+        SCRIPT_LINES__[file]
       end
-      
-      SCRIPT_LINES__[file]
     end
     
     def source_reload
@@ -211,9 +214,58 @@ module Debugger
       processor = ControlCommandProcessor.new(interface)
       processor.process_commands
     end
+
+    #
+    # Activates the post-mortem mode. There are two ways of using it:
+    # 
+    # == Global post-mortem mode
+    # By calling Debugger.post_mortem method without a block, you install
+    # at_exit hook that intercepts any unhandled by your script exceptions
+    # and enables post-mortem mode.
+    #
+    # == Local post-mortem mode
+    #
+    # If you know that a particular block of code raises an exception you can
+    # enable post-mortem mode by wrapping this block with Debugger.post_mortem, e.g.
+    #
+    #   def offender
+    #      raise 'error'
+    #   end
+    #   Debugger.post_mortem do
+    #      ...
+    #      offender
+    #      ...
+    #   end
+    def post_mortem
+      raise "Post-mortem is already activated" if self.post_mortem?
+      self.post_mortem = true
+      if block_given?
+        begin
+          yield
+        rescue Exception => exp
+          handle_post_mortem(exp)
+          raise
+        ensure
+          self.post_mortem = false
+        end
+      else
+        debug_at_exit do
+          handle_post_mortem($!) if $! && post_mortem?
+        end
+      end
+    end
+    
+    def handle_post_mortem(exp)
+      processor.at_line(nil, exp.__debug_file, exp.__debug_line, exp.__debug_binding, exp.__debug_frames)
+    end
+    private :handle_post_mortem
   end
 end
 
+class Exception # :nodoc:
+  attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_frames
+end
+
 module Kernel
   #
   # Stops the current thread after a number of _steps_ made.

data/lib/ruby-debug/command.rb

@@ -10,6 +10,7 @@ module Debugger
         :control => false, 
         :always_run => false,
         :unknown => false,
+        :context => false,
       }
       
       def inherited(klass)

data/lib/ruby-debug/commands/control.rb

@@ -29,6 +29,7 @@ module Debugger
   class InterruptCommand < Command # :nodoc:
     self.event = false
     self.control = true
+    self.context = true
     
     def regexp
       /^\s*i(?:nterrupt)?\s*$/

data/lib/ruby-debug/commands/frame.rb

@@ -14,7 +14,7 @@ module Debugger
     end
 
     def execute
-      @state.context.frames.each_with_index do |frame, idx|
+      @state.frames.each_with_index do |frame, idx|
         if idx == @state.frame_pos
           print "--> "
         else
@@ -63,11 +63,11 @@ module Debugger
         @state.frame_pos += (arg ? arg.to_i : 1)
       end
       @state.frame_pos = 0 if @state.frame_pos < 0
-      if @state.frame_pos >= @state.context.frames.size
-        @state.frame_pos = @state.context.frames.size - 1
+      if @state.frame_pos >= @state.frames.size
+        @state.frame_pos = @state.frames.size - 1
         print "At toplevel\n"
       end
-      frame = @state.context.frames[@state.frame_pos]
+      frame = @state.frames[@state.frame_pos]
       @state.binding, @state.file, @state.line = frame.binding, frame.file, frame.line
       print format_frame(frame, @state.frame_pos)
     end
@@ -105,7 +105,7 @@ module Debugger
         @state.frame_pos = 0
         print "At stack bottom\n"
       end
-      frame = @state.context.frames[@state.frame_pos]
+      frame = @state.frames[@state.frame_pos]
       @state.binding, @state.file, @state.line = frame.binding, frame.file, frame.line
       print format_frame(frame, @state.frame_pos)
     end

data/lib/ruby-debug/commands/irb.rb

@@ -0,0 +1,50 @@
+require 'irb'
+module IRB # :nodoc:
+  def self.start_session(binding)
+    IRB.setup(nil)
+
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+#     trap("SIGINT") do
+#       irb.signal_handle
+#     end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+module Debugger
+  class IRBCommand < Command # :nodoc:
+    def regexp
+      /^irb$/
+    end
+    
+    def execute
+      unless @state.interface.kind_of?(LocalInterface)
+        print "Command is available only in local mode.\n"
+        return
+      end
+      IRB.start_session(@state.binding)
+    end
+  end
+  
+  class << self
+    def help_command
+      'irb'
+    end
+    
+    def help(cmd)
+      %{
+        irb\tstarts an IRB session. (EXPERIMENTAL)
+      }
+    end
+  end
+end
+

data/lib/ruby-debug/commands/list.rb

@@ -1,11 +1,11 @@
 module Debugger
   class ListCommand < Command # :nodoc:
     def regexp
-      /^\s*l(?:ist)?(?:\s*(.+))?$/
+      /^\s*l(?:ist)?(?:\s*([-=])|\s+(.+))?$/
     end
 
     def execute
-      if !@match || !@match[1]
+      if !@match || !(@match[1] || @match[2])
         b = @state.previous_line ? @state.previous_line + 10 : @state.line - 5
         e = b + 9
       elsif @match[1] == '-'
@@ -15,16 +15,16 @@ module Debugger
         @state.previous_line = nil
         b = @state.line - 5
         e = b + 9
-      elsif @match[1] == 'on'
+      elsif @match[2] == 'on'
         self.class.always_run = true
         print "Listing is on.\n"
         return
-      elsif @match[1] == 'off'
+      elsif @match[2] == 'off'
         self.class.always_run = false
         print "Listing is off.\n"
         return
       else
-        b, e = @match[1].split(/[-,]/)
+        b, e = @match[2].split(/[-,]/)
         if e
           b = b.to_i
           e = e.to_i

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

@@ -1,12 +1,14 @@
 module Debugger
   class NextCommand < Command # :nodoc:
+    self.context = true
+    
     def regexp
       /^\s*n(?:ext)?(?:\s+(\d+))?$/
     end
 
     def execute
       steps = @match[1] ? @match[1].to_i : 1
-      @state.context.step_over steps, @state.context.frames.size - @state.frame_pos
+      @state.context.step_over steps, @state.frames.size - @state.frame_pos
       @state.proceed
     end
 
@@ -24,6 +26,8 @@ module Debugger
   end
 
   class StepCommand < Command # :nodoc:
+    self.context = true
+    
     def regexp
       /^\s*s(?:tep)?(?:\s+(\d+))?$/
     end
@@ -47,15 +51,17 @@ module Debugger
   end
 
   class FinishCommand < Command # :nodoc:
+    self.context = true
+    
     def regexp
       /^\s*fin(?:ish)?$/
     end
 
     def execute
-      if @state.frame_pos == @state.context.frames.size
+      if @state.frame_pos == @state.frames.size
         print "\"finish\" not meaningful in the outermost frame.\n"
       else
-        @state.context.stop_frame = @state.context.frames.size - @state.frame_pos
+        @state.context.stop_frame = @state.frames.size - @state.frame_pos
         @state.frame_pos = 0
         @state.proceed
       end
@@ -76,7 +82,7 @@ module Debugger
 
   class ContinueCommand < Command # :nodoc:
     def regexp
-      /^\s*c(?:ont)?$|^\s*r(?:un)?$/
+      /^\s*c(?:ont)?$/
     end
 
     def execute
@@ -85,19 +91,13 @@ module Debugger
 
     class << self
       def help_command
-        %w|cont run|
+        'cont'
       end
 
       def help(cmd)
-        if cmd == 'cont'
-          %{
-            c[ont]\trun until program ends or hit breakpoint
-          }
-        else
-          %{
-            r[un]\talias for cont
-          }
-        end
+        %{
+          c[ont]\trun until program ends or hit breakpoint
+        }
       end
     end
   end

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

@@ -47,6 +47,8 @@ module Debugger
 
   class ThreadSwitchCommand < Command # :nodoc:
     self.control = true
+    self.context = true
+    
     include ThreadFunctions
 
     def regexp
@@ -83,6 +85,8 @@ module Debugger
 
   class ThreadStopCommand < Command # :nodoc:
     self.control = true
+    self.context = true
+    
     include ThreadFunctions
 
     def regexp
@@ -118,6 +122,8 @@ module Debugger
   end
 
   class ThreadCurrentCommand < Command # :nodoc:
+    self.context = true
+    
     include ThreadFunctions
 
     def regexp
@@ -143,6 +149,8 @@ module Debugger
 
   class ThreadResumeCommand < Command # :nodoc:
     self.control = true
+    self.context = true
+    
     include ThreadFunctions
 
     def regexp

data/lib/ruby-debug/commands/tmate.rb

@@ -8,11 +8,11 @@ module Debugger
       def execute
         if @match[1]
           frm_n = @match[1].to_i
-          if frm_n > @state.context.frames.size || frm_n == 0
+          if frm_n > @state.frames.size || frm_n == 0
             print "Wrong frame number\n"
             return
           end
-          frame = @state.context.frames[frm_n - 1]
+          frame = @state.frames[frm_n - 1]
           file, line = frame.file, frame.line
         else
           file, line = @state.file, @state.line

data/lib/ruby-debug/processor.rb

@@ -61,9 +61,9 @@ module Debugger
     end
     protect :at_tracing
 
-    def at_line(context, file, line, binding)
+    def at_line(context, file, line, binding, frames = context.frames)
       print "%s:%d: %s", file, line, Debugger.line_at(file, line)
-      process_commands(context, file, line, binding)
+      process_commands(context, file, line, binding, frames)
     end
     protect :at_line
 
@@ -73,7 +73,15 @@ module Debugger
       @interface.print(*args)
     end
     
-    def process_commands(context, file, line, binding)
+    def prompt(context)
+      if context
+        "(rdb:%d) " % context.thnum
+      else
+        "(rdb:post-mortem) "
+      end
+    end
+    
+    def process_commands(context, file, line, binding, frames)
       event_cmds = Command.commands.select{|cmd| cmd.event }
       state = State.new do |s|
         s.context = context
@@ -83,12 +91,14 @@ module Debugger
         s.display = display
         s.interface = interface
         s.commands = event_cmds
+        s.frames = frames
       end
       commands = event_cmds.map{|cmd| cmd.new(state) }
       commands.select{|cmd| cmd.class.always_run }.each{|cmd| cmd.execute }
       
-      while !state.proceed? and input = @interface.read_command("(rdb:%d) " % context.thnum)
+      while !state.proceed? and input = @interface.read_command(prompt(context))
         catch(:debug_error) do
+          
           if input == ""
             next unless @last_cmd
             input = @last_cmd
@@ -97,7 +107,11 @@ module Debugger
           end
           
           if cmd = commands.find{ |c| c.match(input) }
-            cmd.execute
+            if context.nil? && cmd.class.context
+              print "Command is unavailable\n"
+            else
+              cmd.execute
+            end
           else
             unknown_cmd = commands.find{|cmd| cmd.class.unknown }
             if unknown_cmd
@@ -113,7 +127,7 @@ module Debugger
     class State # :nodoc:
       attr_accessor :context, :file, :line, :binding
       attr_accessor :frame_pos, :previous_line, :display
-      attr_accessor :interface, :commands
+      attr_accessor :interface, :commands, :frames
 
       def initialize
         @frame_pos = 0

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-debug
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
-date: 2006-12-04 15:26:06 -05:00
+  version: "0.5"
+date: 2006-12-20 16:26:41 -05:00
 summary: Fast Ruby debugger
 require_paths: 
 - lib
@@ -46,6 +46,7 @@ files:
 - lib/ruby-debug/commands/eval.rb
 - lib/ruby-debug/commands/frame.rb
 - lib/ruby-debug/commands/help.rb
+- lib/ruby-debug/commands/irb.rb
 - lib/ruby-debug/commands/list.rb
 - lib/ruby-debug/commands/method.rb
 - lib/ruby-debug/commands/script.rb