ruby-debug 0.5.2-mswin32 → 0.6-mswin32

data/CHANGES

@@ -1,3 +1,15 @@
+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.
+
 0.5.2
 - Fixes interoperability problems with rspec.
 - Made 'exit' as an alias to 'quit'

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.2"
+#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,22 +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;
 
@@ -52,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;
@@ -65,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;
@@ -81,21 +91,69 @@ static ID idIndex;
 
 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;
     
@@ -104,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;
 }
@@ -113,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;
@@ -139,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
@@ -166,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;
 }
@@ -211,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
@@ -237,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
@@ -251,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;
@@ -260,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;
 }
@@ -270,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;
 }
@@ -287,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;
@@ -335,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;
@@ -435,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);
 }
@@ -455,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;
@@ -470,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;
     
@@ -517,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);
@@ -531,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 || 
@@ -557,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 */
@@ -577,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;
     }
@@ -589,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;
@@ -627,9 +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_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_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));
         }
@@ -653,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;
             }
         }
@@ -668,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 */
@@ -754,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);
 }
 
@@ -774,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();
     
@@ -781,16 +944,55 @@ 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->pos = pos;
+    breakpoint->id = ++bkp_count;
+    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);
     return result;
 }
 
+/*
+ *   call-seq:
+ *      Debugger.remove_breakpoint(id) -> breakpoint
+ *   
+ *   Removes breakpoint by its id.
+ *   <i>id</i> is an identificator of a breakpoint.
+ */
+static VALUE
+debug_remove_breakpoint(VALUE self, VALUE id_value)
+{
+    int i;
+    int id;
+    VALUE breakpoint;
+    debug_breakpoint_t *debug_breakpoint;
+    
+    id = FIX2INT(id_value);
+    
+    for( i = 0; i < RARRAY(breakpoints)->len; i += 1 )
+    {
+        breakpoint = rb_ary_entry(breakpoints, i);
+        Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+        if(debug_breakpoint->id == id)
+        {
+            rb_ary_delete_at(breakpoints, i);
+            return breakpoint;
+        }
+    }
+    return Qnil;
+}
+
 /*
  *   call-seq:
  *      Debugger.breakpoints -> array
@@ -926,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;
@@ -1001,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;
@@ -1064,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
@@ -1263,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);
 }
 
 /*
@@ -1318,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;
 }
 
@@ -1410,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);
 }
 
 /*
@@ -1425,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);
 }
 
 /*
@@ -1485,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);
 }
 
 /*
@@ -1503,6 +1733,21 @@ breakpoint_expr(VALUE self)
     return breakpoint->expr;
 }
 
+/*
+ *   call-seq:
+ *      breakpoint.id -> int
+ *   
+ *   Returns id of the breakpoint.
+ */
+static VALUE
+breakpoint_id(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+    
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return INT2FIX(breakpoint->id);
+}
+
 /*
  *   Document-class: Context
  *   
@@ -1562,6 +1807,7 @@ Init_breakpoint()
     rb_define_method(cBreakpoint, "source", breakpoint_source, 0);
     rb_define_method(cBreakpoint, "pos", breakpoint_pos, 0);
     rb_define_method(cBreakpoint, "expr", breakpoint_expr, 0);
+    rb_define_method(cBreakpoint, "id", breakpoint_id, 0);
 }
 
 /*
@@ -1585,6 +1831,7 @@ Init_ruby_debug()
     rb_define_module_function(mDebugger, "started?", debug_is_started, 0);
     rb_define_module_function(mDebugger, "breakpoints", debug_breakpoints, 0);
     rb_define_module_function(mDebugger, "add_breakpoint", debug_add_breakpoint, -1);
+    rb_define_module_function(mDebugger, "remove_breakpoint", debug_remove_breakpoint, 1);
     rb_define_module_function(mDebugger, "catchpoint", debug_catchpoint, 0);
     rb_define_module_function(mDebugger, "catchpoint=", debug_set_catchpoint, 1);
     rb_define_module_function(mDebugger, "last_context", debug_last_interrupted, 0);
@@ -1599,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);
     
@@ -1610,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);
 }