ruby-debug 0.5.3 → 0.6

data/CHANGES

@@ -1,3 +1,11 @@
+0.6
+- Added option to exclude collecting of frame bindings.
+- Several performance optimizations.
+
+0.5.4
+- Added -x/--trace option to rdebug script. Patch from R. Bernstein.
+- Removed a live thread reference from the context's structure avoiding memory leakage.
+
 0.5.3
 - Added Module#post_mortem_method method, which wraps any method with Debugger.post_mortem block.
 - Added breakpoint id, which is not dependent on the breakpoint position in Debugger.breakpoints array.

data/bin/rdebug

@@ -14,7 +14,9 @@ options = OpenStruct.new(
   'wait'        => false,
   'nostop'      => false,
   'post_mortem' => false,
-  'script'      => nil
+  'script'      => nil,
+  'tracing'     => false,
+  'frame_info'  => false
 )
 
 opts = OptionParser.new do |opts|
@@ -25,11 +27,13 @@ EOB
   opts.separator ""
   opts.separator "Options:"
   opts.on("-s", "--server", "Listen for remote connections") {options.server = 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("-w", "--wait", "Wait for a client connection, implies -s option") {options.wait = true}
+  opts.on("-x", "--trace", "turn on line tracing") {options.tracing = true}
   opts.on("-n", "--nostop", "Do not stop when a client connects, implies -s option") {options.nostop = true}
+  opts.on("-f", "--keep-frame-state", "Keep frame state") {options.frame_info = 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|}
   opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
     $LOAD_PATH.unshift(path)
@@ -82,6 +86,7 @@ else
   trap('INT') { Debugger.interrupt_last }
   Debugger.stop_on_connect = !options.nostop
   Debugger.wait_connection = options.wait
+  Debugger.keep_frame_info = options.frame_info
   load "#{ENV["HOME"]}/.rdebugrc" if File.exists?("#{ENV["HOME"]}/.rdebugrc")
   if options.server
     Debugger.start_remote(options.host, [options.port, options.cport], options.post_mortem)
@@ -92,7 +97,11 @@ else
       Debugger.run_script(options.script)
     end
     Debugger.post_mortem if options.post_mortem
-    debugger 2
+    if options.tracing
+      Debugger.tracing = true
+    else
+      debugger 2
+    end
     Debugger.debug_load Debugger::PROG_SCRIPT
   end
 end

data/ext/ruby_debug.c

@@ -4,7 +4,7 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.5.3"
+#define DEBUG_VERSION "0.6"
 
 #define CTX_FL_MOVED        (1<<1)
 #define CTX_FL_SUSPEND      (1<<2)
@@ -17,11 +17,15 @@
 #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)
+                          debug_context->last_file == NULL || \
+                          strcmp(debug_context->last_file, file) != 0)
 
 #define IS_STARTED  (threads_tbl != Qnil)
 
+#ifndef min
+#define min(x,y) ((x) < (y) ? (x) : (y))
+#endif
+
 typedef struct {
     int thnum;
     int flags;
@@ -29,23 +33,30 @@ typedef struct {
     int dest_frame;
     int stop_line;
     int stop_frame;
+    unsigned long thread_id;
     VALUE frames;
-    VALUE thread;
-    VALUE last_file;
-    VALUE last_line;
+    const char * last_file;
+    int last_line;
 } debug_context_t;
 
 typedef struct {
-    VALUE file;
-    VALUE line;
-    VALUE binding;
     ID id;
+    VALUE binding;
+    int line;
+    const char * file;
 } debug_frame_t;
 
+enum bp_type {BP_POS_TYPE, BP_METHOD_TYPE};
+
 typedef struct {
     int   id;
+    int   type;
     VALUE source;
-    VALUE pos;
+    union
+    {
+        int line;
+        ID  mid;
+    } pos;
     VALUE expr;
 } debug_breakpoint_t;
 
@@ -53,12 +64,13 @@ typedef struct {
     st_table *tbl;
 } threads_table_t;
 
-static VALUE threads_tbl = Qnil;
-static VALUE breakpoints = Qnil;
-static VALUE catchpoint  = Qnil;
-static VALUE tracing     = Qfalse;
-static VALUE locker      = Qnil;
-static VALUE post_mortem = Qfalse;
+static VALUE threads_tbl     = Qnil;
+static VALUE breakpoints     = Qnil;
+static VALUE catchpoint      = Qnil;
+static VALUE tracing         = Qfalse;
+static VALUE locker          = Qnil;
+static VALUE post_mortem     = Qfalse;
+static VALUE keep_frame_info = Qfalse;
 
 static VALUE mDebugger;
 static VALUE cThreadsTable;
@@ -66,15 +78,12 @@ static VALUE cContext;
 static VALUE cFrame;
 static VALUE cBreakpoint;
 
-static VALUE file_separator;
-static VALUE alt_file_separator;
+static VALUE rb_mObjectSpace;
 
 static ID idAtLine;
 static ID idAtBreakpoint;
 static ID idAtCatchpoint;
 static ID idAtTracing;
-static ID idBinding;
-static ID idBasename;
 static ID idEval;
 static ID idList;
 static ID idClear;
@@ -84,20 +93,67 @@ static int start_count = 0;
 static int thnum_max = 0;
 static int bkp_count = 0;
 static int last_debugged_thnum = -1;
+static unsigned long last_check = 0;
+static unsigned long hook_count = 0;
 
 static VALUE create_binding(VALUE);
 static VALUE debug_stop(VALUE);
 
 typedef struct locked_thread_t { 
-    VALUE thread;
+    unsigned long thread_id;
     struct locked_thread_t *next;
 } locked_thread_t;
 
 static locked_thread_t *locked_head = NULL;
 static locked_thread_t *locked_tail = NULL;
 
+inline static void *
+ruby_method_ptr(VALUE class, ID meth_id)
+{
+    NODE *body, *method;
+    st_lookup(RCLASS(class)->m_tbl, meth_id, (st_data_t *)&body);
+    method       = (NODE *)body->u2.value;
+    return (void *)method->u1.value;
+}
+
+inline static unsigned long 
+ref2id(VALUE obj)
+{
+    return NUM2ULONG(rb_obj_id(obj));
+}
+
+static VALUE
+id2ref_unprotected(VALUE id)
+{
+    typedef VALUE (*id2ref_func_t)(VALUE, VALUE);
+    static id2ref_func_t f_id2ref = NULL;
+    if(f_id2ref == NULL)
+    {
+        f_id2ref = ruby_method_ptr(rb_mObjectSpace, rb_intern("_id2ref"));
+    }
+    return f_id2ref(rb_mObjectSpace, id);
+}
+
+static VALUE
+id2ref_error()
+{
+    return Qnil;
+}
+
+static VALUE
+id2ref(unsigned long id)
+{
+    return rb_rescue(id2ref_unprotected, ULONG2NUM(id), id2ref_error, 0);
+}
+
+inline static VALUE
+context_thread_0(debug_context_t *debug_context)
+{
+    return id2ref(debug_context->thread_id);
+}
+
 static int
-is_in_locked(VALUE thread)
+is_in_locked(unsigned long thread_id)
 {
     locked_thread_t *node;
     
@@ -106,7 +162,7 @@ is_in_locked(VALUE thread)
     
     for(node = locked_head; node != locked_tail; node = node->next)
     {
-        if(node->thread == thread) return 1;
+        if(node->thread_id == thread_id) return 1;
     }
     return 0;
 }
@@ -115,12 +171,13 @@ static void
 add_to_locked(VALUE thread)
 {
     locked_thread_t *node;
+    unsigned long thread_id = ref2id(thread);
     
-    if(is_in_locked(thread))
+    if(is_in_locked(thread_id))
         return;
 
     node = ALLOC(locked_thread_t);
-    node->thread = thread;
+    node->thread_id = thread_id;
     node->next = NULL;
     if(locked_tail)
         locked_tail->next = node;
@@ -141,15 +198,15 @@ remove_from_locked()
     locked_head = locked_head->next;
     if(locked_tail == node)
         locked_tail = NULL;
-    thread = node->thread;
+    thread = id2ref(node->thread_id);
     xfree(node);
     return thread;
 }
 
 static int
-thread_hash(VALUE thread)
+thread_hash(unsigned long thread_id)
 {
-    return (int)FIX2LONG(rb_obj_id(thread));
+    return (int)thread_id;
 }
 
 static int
@@ -168,7 +225,6 @@ static struct st_hash_type st_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;
 }
@@ -213,6 +269,43 @@ threads_table_clear(VALUE table)
     st_foreach(threads_table->tbl, threads_table_clear_i, 0);
 }
 
+static VALUE
+is_thread_alive(VALUE thread)
+{
+    static ID id_alive = 0;
+    if(!id_alive)
+    {
+        id_alive = rb_intern("alive?");
+    }
+    return rb_funcall(thread, id_alive, 0);
+}
+
+static int
+threads_table_check_i(VALUE key, VALUE value, VALUE dummy)
+{
+    VALUE thread;
+    
+    thread = id2ref(key);
+    if(!rb_obj_is_kind_of(thread, rb_cThread))
+    {
+        return ST_DELETE;
+    }
+    if(rb_protect(is_thread_alive, thread, 0) != Qtrue)
+    {
+        return ST_DELETE;
+    }
+    return ST_CONTINUE;
+}
+
+static void
+check_thread_contexts()
+{
+    threads_table_t *threads_table;
+
+    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    st_foreach(threads_table->tbl, threads_table_check_i, 0);
+}
+
 /*
  *   call-seq:
  *      Debugger.started? -> bool
@@ -239,9 +332,6 @@ debug_context_mark(void* data)
 {
     debug_context_t *debug_context = (debug_context_t *)data;
     rb_gc_mark(debug_context->frames);
-    rb_gc_mark(debug_context->thread);
-    rb_gc_mark(debug_context->last_file);
-    rb_gc_mark(debug_context->last_line);
 }
 
 static VALUE
@@ -253,8 +343,8 @@ debug_context_create(VALUE thread)
     debug_context = ALLOC(debug_context_t);
     debug_context-> thnum = ++thnum_max;
     
-    debug_context->last_file = Qnil;
-    debug_context->last_line = Qnil;
+    debug_context->last_file = NULL;
+    debug_context->last_line = 0;
     debug_context->flags = 0;
 
     debug_context->stop_next = -1;
@@ -262,7 +352,7 @@ debug_context_create(VALUE thread)
     debug_context->stop_line = -1;
     debug_context->stop_frame = -1;
     debug_context->frames = rb_ary_new();
-    debug_context->thread = thread;
+    debug_context->thread_id = ref2id(thread);
     result = Data_Wrap_Struct(cContext, debug_context_mark, xfree, debug_context);
     return result;
 }
@@ -272,14 +362,15 @@ thread_context_lookup(VALUE thread)
 {
     VALUE context;
     threads_table_t *threads_table;
+    unsigned long thread_id = ref2id(thread);
 
     debug_check_started();
 
     Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
-    if(!st_lookup(threads_table->tbl, thread, &context))
+    if(!st_lookup(threads_table->tbl, thread_id, &context))
     {
         context = debug_context_create(thread);
-        st_insert(threads_table->tbl, thread, context);
+        st_insert(threads_table->tbl, thread_id, context);
     }
     return context;
 }
@@ -289,12 +380,10 @@ debug_frame_mark(void *data)
 {
     debug_frame_t *debug_frame = (debug_frame_t *)data;
     rb_gc_mark(debug_frame->binding);
-    rb_gc_mark(debug_frame->file);
-    rb_gc_mark(debug_frame->line);
 }
 
 static VALUE
-debug_frame_create(VALUE file, VALUE line, VALUE binding, ID id)
+debug_frame_create(char *file, int line, VALUE binding, ID id)
 {
     VALUE result;
     debug_frame_t *debug_frame;
@@ -337,89 +426,112 @@ call_at_line_unprotected(VALUE args)
 }
 
 static VALUE
-call_at_line(VALUE context, int thnum, VALUE binding, VALUE file, VALUE line)
+call_at_line(VALUE context, int thnum, VALUE file, VALUE line)
 {
     VALUE args;
     
     last_debugged_thnum = thnum;
     save_current_position(context);
     
-    args = rb_ary_new3(4, context, file, line, binding);
+    args = rb_ary_new3(3, context, file, line);
     return rb_protect(call_at_line_unprotected, args, 0);
 }
 
 static void
-set_frame_source(debug_context_t *debug_context, VALUE file, VALUE line)
-{
-    VALUE frame;
-    debug_frame_t *top_frame;
-
-    if(RARRAY(debug_context->frames)->len > 0)
-    {
-        frame = *RARRAY(debug_context->frames)->ptr;
-        Data_Get_Struct(frame, debug_frame_t, top_frame);
-        top_frame->file = file;
-        top_frame->line = line;
-    }
-}
-
-static void
-save_call_frame(VALUE self, VALUE file, VALUE line, ID mid, debug_context_t *debug_context)
+save_call_frame(VALUE self, char *file, int line, ID mid, debug_context_t *debug_context)
 {
     VALUE frame, binding;
     
-    binding = self? create_binding(self) : Qnil;
+    binding = self && RTEST(keep_frame_info)? create_binding(self) : Qnil;
     frame = debug_frame_create(file, line, binding, mid);
     rb_ary_unshift(debug_context->frames, frame);
 }
 
-static VALUE
-basename(VALUE filename)
+#if defined DOSISH
+#define isdirsep(x) ((x) == '/' || (x) == '\\')
+#else
+#define isdirsep(x) ((x) == '/')
+#endif
+
+static int
+filename_cmp(VALUE source, char *file)
 {
-    return rb_funcall(rb_cFile, idBasename, 1, filename);
+    char *source_ptr, *file_ptr;
+    int s_len, f_len, min_len;
+    int s,f;
+    int dirsep_flag = 0;
+    
+    s_len = RSTRING(source)->len;
+    f_len = strlen(file);
+    min_len = min(s_len, f_len);
+    
+    source_ptr = RSTRING(source)->ptr;
+    file_ptr   = file;
+    
+    for( s = s_len - 1, f = f_len - 1; s >= s_len - min_len && f >= f_len - min_len; s--, f-- )
+    {
+        if((source_ptr[s] == '.' || file_ptr[f] == '.') && dirsep_flag)
+            return 1;
+        if(source_ptr[s] != file_ptr[f])
+            return 0;
+        if(isdirsep(source_ptr[s]))
+            dirsep_flag = 1;
+    }
+    return 1;
 }
 
 static int
-filename_cmp(debug_breakpoint_t *debug_breakpoint, VALUE file)
+check_breakpoints_by_pos(debug_context_t *debug_context, char *file, int line)
 {
-    VALUE flag = Qnil;
+    VALUE breakpoint; 
+    debug_breakpoint_t *debug_breakpoint;
+    int i;
+
+    if(RARRAY(breakpoints)->len == 0)
+        return -1;
+    if(!CTX_FL_TEST(debug_context, CTX_FL_MOVED))
+        return -1;
     
-    flag = rb_funcall(debug_breakpoint->source, idIndex, 1, file_separator);
-    if(alt_file_separator != Qnil && flag == Qnil)
-        flag = rb_funcall(debug_breakpoint->source, idIndex, 1, alt_file_separator);
-    if(flag == Qnil)
-        file = basename(file);
-    else
-        file = rb_file_expand_path(file, Qnil);
-    return(rb_str_cmp(debug_breakpoint->source, file) == 0);
+    for(i = 0; i < RARRAY(breakpoints)->len; i++)
+    {
+        breakpoint = rb_ary_entry(breakpoints, i);
+        Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+        if(debug_breakpoint->type != BP_POS_TYPE)
+            continue;
+        if(debug_breakpoint->pos.line != line)
+            continue;
+        if(filename_cmp(debug_breakpoint->source, file))
+            return i;
+    }
+    return -1;
 }
 
-static int
-classname_cmp(debug_breakpoint_t *debug_breakpoint, VALUE klass)
+inline static int
+classname_cmp(VALUE name, VALUE klass)
 {
-    return (klass != Qnil && rb_str_cmp(debug_breakpoint->source, rb_mod_name(klass)) == 0);
+    return (klass != Qnil && rb_str_cmp(name, rb_mod_name(klass)) == 0);
 }
 
 static int
-check_breakpoints(debug_context_t *debug_context, VALUE file, VALUE klass, VALUE pos)
+check_breakpoints_by_method(debug_context_t *debug_context, VALUE klass, ID mid)
 {
     VALUE breakpoint; 
     debug_breakpoint_t *debug_breakpoint;
     int i;
-
+    
     if(RARRAY(breakpoints)->len == 0)
         return -1;
     if(!CTX_FL_TEST(debug_context, CTX_FL_MOVED))
         return -1;
-    
     for(i = 0; i < RARRAY(breakpoints)->len; i++)
     {
         breakpoint = rb_ary_entry(breakpoints, i);
         Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
-        if(debug_breakpoint->pos != pos && !(TYPE(pos) == T_STRING && 
-            TYPE(debug_breakpoint->pos) == T_STRING && rb_str_cmp(debug_breakpoint->pos, pos) == 0))
+        if(debug_breakpoint->type != BP_METHOD_TYPE)
             continue;
-        if(filename_cmp(debug_breakpoint, file) || classname_cmp(debug_breakpoint, klass))
+        if(debug_breakpoint->pos.mid != mid)
+            continue;
+        if(classname_cmp(debug_breakpoint->source, klass))
             return i;
     }
     return -1;
@@ -437,10 +549,7 @@ create_binding(VALUE self)
 
     if(f_binding == NULL)
     {
-        NODE *body, *method;
-        st_lookup(RCLASS(rb_mKernel)->m_tbl, idBinding, (st_data_t *)&body);
-        method       = (NODE *)body->u2.value;
-        f_binding    = (bind_func_t)method->u1.value;
+        f_binding = (bind_func_t)ruby_method_ptr(rb_mKernel, rb_intern("binding"));
     }
     return f_binding(self);
 }
@@ -457,7 +566,7 @@ eval_expression(VALUE args)
     return rb_funcall2(rb_mKernel, idEval, 2, RARRAY(args)->ptr);
 }
 
-static int
+inline static int
 check_breakpoint_expression(VALUE breakpoint, VALUE binding)
 {
     debug_breakpoint_t *debug_breakpoint;
@@ -472,15 +581,53 @@ check_breakpoint_expression(VALUE breakpoint, VALUE binding)
     return RTEST(expr_result);
 }
 
+inline static debug_frame_t *
+get_top_frame(debug_context_t *debug_context)
+{
+    VALUE frame;
+    debug_frame_t *debug_frame;
+    if(RARRAY(debug_context->frames)->len == 0)
+        return NULL;
+    else {
+        frame = RARRAY(debug_context->frames)->ptr[0];
+        Data_Get_Struct(frame, debug_frame_t, debug_frame);
+        return debug_frame;
+    }
+}
+
+inline static void
+save_top_binding(debug_context_t *debug_context, VALUE binding)
+{
+    debug_frame_t *debug_frame;
+    debug_frame = get_top_frame(debug_context);
+    if(debug_frame)
+        debug_frame->binding = binding;
+}
+
+static void
+set_frame_source(debug_context_t *debug_context, char *file, int line)
+{
+    debug_frame_t *top_frame;
+    top_frame = get_top_frame(debug_context);
+    if(top_frame)
+    {
+        top_frame->file = file;
+        top_frame->line = line;
+    }
+}
+
 static void
 debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 {
     VALUE thread, context, breakpoint;
     VALUE binding = Qnil;
     debug_context_t *debug_context;
-    VALUE file = Qnil, line = Qnil;
+    char *file;
+    int line;
     int breakpoint_index = -1;
     
+    hook_count++;
+    
     if (mid == ID_ALLOCATOR) return;
     if(!node) return;
     
@@ -519,8 +666,8 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     /* 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));
+    file = node->nd_file;
+    line = nd_line(node);
 
     if(DID_MOVED)
         CTX_FL_SET(debug_context, CTX_FL_MOVED);
@@ -533,7 +680,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 
         if(RTEST(tracing) || CTX_FL_TEST(debug_context, CTX_FL_TRACING))
         {
-            rb_funcall(context, idAtTracing, 2, file, line);
+            rb_funcall(context, idAtTracing, 2, rb_str_new2(file), INT2FIX(line));
         }
         
         if(debug_context->dest_frame == -1 || 
@@ -559,7 +706,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_line == 0 ||
-            (breakpoint_index = check_breakpoints(debug_context, file, klass, line)) != -1)
+            (breakpoint_index = check_breakpoints_by_pos(debug_context, file, line)) != -1)
         {
             binding = self? create_binding(self) : Qnil;
             /* check breakpoint expression */
@@ -579,7 +726,8 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             debug_context->stop_line = -1;
             debug_context->stop_next = -1;
 
-            call_at_line(context, debug_context->thnum, binding, file, line);
+            save_top_binding(debug_context, binding);
+            call_at_line(context, debug_context->thnum, rb_str_new2(file), INT2FIX(line));
         }
         break;
     }
@@ -591,15 +739,21 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     case RUBY_EVENT_CALL:
     {
         save_call_frame(self, file, line, mid, debug_context);
-        breakpoint_index = check_breakpoints(debug_context, file, klass, rb_str_new2(rb_id2name(mid)));
+        breakpoint_index = check_breakpoints_by_method(debug_context, klass, mid);
         if(breakpoint_index != -1)
         {
-            binding = self? create_binding(self) : Qnil;
+            debug_frame_t *debug_frame;
+            debug_frame = get_top_frame(debug_context);
+            if(debug_frame)
+                binding = debug_frame->binding;
+            if(NIL_P(binding) && self)
+                binding = create_binding(self);
             breakpoint = get_breakpoint_at(breakpoint_index);
             if(check_breakpoint_expression(breakpoint, binding))
             {
+                save_top_binding(debug_context, binding);
                 rb_funcall(context, idAtBreakpoint, 1, breakpoint);
-                call_at_line(context, debug_context->thnum, binding, file, line);
+                call_at_line(context, debug_context->thnum, rb_str_new2(file), INT2FIX(line));
             }
         }
         break;
@@ -629,8 +783,8 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         if(post_mortem == Qtrue && self)
         {
             binding = create_binding(self);
-            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_file"), rb_str_new2(file));
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_line"), INT2FIX(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));
         }
@@ -654,7 +808,8 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
                 rb_funcall(context, idAtCatchpoint, 1, ruby_errinfo);
                 if(self && binding == Qnil)
                     binding = create_binding(self);
-                call_at_line(context, debug_context->thnum, binding, file, line);
+                save_top_binding(debug_context, binding);
+                call_at_line(context, debug_context->thnum, rb_str_new2(file), INT2FIX(line));
                 break;
             }
         }
@@ -669,6 +824,13 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 
     cleanup:
     
+    /* check that all contexts point to alive threads */
+    if(hook_count - last_check > 1000)
+    {
+        check_thread_contexts();
+        last_check = hook_count;
+    }
+    
     /* release a lock */
     locker = Qnil;
     /* let the next thread to run */
@@ -755,7 +917,6 @@ breakpoint_mark(void *data)
     debug_breakpoint_t *breakpoint;
     breakpoint = (debug_breakpoint_t *)data;
     rb_gc_mark(breakpoint->source);
-    rb_gc_mark(breakpoint->pos);
     rb_gc_mark(breakpoint->expr);
 }
 
@@ -775,6 +936,7 @@ debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
     VALUE source, pos, expr;
     VALUE result;
     debug_breakpoint_t *breakpoint;
+    int type;
 
     debug_check_started();
     
@@ -782,11 +944,19 @@ debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
     {
         expr = Qnil;
     }
-
+    type = FIXNUM_P(pos) ? BP_POS_TYPE : BP_METHOD_TYPE;
+    if(type == BP_POS_TYPE)
+        source = StringValue(source);
+    else
+        pos = StringValue(pos);
     breakpoint = ALLOC(debug_breakpoint_t);
-    breakpoint->source = StringValue(source);
     breakpoint->id = ++bkp_count;
-    breakpoint->pos = pos;
+    breakpoint->source = source;
+    breakpoint->type = type;
+    if(type == BP_POS_TYPE)
+        breakpoint->pos.line = FIX2INT(pos);
+    else
+        breakpoint->pos.mid = rb_intern(RSTRING(pos)->ptr);
     breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
     result = Data_Wrap_Struct(cBreakpoint, breakpoint_mark, xfree, breakpoint);
     rb_ary_push(breakpoints, result);
@@ -958,7 +1128,7 @@ debug_contexts(VALUE self)
     {
         context = rb_ary_entry(new_list, i);
         Data_Get_Struct(context, debug_context_t, debug_context);
-        st_insert(threads_table->tbl, debug_context->thread, context);
+        st_insert(threads_table->tbl, debug_context->thread_id, context);
     }
 
     return new_list;
@@ -1033,7 +1203,7 @@ debug_resume(VALUE self)
         if(CTX_FL_TEST(debug_context, CTX_FL_SUSPEND))
         {
             CTX_FL_UNSET(debug_context, CTX_FL_SUSPEND);
-            rb_thread_run(debug_context->thread);
+            rb_thread_run(context_thread_0(debug_context));
         }
     }
     rb_thread_critical = saved_crit;
@@ -1096,6 +1266,31 @@ debug_set_post_mortem(VALUE self, VALUE value)
     return value;
 }
 
+/*
+ *   call-seq:
+ *      Debugger.post_mortem? -> bool
+ *   
+ *   Returns +true+ if the debugger will collect frame bindings.
+ */
+static VALUE
+debug_keep_frame_info(VALUE self)
+{
+    return keep_frame_info;
+}
+
+/*
+ *   call-seq:
+ *      Debugger.post_mortem = bool
+ *   
+ *   Setting to +true+ will make the debugger keep frame bindings.
+ */
+static VALUE
+debug_set_keep_frame_info(VALUE self, VALUE value)
+{
+    keep_frame_info = RTEST(value) ? Qtrue : Qfalse;
+    return value;
+}
+
 /*
  *   call-seq:
  *      Debugger.debug_load(file) -> nil
@@ -1295,7 +1490,7 @@ context_thread(VALUE self)
     debug_context_t *debug_context;
 
     Data_Get_Struct(self, debug_context_t, debug_context);
-    return debug_context->thread;
+    return context_thread_0(debug_context);
 }
 
 /*
@@ -1350,7 +1545,7 @@ context_resume(VALUE self)
     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);
+    rb_thread_run(context_thread_0(debug_context));
     return Qnil;
 }
 
@@ -1442,7 +1637,7 @@ frame_file(VALUE self)
     debug_frame_t *debug_frame;
 
     Data_Get_Struct(self, debug_frame_t, debug_frame);
-    return debug_frame->file;
+    return rb_str_new2(debug_frame->file);
 }
 
 /*
@@ -1457,7 +1652,7 @@ frame_line(VALUE self)
     debug_frame_t *debug_frame;
 
     Data_Get_Struct(self, debug_frame_t, debug_frame);
-    return debug_frame->line;
+    return INT2FIX(debug_frame->line);
 }
 
 /*
@@ -1517,7 +1712,10 @@ breakpoint_pos(VALUE self)
     debug_breakpoint_t *breakpoint;
 
     Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return breakpoint->pos;
+    if(breakpoint->type == BP_METHOD_TYPE)
+        return rb_str_new2(rb_id2name(breakpoint->pos.mid));
+    else
+        return INT2FIX(breakpoint->pos.line);
 }
 
 /*
@@ -1648,6 +1846,8 @@ Init_ruby_debug()
     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);
+    rb_define_module_function(mDebugger, "keep_frame_info?", debug_keep_frame_info, 0);
+    rb_define_module_function(mDebugger, "keep_frame_info=", debug_set_keep_frame_info, 1);
     
     cThreadsTable = rb_define_class_under(mDebugger, "ThreadsTable", rb_cObject);
     
@@ -1659,20 +1859,15 @@ Init_ruby_debug()
     idAtBreakpoint = rb_intern("at_breakpoint");
     idAtCatchpoint = rb_intern("at_catchpoint");
     idAtTracing    = rb_intern("at_tracing");
-    idBinding      = rb_intern("binding");
-    idBasename     = rb_intern("basename");
     idEval         = rb_intern("eval");
     idList         = rb_intern("list");
     idClear        = rb_intern("clear");
     idIndex        = rb_intern("index");
 
-    file_separator = rb_eval_string("File::SEPARATOR");
-    alt_file_separator = rb_eval_string("File::ALT_SEPARATOR");
+    rb_mObjectSpace = rb_const_get(rb_mKernel, rb_intern("ObjectSpace"));
 
     rb_global_variable(&threads_tbl);
     rb_global_variable(&breakpoints);
     rb_global_variable(&catchpoint);
     rb_global_variable(&locker);
-    rb_global_variable(&file_separator);
-    rb_global_variable(&alt_file_separator);
 }

data/ext/tags

@@ -0,0 +1,90 @@
+CTX_FL_SET	ruby_debug.c	/^#define CTX_FL_SET(c,f) do { (c)->flags |= (f); } /
+CTX_FL_TEST	ruby_debug.c	/^#define CTX_FL_TEST(c,f) ((c)->flags & (f))$/
+CTX_FL_UNSET	ruby_debug.c	/^#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f);/
+Init_breakpoint	ruby_debug.c	/^Init_breakpoint()$/
+Init_context	ruby_debug.c	/^Init_context()$/
+Init_frame	ruby_debug.c	/^Init_frame()$/
+Init_ruby_debug	ruby_debug.c	/^Init_ruby_debug()$/
+VALUE	ruby_debug.c	/^    typedef VALUE (*bind_func_t)(VALUE);$/
+add_to_locked	ruby_debug.c	/^add_to_locked(VALUE thread)$/
+basename	ruby_debug.c	/^basename(VALUE filename)$/
+breakpoint_expr	ruby_debug.c	/^breakpoint_expr(VALUE self)$/
+breakpoint_id	ruby_debug.c	/^breakpoint_id(VALUE self)$/
+breakpoint_mark	ruby_debug.c	/^breakpoint_mark(void *data)$/
+breakpoint_pos	ruby_debug.c	/^breakpoint_pos(VALUE self)$/
+breakpoint_source	ruby_debug.c	/^breakpoint_source(VALUE self)$/
+call_at_line	ruby_debug.c	/^call_at_line(VALUE context, int thnum, VALUE bindi/
+call_at_line_unprotected	ruby_debug.c	/^call_at_line_unprotected(VALUE args)$/
+check_breakpoint_expression	ruby_debug.c	/^check_breakpoint_expression(VALUE breakpoint, VALU/
+check_breakpoints	ruby_debug.c	/^check_breakpoints(debug_context_t *debug_context, /
+classname_cmp	ruby_debug.c	/^classname_cmp(debug_breakpoint_t *debug_breakpoint/
+context_frames	ruby_debug.c	/^context_frames(VALUE self)$/
+context_ignore	ruby_debug.c	/^context_ignore(VALUE self)$/
+context_resume	ruby_debug.c	/^context_resume(VALUE self)$/
+context_set_ignore	ruby_debug.c	/^context_set_ignore(VALUE self, VALUE value)$/
+context_set_tracing	ruby_debug.c	/^context_set_tracing(VALUE self, VALUE value)$/
+context_step_over	ruby_debug.c	/^context_step_over(int argc, VALUE *argv, VALUE sel/
+context_stop_frame	ruby_debug.c	/^context_stop_frame(VALUE self, VALUE frame)$/
+context_stop_next	ruby_debug.c	/^context_stop_next(VALUE self, VALUE steps)$/
+context_suspend	ruby_debug.c	/^context_suspend(VALUE self)$/
+context_thnum	ruby_debug.c	/^context_thnum(VALUE self)$/
+context_thread	ruby_debug.c	/^context_thread(VALUE self)$/
+context_tracing	ruby_debug.c	/^context_tracing(VALUE self)$/
+create_binding	ruby_debug.c	/^create_binding(VALUE self)$/
+debug_add_breakpoint	ruby_debug.c	/^debug_add_breakpoint(int argc, VALUE *argv, VALUE /
+debug_at_exit	ruby_debug.c	/^debug_at_exit(VALUE self)$/
+debug_at_exit_c	ruby_debug.c	/^debug_at_exit_c(VALUE proc)$/
+debug_at_exit_i	ruby_debug.c	/^debug_at_exit_i(VALUE proc)$/
+debug_breakpoint_t	ruby_debug.c	/^} debug_breakpoint_t;$/
+debug_breakpoints	ruby_debug.c	/^debug_breakpoints(VALUE self)$/
+debug_catchpoint	ruby_debug.c	/^debug_catchpoint(VALUE self)$/
+debug_check_started	ruby_debug.c	/^debug_check_started()$/
+debug_context_create	ruby_debug.c	/^debug_context_create(VALUE thread)$/
+debug_context_mark	ruby_debug.c	/^debug_context_mark(void* data)$/
+debug_context_t	ruby_debug.c	/^} debug_context_t;$/
+debug_contexts	ruby_debug.c	/^debug_contexts(VALUE self)$/
+debug_current_context	ruby_debug.c	/^debug_current_context(VALUE self)$/
+debug_debug_load	ruby_debug.c	/^debug_debug_load(VALUE self, VALUE file)$/
+debug_event_hook	ruby_debug.c	/^debug_event_hook(rb_event_t event, NODE *node, VAL/
+debug_frame_create	ruby_debug.c	/^debug_frame_create(VALUE file, VALUE line, VALUE b/
+debug_frame_mark	ruby_debug.c	/^debug_frame_mark(void *data)$/
+debug_frame_t	ruby_debug.c	/^} debug_frame_t;$/
+debug_is_started	ruby_debug.c	/^debug_is_started(VALUE self)$/
+debug_last_interrupted	ruby_debug.c	/^debug_last_interrupted(VALUE self)$/
+debug_post_mortem	ruby_debug.c	/^debug_post_mortem(VALUE self)$/
+debug_remove_breakpoint	ruby_debug.c	/^debug_remove_breakpoint(VALUE self, VALUE id_value/
+debug_resume	ruby_debug.c	/^debug_resume(VALUE self)$/
+debug_set_catchpoint	ruby_debug.c	/^debug_set_catchpoint(VALUE self, VALUE value)$/
+debug_set_post_mortem	ruby_debug.c	/^debug_set_post_mortem(VALUE self, VALUE value)$/
+debug_set_tracing	ruby_debug.c	/^debug_set_tracing(VALUE self, VALUE value)$/
+debug_skip	ruby_debug.c	/^debug_skip(VALUE self)$/
+debug_start	ruby_debug.c	/^debug_start(VALUE self)$/
+debug_stop	ruby_debug.c	/^debug_stop(VALUE self)$/
+debug_stop_i	ruby_debug.c	/^debug_stop_i(VALUE self)$/
+debug_suspend	ruby_debug.c	/^debug_suspend(VALUE self)$/
+debug_tracing	ruby_debug.c	/^debug_tracing(VALUE self)$/
+eval_expression	ruby_debug.c	/^eval_expression(VALUE args)$/
+filename_cmp	ruby_debug.c	/^filename_cmp(debug_breakpoint_t *debug_breakpoint,/
+find_last_context_func	ruby_debug.c	/^find_last_context_func(VALUE key, VALUE value, VAL/
+frame_binding	ruby_debug.c	/^frame_binding(VALUE self)$/
+frame_file	ruby_debug.c	/^frame_file(VALUE self)$/
+frame_id	ruby_debug.c	/^frame_id(VALUE self)$/
+frame_line	ruby_debug.c	/^frame_line(VALUE self)$/
+get_breakpoint_at	ruby_debug.c	/^get_breakpoint_at(int index) $/
+is_in_locked	ruby_debug.c	/^is_in_locked(VALUE thread)$/
+locked_thread_t	ruby_debug.c	/^} locked_thread_t;$/
+remove_from_locked	ruby_debug.c	/^remove_from_locked()$/
+save_call_frame	ruby_debug.c	/^save_call_frame(VALUE self, VALUE file, VALUE line/
+save_current_position	ruby_debug.c	/^save_current_position(VALUE context)$/
+set_current_skipped_status	ruby_debug.c	/^set_current_skipped_status(VALUE status)$/
+set_frame_source	ruby_debug.c	/^set_frame_source(debug_context_t *debug_context, V/
+thread_cmp	ruby_debug.c	/^thread_cmp(VALUE a, VALUE b)$/
+thread_context_lookup	ruby_debug.c	/^thread_context_lookup(VALUE thread)$/
+thread_hash	ruby_debug.c	/^thread_hash(VALUE thread)$/
+threads_table_clear	ruby_debug.c	/^threads_table_clear(VALUE table)$/
+threads_table_clear_i	ruby_debug.c	/^threads_table_clear_i(VALUE key, VALUE value, VALU/
+threads_table_create	ruby_debug.c	/^threads_table_create()$/
+threads_table_free	ruby_debug.c	/^threads_table_free(void* data)$/
+threads_table_mark	ruby_debug.c	/^threads_table_mark(void* data)$/
+threads_table_mark_keyvalue	ruby_debug.c	/^threads_table_mark_keyvalue(VALUE key, VALUE value/
+threads_table_t	ruby_debug.c	/^} threads_table_t;$/

data/lib/ruby-debug.rb

@@ -36,8 +36,8 @@ module Debugger
       processor.at_tracing(self, file, line)
     end
 
-    def at_line(file, line, binding)
-      processor.at_line(self, file, line, binding)
+    def at_line(file, line)
+      processor.at_line(self, file, line)
     end
   end
 
@@ -170,7 +170,7 @@ module Debugger
     private :stop_main_thread
 
     def source_for(file) # :nodoc:
-      Dir.chdir File.dirname($0) do
+      finder = lambda do
         unless File.exists?(file)
           return (SCRIPT_LINES__[file] == true ? nil : SCRIPT_LINES__[file])
         end
@@ -187,6 +187,7 @@ module Debugger
 
         SCRIPT_LINES__[file]
       end
+      Dir.chdir(File.dirname($0)){finder.call} || finder.call
     end
     
     def source_reload
@@ -257,7 +258,11 @@ module Debugger
     
     def handle_post_mortem(exp)
       return if exp.__debug_frames.empty?
-      processor.at_line(nil, exp.__debug_file, exp.__debug_line, exp.__debug_frames.first.binding, exp.__debug_frames)
+      orig_tracing = Debugger.tracing, Debugger.current_context.tracing
+      Debugger.tracing = Debugger.current_context.tracing = false
+      processor.at_line(nil, exp.__debug_file, exp.__debug_line, exp.__debug_frames)
+    ensure
+      Debugger.tracing, Debugger.current_context.tracing = orig_tracing
     end
     private :handle_post_mortem
   end

data/lib/ruby-debug/command.rb

@@ -62,11 +62,15 @@ module Debugger
       @state.confirm(msg) == 'y'
     end
 
-    def debug_eval(str)
+    def debug_eval(str, b = @state.binding)
+      unless b
+        print "Can't evaluate in the current context.\n"
+        throw :debug_error
+      end
       begin
-        val = eval(str, @state.binding)
+        val = eval(str, b)
       rescue StandardError, ScriptError => e
-        at = eval("caller(1)", @state.binding)
+        at = eval("caller(1)", b)
         print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
         for i in at
           print "\tfrom %s\n", i
@@ -76,6 +80,7 @@ module Debugger
     end
 
     def debug_silent_eval(str)
+      return nil unless @state.binding
       begin
         eval(str, @state.binding)
       rescue StandardError, ScriptError

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

@@ -35,7 +35,11 @@ module Debugger
     def execute
       unless @state.interface.kind_of?(LocalInterface)
         print "Command is available only in local mode.\n"
-        return
+        throw :debug_error
+      end
+      unless @state.binding
+        print "Can't evaluate in the current context.\n"
+        throw :debug_error
       end
       IRB.start_session(@state.binding)
     end

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

@@ -1,10 +1,17 @@
 module Debugger
   module VarFunctions # :nodoc:
-    def var_list(ary, bind = nil)
-      bind ||= @state.binding
+    def var_list(ary, bind = @state.binding)
       ary.sort!
       for v in ary
-        print "  %s => %s\n", v, eval(v, bind).inspect
+        print "  %s => %s\n", v, debug_eval(v, bind).inspect
+      end
+    end
+    
+    def var_consts(mod)
+      constants = mod.constants
+      constants.sort!
+      for c in constants
+        print " %s => %s\n", c, mod.const_get(c)
       end
     end
   end
@@ -21,7 +28,7 @@ module Debugger
       unless obj.kind_of? Module
         print "Should be Class/Module: %s\n", @match.post_match
       else
-        var_list(obj.constants, obj.module_eval{binding()})
+        var_consts(obj)
       end
     end
 
@@ -95,7 +102,7 @@ module Debugger
     end
 
     def execute
-      var_list(eval("local_variables", @state.binding))
+      var_list(debug_eval("local_variables"))
     end
 
     class << self

data/lib/ruby-debug/processor.rb

@@ -62,9 +62,9 @@ module Debugger
     end
     protect :at_tracing
 
-    def at_line(context, file, line, binding, frames = context.frames)
+    def at_line(context, file, line, frames = context.frames)
       print "%s:%d: %s", file, line, Debugger.line_at(file, line)
-      process_commands(context, file, line, binding, frames)
+      process_commands(context, file, line, frames)
     end
     protect :at_line
     
@@ -82,13 +82,13 @@ module Debugger
       end
     end
     
-    def process_commands(context, file, line, binding, frames)
+    def process_commands(context, file, line, frames)
       event_cmds = Command.commands.select{|cmd| cmd.event }
       state = State.new do |s|
         s.context = context
         s.file    = file
         s.line    = line
-        s.binding = binding
+        s.binding = frames.first.binding
         s.display = display
         s.interface = interface
         s.commands = event_cmds

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: ruby-debug
 version: !ruby/object:Gem::Version 
-  version: 0.5.3
-date: 2007-01-21 03:38:07 -05:00
+  version: "0.6"
+date: 2007-01-26 15:22:30 -05:00
 summary: Fast Ruby debugger
 require_paths: 
 - lib
@@ -57,6 +57,7 @@ files:
 - lib/ruby-debug/commands/variables.rb
 - ext/extconf.rb
 - ext/ruby_debug.c
+- ext/tags
 - ext/win32
 - bin/rdebug
 test_files: []