ruby-debug 0.4.2-mswin32 → 0.4.3-mswin32

data/CHANGES

@@ -1,3 +1,7 @@
+0.4.3
+- Added Debugger.skip method which allows escaping a block from the debugger reach.
+- Bugfixes.
+
 0.4.2
 - Module#deubg_method added.
 - Added rdoc.

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/rdoctask'
 SO_NAME = "ruby_debug.so"
 
 # ------- Default Package ----------
-RUBY_DEBUG_VERSION = "0.4.2"
+RUBY_DEBUG_VERSION = "0.4.3"
 
 FILES = FileList[
   'Rakefile',

data/bin/rdebug

@@ -70,14 +70,16 @@ else
   trap('INT') { Debugger.interrupt_last }
   Debugger.stop_on_connect = !options.nostop
   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.debug_load ARGV.shift
   else
     Debugger.start
     if options.script
       Debugger.run_script(options.script)
     end
     debugger 2
+    Debugger.debug_load ARGV.shift
   end
-  load ARGV.shift
 end

data/ext/ruby_debug.c

@@ -4,7 +4,7 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.4.2"
+#define DEBUG_VERSION "0.4.3"
 
 typedef struct {
     int thnum;
@@ -39,6 +39,7 @@ static VALUE breakpoints = Qnil;
 static VALUE catchpoint  = Qnil;
 static VALUE waiting     = Qnil;
 static VALUE tracing     = Qfalse;
+static VALUE locker      = Qnil;
 
 static VALUE mDebugger;
 static VALUE cContext;
@@ -67,6 +68,64 @@ static VALUE debug_suspend(VALUE);
 static VALUE create_binding(VALUE);
 static VALUE debug_stop(VALUE);
 
+typedef struct locked_thread_t { 
+    VALUE thread;
+    struct locked_thread_t *next;
+} locked_thread_t;
+
+static locked_thread_t *locked_head = NULL;
+static locked_thread_t *locked_tail = NULL;
+
+static int
+is_in_locked(VALUE thread)
+{
+    locked_thread_t *node;
+    
+    if(!locked_head)
+        return 0;
+    
+    for(node = locked_head; node != locked_tail; node = node->next)
+    {
+        if(node->thread == thread) return 1;
+    }
+    return 0;
+}
+
+static void
+add_to_locked(VALUE thread)
+{
+    locked_thread_t *node;
+    
+    if(is_in_locked(thread))
+        return;
+
+    node = ALLOC(locked_thread_t);
+    node->thread = thread;
+    node->next = NULL;
+    if(locked_tail)
+        locked_tail->next = node;
+    locked_tail = node;
+    if(!locked_head)
+        locked_head = node;
+}
+
+static VALUE
+remove_from_locked()
+{
+    VALUE thread;
+    locked_thread_t *node;
+    
+    if(locked_head == NULL)
+        return Qnil;
+    node = locked_head;
+    locked_head = locked_head->next;
+    if(locked_tail == node)
+        locked_tail = NULL;
+    thread = node->thread;
+    xfree(node);
+    return thread;
+}
+
 #define IS_STARTED  (threads_tbl != Qnil)
 
 /*
@@ -359,15 +418,20 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     VALUE file = Qnil, line = Qnil;
     int breakpoint_index = -1;
     
-    static int debugging = 0;
-
     if (mid == ID_ALLOCATOR) return;
-    if(debugging) return;
     if(!node) return;
+    
+    thread = rb_thread_current();
+    while(locker != Qnil && locker != thread)
+    {
+        add_to_locked(thread);
+        rb_thread_stop();
+    }
+    
+    if(locker != Qnil) return;
 
-    debugging++;
+    locker = rb_thread_current();
 
-    thread = rb_thread_current();
     context = thread_context_lookup(thread);
     Data_Get_Struct(context, debug_context_t, debug_context);
     check_suspend(debug_context);
@@ -420,7 +484,9 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             {
                 breakpoint = get_breakpoint_at(breakpoint_index);
                 if(check_breakpoint_expression(breakpoint, binding))
+                {
                     rb_funcall(context, idAtBreakpoint, 1, breakpoint);
+                }
                 else
                     break;
             }
@@ -508,7 +574,10 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     }
     }
 
-    debugging--;
+    locker = Qnil;
+    thread = remove_from_locked();
+    if(thread != Qnil)
+        rb_thread_run(thread);
 }
 
 static VALUE
@@ -543,15 +612,12 @@ debug_start(VALUE self)
     threads_tbl = rb_hash_new();
     breakpoints = rb_ary_new();
     waiting     = rb_ary_new();
+    locker      = Qnil;
 
-    rb_add_event_hook(debug_event_hook, 
-        RUBY_EVENT_LINE | RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN |
-        RUBY_EVENT_CALL | RUBY_EVENT_RETURN | RUBY_EVENT_CLASS |
-        RUBY_EVENT_END | RUBY_EVENT_RAISE
-        );
+    rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL);
     
     if(rb_block_given_p())
-        return rb_ensure(rb_yield, Qnil, debug_stop_i, Qnil);
+        return rb_ensure(rb_yield, Qnil, debug_stop_i, self);
     
     return Qtrue;
 }
@@ -578,6 +644,7 @@ debug_stop(VALUE self)
     rb_remove_event_hook(debug_event_hook);
 
     waiting     = Qnil;
+    locker      = Qnil;
     breakpoints = Qnil;
     threads_tbl = Qnil;
 
@@ -799,7 +866,7 @@ debug_suspend(VALUE self)
     rb_thread_critical = saved_crit;
 
     if(rb_thread_critical == Qfalse)
-    rb_thread_schedule();
+        rb_thread_schedule();
 
     return self;
 }
@@ -837,8 +904,8 @@ debug_resume(VALUE self)
     }
     for(i = 0; i < RARRAY(waiting)->len; i++)
     {
-    thread = rb_ary_entry(waiting, i);
-    rb_thread_run(thread);
+        thread = rb_ary_entry(waiting, i);
+        rb_thread_run(thread);
     }
     rb_ary_clear(waiting);
     rb_thread_critical = saved_crit;
@@ -873,6 +940,94 @@ debug_set_tracing(VALUE self, VALUE value)
     return value;
 }
 
+/*
+ *   call-seq:
+ *      Debugger.debug_load(file) -> nil
+ *   
+ *   Same as Kernel#load but resets current context's frames. 
+ *   FOR INTERNAL USE ONLY.
+ */
+static VALUE
+debug_debug_load(VALUE self, VALUE file)
+{
+    VALUE context;
+    debug_context_t *debug_context;
+    
+    debug_start(self);
+    
+    context = debug_current_context(self);
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    rb_ary_clear(debug_context->frames);
+    rb_load(file, 0);
+    
+    debug_stop(self);
+    return Qnil;
+}
+
+static VALUE
+debug_skip_i(VALUE value)
+{
+    rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL);
+    return Qnil;
+}
+
+/*
+ *   call-seq:
+ *      Debugger.skip { block } -> obj or nil
+ *   
+ *   The code inside of the block is escaped from the debugger.
+ */
+static VALUE
+debug_skip(VALUE self)
+{
+    if (!rb_block_given_p()) {
+        rb_raise(rb_eArgError, "called without a block");
+    }
+    if(!IS_STARTED)
+        return rb_yield(Qnil);
+    rb_remove_event_hook(debug_event_hook);
+    return rb_ensure(rb_yield, Qnil, debug_skip_i, Qnil);
+}
+
+static VALUE
+debug_at_exit_c(VALUE proc)
+{
+    return rb_funcall(proc, rb_intern("call"), 0);
+}
+
+static void
+debug_at_exit_i(VALUE proc)
+{
+    if(!IS_STARTED)
+    {
+        debug_at_exit_c(proc);
+    }
+    else
+    {
+        rb_remove_event_hook(debug_event_hook);
+        rb_ensure(debug_at_exit_c, proc, debug_skip_i, Qnil);
+    }
+}
+
+/*
+ *   call-seq:
+ *      Debugger.debug_at_exit { block } -> proc
+ *   
+ *   Register <tt>at_exit</tt> hook which is escaped from the debugger.
+ *   FOR INTERNAL USE ONLY.
+ */
+static VALUE
+debug_at_exit(VALUE self)
+{
+    VALUE proc;
+    if (!rb_block_given_p()) {
+        rb_raise(rb_eArgError, "called without a block");
+    }
+    proc = rb_block_proc();
+    rb_set_end_proc(debug_at_exit_i, proc);
+    return proc;
+}
+
 /*
  *   call-seq:
  *      context.stop_next = steps
@@ -1259,6 +1414,9 @@ Init_ruby_debug()
     rb_define_module_function(mDebugger, "resume", debug_resume, 0);
     rb_define_module_function(mDebugger, "tracing", debug_tracing, 0);
     rb_define_module_function(mDebugger, "tracing=", debug_set_tracing, 1);
+    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);
     
     Init_context();
     Init_frame();
@@ -1282,6 +1440,7 @@ Init_ruby_debug()
     rb_global_variable(&breakpoints);
     rb_global_variable(&catchpoint);
     rb_global_variable(&waiting);
+    rb_global_variable(&locker);
     rb_global_variable(&file_separator);
     rb_global_variable(&alt_file_separator);
 }

data/lib/ruby-debug.rb

@@ -156,7 +156,6 @@ module Debugger
         end
       end
       socket.close
-      puts
     end
     
     def stop_main_thread # :nodoc:

data/lib/ruby-debug/interface.rb

@@ -19,25 +19,26 @@ module Debugger
     
     begin
       require 'readline'
-      FILE_HISTORY = ".rdebug_hist"
-      
-      save_file = File.join(Dir.getwd, FILE_HISTORY)
-      open(save_file, 'r') do |file|
-        file.each do |line|
-          line.chomp!
-          Readline::HISTORY << line
-        end
-      end if File.exists?(save_file)
-
-      class << Debugger; self end.send('define_method', 'save_history') do
-        open(save_file, 'w') do |file|
-          Readline::HISTORY.each do |line|
-            file.puts line unless line.strip.empty?
+      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|
+              file.puts line unless line.strip.empty?
+            end
           end
         end
+        public :save_history 
       end
-      class << Debugger; public :save_history end
-      at_exit { Debugger.save_history }
+      Debugger.debug_at_exit { Debugger.save_history }
       
       def readline(prompt, hist)
         Readline::readline(prompt, hist)
@@ -51,7 +52,6 @@ module Debugger
         line.chomp!
         line
       end
-      USE_READLINE = false
     end
   end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-debug
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
-date: 2006-09-15 10:57:34 -04:00
+  version: 0.4.3
+date: 2006-10-09 18:04:00 -04:00
 summary: Fast Ruby debugger
 require_paths: 
 - lib