ruby-debug 0.4.3 → 0.4.4

data/CHANGES

@@ -1,3 +1,8 @@
+0.4.4
+- Renamed Context#set_suspend and Context#clear_suspend methods to Context#suspend and Context#resume respectively.
+- Context#resume method not only clears suspend flag, but also resumes the thread execution.
+- Bugfixes.
+
 0.4.3
 - Added Debugger.skip method which allows escaping a block from the debugger reach.
 - Bugfixes.

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/rdoctask'
 SO_NAME = "ruby_debug.so"
 
 # ------- Default Package ----------
-RUBY_DEBUG_VERSION = "0.4.3"
+RUBY_DEBUG_VERSION = open("ext/ruby_debug.c"){|f| f.grep(/^#define DEBUG_VERSION/).first[/"(.+)"/,1]}
 
 FILES = FileList[
   'Rakefile',

data/bin/rdebug

@@ -29,6 +29,9 @@ EOB
   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|}
+  opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
+    $LOAD_PATH.unshift(path)
+  end
   opts.on("--script FILE", String, "Name of the script file to run") do |options.script| 
     unless File.exists?(options.script)
       puts "Script file '#{options.script}' is not found"

data/ext/ruby_debug.c

@@ -4,21 +4,35 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.4.3"
+#define DEBUG_VERSION "0.4.4"
+
+#define CTX_FL_MOVED        (1<<1)
+#define CTX_FL_SUSPEND      (1<<2)
+#define CTX_FL_TRACING      (1<<3)
+#define CTX_FL_SKIPPED      (1<<4)
+#define CTX_FL_IGNORE       (1<<5)
+
+#define CTX_FL_TEST(c,f) ((c)->flags & (f))
+#define CTX_FL_SET(c,f) do { (c)->flags |= (f); } while (0)
+#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
+
+#define DID_MOVED   (debug_context->last_line != line || \
+                          debug_context->last_file == Qnil || \
+                          rb_str_cmp(debug_context->last_file, file) != 0)
+
+#define IS_STARTED  (threads_tbl != Qnil)
 
 typedef struct {
     int thnum;
-    VALUE last_file;
-    VALUE last_line;
-    int moved;
+    int flags;
     int stop_next;
     int dest_frame;
     int stop_line;
     int stop_frame;
-    int suspend;
-    int tracing;
     VALUE frames;
     VALUE thread;
+    VALUE last_file;
+    VALUE last_line;
 } debug_context_t;
 
 typedef struct {
@@ -34,14 +48,18 @@ typedef struct {
     VALUE expr;
 } debug_breakpoint_t;
 
+typedef struct {
+    st_table *tbl;
+} threads_table_t;
+
 static VALUE threads_tbl = Qnil;
 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 cThreadsTable;
 static VALUE cContext;
 static VALUE cFrame;
 static VALUE cBreakpoint;
@@ -64,7 +82,6 @@ static int start_count = 0;
 static int thnum_max = 0;
 static int last_debugged_thnum = -1;
 
-static VALUE debug_suspend(VALUE);
 static VALUE create_binding(VALUE);
 static VALUE debug_stop(VALUE);
 
@@ -126,7 +143,72 @@ remove_from_locked()
     return thread;
 }
 
-#define IS_STARTED  (threads_tbl != Qnil)
+static int
+thread_hash(VALUE thread)
+{
+    return (int)FIX2LONG(rb_obj_id(thread));
+}
+
+static int
+thread_cmp(VALUE a, VALUE b)
+{
+    if(a == b) return 0;
+    if(a < b) return -1;
+    return 1;
+}
+
+static struct st_hash_type st_thread_hash = {
+    thread_cmp,
+    thread_hash
+};
+
+static int
+threads_table_mark_keyvalue(VALUE key, VALUE value, int dummy)
+{
+    rb_gc_mark(key);
+    rb_gc_mark(value);
+    return ST_CONTINUE;
+}
+
+static void
+threads_table_mark(void* data)
+{
+    threads_table_t *threads_table = (threads_table_t*)data;
+    st_foreach(threads_table->tbl, threads_table_mark_keyvalue, 0);
+}
+
+static void
+threads_table_free(void* data)
+{
+    threads_table_t *threads_table = (threads_table_t*)data;
+    st_free_table(threads_table->tbl);
+    xfree(threads_table);
+}
+
+static VALUE
+threads_table_create()
+{
+    threads_table_t *threads_table;
+    
+    threads_table = ALLOC(threads_table_t);
+    threads_table->tbl = st_init_table(&st_thread_hash);
+    return Data_Wrap_Struct(cThreadsTable, threads_table_mark, threads_table_free, threads_table);
+}
+
+static int
+threads_table_clear_i(VALUE key, VALUE value, VALUE dummy)
+{
+    return ST_DELETE;
+}
+
+static void
+threads_table_clear(VALUE table)
+{
+    threads_table_t *threads_table;
+    
+    Data_Get_Struct(table, threads_table_t, threads_table);
+    st_foreach(threads_table->tbl, threads_table_clear_i, 0);
+}
 
 /*
  *   call-seq:
@@ -170,14 +252,12 @@ debug_context_create(VALUE thread)
     
     debug_context->last_file = Qnil;
     debug_context->last_line = Qnil;
-    debug_context->moved = 0;
+    debug_context->flags = 0;
 
     debug_context->stop_next = -1;
     debug_context->dest_frame = -1;
     debug_context->stop_line = -1;
     debug_context->stop_frame = -1;
-    debug_context->suspend = 0;
-    debug_context->tracing = 0;
     debug_context->frames = rb_ary_new();
     debug_context->thread = thread;
     result = Data_Wrap_Struct(cContext, debug_context_mark, xfree, debug_context);
@@ -188,14 +268,15 @@ static VALUE
 thread_context_lookup(VALUE thread)
 {
     VALUE context;
+    threads_table_t *threads_table;
 
     debug_check_started();
 
-    context = rb_hash_aref(threads_tbl, thread);
-    if(context == Qnil)
+    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    if(!st_lookup(threads_table->tbl, thread, &context))
     {
-    context = debug_context_create(thread);
-    rb_hash_aset(threads_tbl, thread, context);
+        context = debug_context_create(thread);
+        st_insert(threads_table->tbl, thread, context);
     }
     return context;
 }
@@ -241,13 +322,9 @@ save_current_position(VALUE context)
     
     debug_context->last_file = debug_frame->file;
     debug_context->last_line = debug_frame->line;
-    debug_context->moved = 0;
+    CTX_FL_UNSET(debug_context, CTX_FL_MOVED);
 }
 
-#define did_moved()   (debug_context->last_line != line || \
-                          debug_context->last_file == Qnil || \
-                          rb_str_cmp(debug_context->last_file, file) != 0)
-
 static VALUE
 call_at_line_unprotected(VALUE args)
 {
@@ -263,7 +340,6 @@ call_at_line(VALUE context, int thnum, VALUE binding, VALUE file, VALUE line)
     
     last_debugged_thnum = thnum;
     save_current_position(context);
-    debug_suspend(mDebugger);
     
     args = rb_ary_new3(4, context, file, line, binding);
     return rb_protect(call_at_line_unprotected, args, 0);
@@ -330,7 +406,7 @@ check_breakpoints(debug_context_t *debug_context, VALUE file, VALUE klass, VALUE
 
     if(RARRAY(breakpoints)->len == 0)
         return -1;
-    if(!debug_context->moved)
+    if(!CTX_FL_TEST(debug_context, CTX_FL_MOVED))
         return -1;
     
     for(i = 0; i < RARRAY(breakpoints)->len; i++)
@@ -366,23 +442,6 @@ create_binding(VALUE self)
     return f_binding(self);
 }
 
-static void
-check_suspend(debug_context_t *debug_context)
-{
-    if(rb_thread_critical == Qtrue)
-        return;
-    while(1)
-    {
-        rb_thread_critical = Qtrue;
-        if(!debug_context->suspend)
-            break;
-        rb_ary_push(waiting, rb_thread_current());
-        debug_context->suspend = 0;
-        rb_thread_stop();
-    }
-    rb_thread_critical = Qfalse;
-}
-
 static VALUE
 get_breakpoint_at(int index) 
 {
@@ -422,25 +481,45 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     if(!node) return;
     
     thread = rb_thread_current();
-    while(locker != Qnil && locker != thread)
+    context = thread_context_lookup(thread);
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    
+    /* return if thread is marked as 'ignored'.
+       debugger's threads are marked this way
+    */
+    if(CTX_FL_TEST(debug_context, CTX_FL_IGNORE)) return;
+    
+    while(1)
     {
-        add_to_locked(thread);
-        rb_thread_stop();
+        /* halt execution of the current thread if the debugger
+           is activated in another
+        */
+        while(locker != Qnil && locker != thread)
+        {
+            add_to_locked(thread);
+            rb_thread_stop();
+        }
+
+        /* stop the current thread if it's marked as suspended */
+        if(CTX_FL_TEST(debug_context, CTX_FL_SUSPEND))
+            rb_thread_stop();
+        else break;
     }
     
+    /* return if the current thread is the locker */
     if(locker != Qnil) return;
+    
+    /* only the current thread can proceed */
+    locker = thread;
 
-    locker = rb_thread_current();
-
-    context = thread_context_lookup(thread);
-    Data_Get_Struct(context, debug_context_t, debug_context);
-    check_suspend(debug_context);
+    /* ignore a skipped section of code */
+    if(CTX_FL_TEST(debug_context, CTX_FL_SKIPPED)) goto cleanup;
 
     file = rb_str_new2(node->nd_file);
     line = INT2FIX(nd_line(node));
 
-    if(did_moved())
-        debug_context->moved  = 1;
+    if(DID_MOVED)
+        CTX_FL_SET(debug_context, CTX_FL_MOVED);
 
     switch(event)
     {
@@ -448,7 +527,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     {
         set_frame_source(debug_context, file, line);
 
-        if(RTEST(tracing) || debug_context->tracing )
+        if(RTEST(tracing) || CTX_FL_TEST(debug_context, CTX_FL_TRACING))
         {
             rb_funcall(context, idAtTracing, 2, file, line);
         }
@@ -460,7 +539,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             if(debug_context->stop_next < 0)
                 debug_context->stop_next = -1;
             /* we check that we actualy moved to another line */
-            if(did_moved())
+            if(DID_MOVED)
             {
                 debug_context->stop_line--;
             }
@@ -574,17 +653,21 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     }
     }
 
+    cleanup:
+    
+    /* release a lock */
     locker = Qnil;
+    /* let the next thread to run */
     thread = remove_from_locked();
     if(thread != Qnil)
         rb_thread_run(thread);
 }
 
 static VALUE
-debug_stop_i(VALUE value)
+debug_stop_i(VALUE self)
 {
     if(IS_STARTED)
-        debug_stop(value);
+        debug_stop(self);
     return Qnil;
 }
 
@@ -595,8 +678,8 @@ debug_stop_i(VALUE value)
  *   
  *   This method activates the debugger. 
  *   If it's called without a block it returns +true+, unless debugger was already started.
- *   If a block is given, it starts debugger and yields to block. At the end of stops the debugger
- *   with Debugger.stop method.
+ *   If a block is given, it starts debugger and yields to block. When the block is finished
+ *   executing it stops the debugger with Debugger.stop method.
  *
  *   <i>Note that if you want to stop debugger, you must call Debugger.stop as many time as you 
  *   called Debugger.start method.</i>
@@ -604,22 +687,24 @@ debug_stop_i(VALUE value)
 static VALUE
 debug_start(VALUE self)
 {
+    VALUE result;
     start_count++;
     
     if(IS_STARTED)
-        return Qfalse;
-        
-    threads_tbl = rb_hash_new();
-    breakpoints = rb_ary_new();
-    waiting     = rb_ary_new();
-    locker      = Qnil;
+        result = Qfalse;
+    else
+    {
+        breakpoints = rb_ary_new();
+        locker      = Qnil;
+        threads_tbl = threads_table_create();
 
-    rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL);
+        rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL);
+        result = Qtrue;
+    }
     
     if(rb_block_given_p())
         return rb_ensure(rb_yield, Qnil, debug_stop_i, self);
-    
-    return Qtrue;
+    return result;
 }
 
 /*
@@ -643,7 +728,6 @@ debug_stop(VALUE self)
     
     rb_remove_event_hook(debug_event_hook);
 
-    waiting     = Qnil;
     locker      = Qnil;
     breakpoints = Qnil;
     threads_tbl = Qnil;
@@ -767,10 +851,13 @@ static VALUE
 debug_last_interrupted(VALUE self)
 {
     VALUE result = Qnil;
+    threads_table_t *threads_table;
 
     debug_check_started();
 
-    rb_hash_foreach(threads_tbl, find_last_context_func, (st_data_t)&result);
+    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    
+    st_foreach(threads_table->tbl, find_last_context_func, (st_data_t)&result);
     return result;
 }
 
@@ -806,6 +893,7 @@ debug_contexts(VALUE self)
     volatile VALUE list;
     volatile VALUE new_list;
     VALUE thread, context;
+    threads_table_t *threads_table;
     debug_context_t *debug_context;
     int i;
 
@@ -819,15 +907,13 @@ debug_contexts(VALUE self)
         context = thread_context_lookup(thread);
         rb_ary_push(new_list, context);
     }
-    /*
-     * I wonder why rb_hash_clear is declared static?
-     */
-    rb_funcall(threads_tbl, idClear, 0);
+    threads_table_clear(threads_tbl);
+    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
     for(i = 0; i < RARRAY(new_list)->len; i++)
     {
         context = rb_ary_entry(new_list, i);
         Data_Get_Struct(context, debug_context_t, debug_context);
-        rb_hash_aset(threads_tbl, debug_context->thread, context);
+        st_insert(threads_table->tbl, debug_context->thread, context);
     }
 
     return new_list;
@@ -861,7 +947,7 @@ debug_suspend(VALUE self)
         if(current == context)
             continue;
         Data_Get_Struct(context, debug_context_t, debug_context);
-        debug_context->suspend = 1;
+        CTX_FL_SET(debug_context, CTX_FL_SUSPEND);
     }
     rb_thread_critical = saved_crit;
 
@@ -882,7 +968,6 @@ debug_resume(VALUE self)
 {
     VALUE current, context;
     VALUE saved_crit;
-    VALUE thread;
     VALUE context_list;
     debug_context_t *debug_context;
     int i;
@@ -900,14 +985,12 @@ debug_resume(VALUE self)
         if(current == context)
             continue;
         Data_Get_Struct(context, debug_context_t, debug_context);
-        debug_context->suspend = 0;
-    }
-    for(i = 0; i < RARRAY(waiting)->len; i++)
-    {
-        thread = rb_ary_entry(waiting, i);
-        rb_thread_run(thread);
+        if(CTX_FL_TEST(debug_context, CTX_FL_SUSPEND))
+        {
+            CTX_FL_UNSET(debug_context, CTX_FL_SUSPEND);
+            rb_thread_run(debug_context->thread);
+        }
     }
-    rb_ary_clear(waiting);
     rb_thread_critical = saved_crit;
 
     rb_thread_schedule();
@@ -965,9 +1048,17 @@ debug_debug_load(VALUE self, VALUE file)
 }
 
 static VALUE
-debug_skip_i(VALUE value)
+set_current_skipped_status(VALUE status)
 {
-    rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL);
+    VALUE context;
+    debug_context_t *debug_context;
+    
+    context = debug_current_context(Qnil);
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    if(status) 
+        CTX_FL_SET(debug_context, CTX_FL_SKIPPED);
+    else
+        CTX_FL_UNSET(debug_context, CTX_FL_SKIPPED);
     return Qnil;
 }
 
@@ -985,8 +1076,8 @@ debug_skip(VALUE self)
     }
     if(!IS_STARTED)
         return rb_yield(Qnil);
-    rb_remove_event_hook(debug_event_hook);
-    return rb_ensure(rb_yield, Qnil, debug_skip_i, Qnil);
+    set_current_skipped_status(Qtrue);
+    return rb_ensure(rb_yield, Qnil, set_current_skipped_status, Qfalse);
 }
 
 static VALUE
@@ -1004,8 +1095,8 @@ debug_at_exit_i(VALUE proc)
     }
     else
     {
-        rb_remove_event_hook(debug_event_hook);
-        rb_ensure(debug_at_exit_c, proc, debug_skip_i, Qnil);
+        set_current_skipped_status(Qtrue);
+        rb_ensure(debug_at_exit_c, proc, set_current_skipped_status, Qfalse);
     }
 }
 
@@ -1151,37 +1242,42 @@ context_thnum(VALUE self)
 
 /*
  *   call-seq:
- *      context.set_suspend -> nil
+ *      context.suspend -> nil
  *   
  *   Suspends the thread when it is running.
  */
 static VALUE
-context_set_suspend(VALUE self)
+context_suspend(VALUE self)
 {
     debug_context_t *debug_context;
 
     debug_check_started();
 
     Data_Get_Struct(self, debug_context_t, debug_context);
-    debug_context->suspend = 1;
+    if(CTX_FL_TEST(debug_context, CTX_FL_SUSPEND))
+        rb_raise(rb_eRuntimeError, "Already suspended.");
+    CTX_FL_SET(debug_context, CTX_FL_SUSPEND);
     return Qnil;
 }
 
 /*
  *   call-seq:
- *      context.clear_suspend -> nil
+ *      context.resume -> nil
  *   
- *   Clears a suspend flag.
+ *   Resumes the thread from the suspended mode.
  */
 static VALUE
-context_clear_suspend(VALUE self)
+context_resume(VALUE self)
 {
     debug_context_t *debug_context;
 
     debug_check_started();
 
     Data_Get_Struct(self, debug_context_t, debug_context);
-    debug_context->suspend = 0;
+    if(!CTX_FL_TEST(debug_context, CTX_FL_SUSPEND))
+        rb_raise(rb_eRuntimeError, "Thread is not suspended.");
+    CTX_FL_UNSET(debug_context, CTX_FL_SUSPEND);
+    rb_thread_run(debug_context->thread);
     return Qnil;
 }
 
@@ -1199,7 +1295,7 @@ context_tracing(VALUE self)
     debug_check_started();
 
     Data_Get_Struct(self, debug_context_t, debug_context);
-    return debug_context->tracing ? Qtrue : Qfalse;
+    return CTX_FL_TEST(debug_context, CTX_FL_TRACING) ? Qtrue : Qfalse;
 }
 
 /*
@@ -1216,7 +1312,48 @@ context_set_tracing(VALUE self, VALUE value)
     debug_check_started();
 
     Data_Get_Struct(self, debug_context_t, debug_context);
-    debug_context->tracing = RTEST(value) ? 1 : 0;
+    if(RTEST(value))
+        CTX_FL_SET(debug_context, CTX_FL_TRACING);
+    else
+        CTX_FL_UNSET(debug_context, CTX_FL_TRACING);
+    return value;
+}
+
+/*
+ *   call-seq:
+ *      context.ignore -> bool
+ *   
+ *   Returns the ignore flag for the current context.
+ */
+static VALUE
+context_ignore(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return CTX_FL_TEST(debug_context, CTX_FL_IGNORE) ? Qtrue : Qfalse;
+}
+
+/*
+ *   call-seq:
+ *      context.tracking = bool
+ *   
+ *   Controls the ignore flag for this context.
+ */
+static VALUE
+context_set_ignore(VALUE self, VALUE value)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    if(RTEST(value))
+        CTX_FL_SET(debug_context, CTX_FL_IGNORE);
+    else
+        CTX_FL_UNSET(debug_context, CTX_FL_IGNORE);
     return value;
 }
 
@@ -1344,10 +1481,12 @@ Init_context()
     rb_define_method(cContext, "frames", context_frames, 0);
     rb_define_method(cContext, "thread", context_thread, 0);
     rb_define_method(cContext, "thnum", context_thnum, 0);
-    rb_define_method(cContext, "set_suspend", context_set_suspend, 0);
-    rb_define_method(cContext, "clear_suspend", context_clear_suspend, 0);
+    rb_define_method(cContext, "suspend", context_suspend, 0);
+    rb_define_method(cContext, "resume", context_resume, 0);
     rb_define_method(cContext, "tracing", context_tracing, 0);
     rb_define_method(cContext, "tracing=", context_set_tracing, 1);
+    rb_define_method(cContext, "ignore", context_ignore, 0);
+    rb_define_method(cContext, "ignore=", context_set_ignore, 1);
 }
 
 /*
@@ -1418,6 +1557,8 @@ Init_ruby_debug()
     rb_define_module_function(mDebugger, "skip", debug_skip, 0);
     rb_define_module_function(mDebugger, "debug_at_exit", debug_at_exit, 0);
     
+    cThreadsTable = rb_define_class_under(mDebugger, "ThreadsTable", rb_cObject);
+    
     Init_context();
     Init_frame();
     Init_breakpoint();
@@ -1439,7 +1580,6 @@ Init_ruby_debug()
     rb_global_variable(&threads_tbl);
     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

@@ -2,13 +2,11 @@ require 'pp'
 require 'stringio'
 require 'thread'
 require 'ruby_debug.so'
-require 'ruby-debug/lock'
 require 'ruby-debug/processor'
 
 SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
 
 module Debugger
-  MUTEX = Lock.new
   PORT = 8989
 
   @processor = CommandProcessor.new
@@ -37,10 +35,7 @@ module Debugger
     end
 
     def at_line(file, line, binding)
-      MUTEX.lock
       processor.at_line(self, file, line, binding)
-      MUTEX.unlock
-      Debugger.resume
     end
   end
 
@@ -97,6 +92,7 @@ module Debugger
       end
 
       @control_thread = Thread.start do
+        current_context.ignore = true
         server = TCPServer.new(host, ctrl_port)
         while (session = server.accept)
           interface = RemoteInterface.new(session)
@@ -109,6 +105,7 @@ module Debugger
       proceed = ConditionVariable.new
       
       @thread = Thread.start do
+        current_context.ignore = true
         server = TCPServer.new(host, cmd_port)
         while (session = server.accept)
           self.interface = RemoteInterface.new(session)

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

@@ -36,10 +36,6 @@ module Debugger
     self.always_run = true
     include DisplayFunctions
     
-    def initialize(state)
-      super
-    end
-
     def regexp
       /^\s*disp(?:lay)?$/
     end

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

@@ -100,7 +100,7 @@ module Debugger
         print "Already stopped.\n"
       else
         display_context(c)
-        c.set_suspend
+        c.suspend
       end
     end
 
@@ -160,7 +160,7 @@ module Debugger
         print "Already running."
       else
         display_context(c)
-        c.thread.run
+        c.resume
       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.3
-date: 2006-10-09 17:56:47 -04:00
+  version: 0.4.4
+date: 2006-10-15 18:26:58 -04:00
 summary: Fast Ruby debugger
 require_paths: 
 - lib
@@ -38,7 +38,6 @@ files:
 - lib/ruby-debug/command.rb
 - lib/ruby-debug/commands
 - lib/ruby-debug/interface.rb
-- lib/ruby-debug/lock.rb
 - lib/ruby-debug/processor.rb
 - lib/ruby-debug/commands/breakpoints.rb
 - lib/ruby-debug/commands/catchpoint.rb

data/lib/ruby-debug/lock.rb

@@ -1,41 +0,0 @@
-module Debugger
-  class Lock  # :nodoc:
-    def initialize
-      @locker = nil
-      @waiting = []
-      @locked = false;
-    end
-
-    def locked?
-      @locked
-    end
-
-    def lock
-      return if Thread.critical
-      return if @locker == Thread.current
-      while (Thread.critical = true; @locked)
-        @waiting.push Thread.current
-        Thread.stop
-      end
-      @locked = true
-      @locker = Thread.current
-      Thread.critical = false
-      self
-    end
-
-    def unlock
-      return if Thread.critical
-      return unless @locked
-      unless @locker == Thread.current
-        raise RuntimeError, "unlocked by other"
-      end
-      Thread.critical = true
-      t = @waiting.shift
-      @locked = false
-      @locker = nil
-      Thread.critical = false
-      t.run if t
-      self
-    end
-  end
-end