ruby-debug-base 0.10.0-mswin32 → 0.10.4-mswin32

data/ext/extconf.rb

@@ -15,4 +15,6 @@ else
   exit(1)
 end
 
+# Temporary: to turn off optimization
+# $CFLAGS='-fno-strict-aliasing -g -fPIC'
 create_makefile("ruby_debug")

data/ext/ruby_debug.c

@@ -1,11 +1,12 @@
+#include "ruby_debug.h"
+
 #include <stdio.h>
-#include <ruby.h>
 #include <node.h>
 #include <rubysig.h>
 #include <st.h>
-#include <version.h>
+#include <intern.h>
 
-#define DEBUG_VERSION "0.10.0"
+#define DEBUG_VERSION "0.10.4"
 
 #ifdef _WIN32
 struct FRAME {
@@ -43,21 +44,6 @@ RUBY_EXTERN struct RVarmap *ruby_dyna_vars;
 #include <env.h>
 #endif
 
-#define CTX_FL_SUSPEND      (1<<1)
-#define CTX_FL_TRACING      (1<<2)
-#define CTX_FL_SKIPPED      (1<<3)
-#define CTX_FL_IGNORE       (1<<4)
-#define CTX_FL_DEAD         (1<<5)
-#define CTX_FL_WAS_RUNNING  (1<<6)
-#define CTX_FL_ENABLE_BKPT  (1<<7)
-#define CTX_FL_STEPPED      (1<<8)
-#define CTX_FL_FORCE_MOVE   (1<<9)
-
-#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 IS_STARTED  (threads_tbl != Qnil)
 #define FRAME_N(n)  (&debug_context->frames[debug_context->stack_size-(n)-1])
 #define GET_FRAME   (FRAME_N(check_frame_number(debug_context, frame)))
 
@@ -67,75 +53,10 @@ RUBY_EXTERN struct RVarmap *ruby_dyna_vars;
 
 #define STACK_SIZE_INCREMENT 128
 
-typedef struct {
-    int argc;         /* Number of arguments a frame should have. */
-    VALUE binding;
-    ID id;
-    ID orig_id;
-    int line;
-    const char * file;
-    short dead;
-    VALUE self;
-    VALUE arg_ary;
-    union {
-        struct {
-            struct FRAME *frame;
-            struct SCOPE *scope;
-            struct RVarmap *dyna_vars;
-        } runtime;
-        struct {
-            VALUE args;
-            VALUE locals;
-	    VALUE arg_ary;
-        } copy;
-    } info;
-} debug_frame_t;
-
-enum ctx_stop_reason {CTX_STOP_NONE, CTX_STOP_STEP, CTX_STOP_BREAKPOINT, CTX_STOP_CATCHPOINT};
-
-typedef struct {
-    VALUE thread_id;
-    int thnum;
-    int flags;
-    enum ctx_stop_reason stop_reason;
-    int stop_next;
-    int dest_frame;
-    int stop_line;
-    int stop_frame;
-    int stack_size;
-    int stack_len;
-    debug_frame_t *frames;
-    const char * last_file;
-    int last_line;
-    VALUE breakpoint;
-} debug_context_t;
-
-enum bp_type {BP_POS_TYPE, BP_METHOD_TYPE};
-enum hit_condition {HIT_COND_NONE, HIT_COND_GE, HIT_COND_EQ, HIT_COND_MOD};
-
-typedef struct {
-    int   id;
-    enum bp_type type;
-    VALUE source;
-    union
-    {
-        int line;
-        ID  mid;
-    } pos;
-    VALUE expr;
-    VALUE enabled;
-    int hit_count;
-    int hit_value;
-    enum hit_condition hit_condition;
-} 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 tracing            = Qfalse;
 static VALUE locker             = Qnil;
 static VALUE post_mortem        = Qfalse;
@@ -147,20 +68,21 @@ static VALUE last_context = Qnil;
 static VALUE last_thread  = Qnil;
 static debug_context_t *last_debug_context = NULL;
 
-static VALUE mDebugger;
+VALUE rdebug_threads_tbl = Qnil; /* Context for each of the threads */
+VALUE mDebugger;                 /* Ruby Debugger Module object */
+
 static VALUE cThreadsTable;
 static VALUE cContext;
-static VALUE cBreakpoint;
 static VALUE cDebugThread;
 
 static VALUE rb_mObjectSpace;
 
-static ID idAtLine;
 static ID idAtBreakpoint;
 static ID idAtCatchpoint;
+static ID idAtLine;
+static ID idAtReturn;
 static ID idAtTracing;
 static ID idList;
-static ID idEval;
 
 static int start_count = 0;
 static int thnum_max = 0;
@@ -186,6 +108,17 @@ typedef struct locked_thread_t {
 static locked_thread_t *locked_head = NULL;
 static locked_thread_t *locked_tail = NULL;
 
+/* "Step", "Next" and "Finish" do their work by saving information
+   about where to stop next. reset_stopping_points removes/resets this
+   information. */
+inline static void
+reset_stepping_stop_points(debug_context_t *debug_context)
+{
+    debug_context->dest_frame = -1;
+    debug_context->stop_line  = -1;
+    debug_context->stop_next  = -1;
+}
+
 inline static VALUE
 real_class(VALUE klass)
 {
@@ -379,7 +312,7 @@ check_thread_contexts()
 {
     threads_table_t *threads_table;
 
-    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    Data_Get_Struct(rdebug_threads_tbl, threads_table_t, threads_table);
     st_foreach(threads_table->tbl, threads_table_check_i, 0);
 }
 
@@ -395,15 +328,6 @@ debug_is_started(VALUE self)
     return IS_STARTED ? Qtrue : Qfalse;
 }
 
-static void
-debug_check_started()
-{
-    if(!IS_STARTED)
-    {
-        rb_raise(rb_eRuntimeError, "Debugger.start is not called yet.");
-    }
-}
-
 static void
 debug_context_mark(void *data)
 {
@@ -416,6 +340,7 @@ debug_context_mark(void *data)
         frame = &(debug_context->frames[i]);
         rb_gc_mark(frame->binding);
         rb_gc_mark(frame->self);
+        rb_gc_mark(frame->arg_ary);
         if(frame->dead)
         {
             rb_gc_mark(frame->info.copy.locals);
@@ -505,7 +430,7 @@ thread_context_lookup(VALUE thread, VALUE *context, debug_context_t **debug_cont
         return;
     }
     thread_id = ref2id(thread);
-    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    Data_Get_Struct(rdebug_threads_tbl, threads_table_t, threads_table);
     if(!st_lookup(threads_table->tbl, thread_id, context))
     {
         *context = debug_context_create(thread);
@@ -554,7 +479,7 @@ save_call_frame(rb_event_t event, VALUE self, char *file, int line, ID mid, debu
     if(frame_n >= debug_context->stack_len)
     {
         debug_context->stack_len += STACK_SIZE_INCREMENT;
-        debug_context->frames = REALLOC_N(debug_context->frames, debug_frame_t, debug_context->stack_len);
+        REALLOC_N(debug_context->frames, debug_frame_t, debug_context->stack_len);
     }
     debug_frame = &debug_context->frames[frame_n];
     debug_frame->argc = ruby_frame->argc;
@@ -565,6 +490,7 @@ save_call_frame(rb_event_t event, VALUE self, char *file, int line, ID mid, debu
     debug_frame->orig_id = mid;
     debug_frame->dead = 0;
     debug_frame->self = self;
+    debug_frame->arg_ary = Qnil;
     debug_frame->info.runtime.frame = ruby_frame;
     debug_frame->info.runtime.scope = ruby_scope;
     debug_frame->info.runtime.dyna_vars = event == RUBY_EVENT_LINE ? ruby_dyna_vars : NULL;
@@ -579,7 +505,7 @@ save_call_frame(rb_event_t event, VALUE self, char *file, int line, ID mid, debu
 #define isdirsep(x) ((x) == '/')
 #endif
 
-static int
+int
 filename_cmp(VALUE source, char *file)
 {
     char *source_ptr, *file_ptr;
@@ -606,136 +532,10 @@ filename_cmp(VALUE source, char *file)
     return 1;
 }
 
-inline static int
-classname_cmp(VALUE name, VALUE klass)
-{
-    VALUE class_name = (Qnil == name) ? rb_str_new2("main") : name;
-    return (klass != Qnil 
-	    && rb_str_cmp(class_name, rb_mod_name(klass)) == 0);
-}
-
-static int
-check_breakpoint_hit_condition(VALUE breakpoint)
-{
-    debug_breakpoint_t *debug_breakpoint;
-    
-    if(breakpoint == Qnil)
-        return 0;
-    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
-
-    debug_breakpoint->hit_count++;
-    if (!Qtrue == debug_breakpoint->enabled) return 0;
-    switch(debug_breakpoint->hit_condition)
-    {
-        case HIT_COND_NONE:
-            return 1;
-        case HIT_COND_GE:
-        {
-            if(debug_breakpoint->hit_count >= debug_breakpoint->hit_value)
-                return 1;
-            break;
-        }
-        case HIT_COND_EQ:
-        {
-            if(debug_breakpoint->hit_count == debug_breakpoint->hit_value)
-                return 1;
-            break;
-        }
-        case HIT_COND_MOD:
-        {
-            if(debug_breakpoint->hit_count % debug_breakpoint->hit_value == 0)
-                return 1;
-            break;
-        }
-    }
-    return 0;
-}
-
-static int
-check_breakpoint_by_pos(VALUE breakpoint, char *file, int line)
-{
-    debug_breakpoint_t *debug_breakpoint;
-
-    if(breakpoint == Qnil)
-        return 0;
-    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
-    if (!Qtrue == debug_breakpoint->enabled) return 0;
-    if(debug_breakpoint->type != BP_POS_TYPE)
-        return 0;
-    if(debug_breakpoint->pos.line != line)
-        return 0;
-    if(filename_cmp(debug_breakpoint->source, file))
-        return 1;
-    return 0;
-}
-
-static int
-check_breakpoint_by_method(VALUE breakpoint, VALUE klass, ID mid)
-{
-    debug_breakpoint_t *debug_breakpoint;
-
-    if(breakpoint == Qnil)
-        return 0;
-    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
-    if (!Qtrue == debug_breakpoint->enabled) return 0;
-    if(debug_breakpoint->type != BP_METHOD_TYPE)
-        return 0;
-    if(debug_breakpoint->pos.mid != mid)
-        return 0;
-    if(classname_cmp(debug_breakpoint->source, klass))
-        return 1;
-    return 0;
-}
-
-static VALUE
-check_breakpoints_by_pos(debug_context_t *debug_context, char *file, int line)
-{
-    VALUE breakpoint;
-    int i;
-
-    if(!CTX_FL_TEST(debug_context, CTX_FL_ENABLE_BKPT))
-        return Qnil;
-    
-    if(check_breakpoint_by_pos(debug_context->breakpoint, file, line))
-        return debug_context->breakpoint;
-
-    if(RARRAY(breakpoints)->len == 0)
-        return Qnil;
-    for(i = 0; i < RARRAY(breakpoints)->len; i++)
-    {
-        breakpoint = rb_ary_entry(breakpoints, i);
-        if(check_breakpoint_by_pos(breakpoint, file, line))
-            return breakpoint;
-    }
-    return Qnil;
-}
-
-static VALUE
-check_breakpoints_by_method(debug_context_t *debug_context, VALUE klass, ID mid)
-{
-    VALUE breakpoint;
-    int i;
-
-    if(!CTX_FL_TEST(debug_context, CTX_FL_ENABLE_BKPT))
-        return Qnil;
-        
-    if(check_breakpoint_by_method(debug_context->breakpoint, klass, mid))
-        return debug_context->breakpoint;
-
-    if(RARRAY(breakpoints)->len == 0)
-        return Qnil;
-    for(i = 0; i < RARRAY(breakpoints)->len; i++)
-    {
-        breakpoint = rb_ary_entry(breakpoints, i);
-        if(check_breakpoint_by_method(breakpoint, klass, mid))
-            return breakpoint;
-    }
-    return Qnil;
-}
-
 /*
- * This is a NASTY HACK. For some reasons rb_f_binding is declared
- * static in eval.c. So we create a cons up call to binding in C.
+ * A nasty hack to be able to get at the +Kernel.binding+ method.
+ * +rb_f_binding+ is declared static in eval.c. So copy and save our own value
+ * of it by looking up the method name in the Kernel module.
  */
 static VALUE
 create_binding(VALUE self)
@@ -750,27 +550,6 @@ create_binding(VALUE self)
     return f_binding(self);
 }
 
-static VALUE
-eval_expression(VALUE args)
-{
-    return rb_funcall2(rb_mKernel, idEval, 2, RARRAY(args)->ptr);
-}
-
-inline static int
-check_breakpoint_expression(VALUE breakpoint, VALUE binding)
-{
-    debug_breakpoint_t *debug_breakpoint;
-    VALUE args, expr_result;
-
-    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
-    if(NIL_P(debug_breakpoint->expr))
-        return 1;
-
-    args = rb_ary_new3(2, debug_breakpoint->expr, binding);
-    expr_result = rb_protect(eval_expression, args, 0);
-    return RTEST(expr_result);
-}
-
 inline static debug_frame_t *
 get_top_frame(debug_context_t *debug_context)
 {
@@ -921,11 +700,31 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
       if(debug == Qtrue)
           fprintf(stderr, "%s:%d [%s] %s\n", file, line, get_event_name(event), rb_id2name(mid));
 
+      /* There can be many event calls per line, but we only want
+      *one* breakpoint per line. */
       if(debug_context->last_line != line || debug_context->last_file == NULL ||
           strcmp(debug_context->last_file, file) != 0)
       {
           CTX_FL_SET(debug_context, CTX_FL_ENABLE_BKPT);
           moved = 1;
+      } 
+      else if(event == RUBY_EVENT_LINE)
+      {
+        /* There are two line-event trace hook calls per IF node - one
+          before the expression eval an done afterwards. 
+        */
+        /* FIXME: the static variable can't be safely used here, since this method 
+        is re-entrant by multiple threads. If we want to provide this kind of functionality 
+        if_eval_event variable must be moved to debug_context structure.
+        */
+        /*
+        static int if_eval_event = 0;
+        if_eval_event = (NODE_IF == nd_type(node)) ? !if_eval_event : 0;
+        if (!if_eval_event)
+        {
+            CTX_FL_SET(debug_context, CTX_FL_ENABLE_BKPT);
+        }
+        */
       }
     }
     else if(event != RUBY_EVENT_RETURN && event != RUBY_EVENT_C_RETURN)
@@ -999,11 +798,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
                     debug_context->breakpoint = Qnil;
             }
 
-            /* reset all pointers */
-            debug_context->dest_frame = -1;
-            debug_context->stop_line = -1;
-            debug_context->stop_next = -1;
-
+            reset_stepping_stop_points(debug_context);
             call_at_line(context, debug_context, rb_str_new2(file), INT2FIX(line));
         }
         break;
@@ -1011,7 +806,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     case RUBY_EVENT_CALL:
     {
         save_call_frame(event, self, file, line, mid, debug_context);
-        breakpoint = check_breakpoints_by_method(debug_context, klass, mid);
+        breakpoint = check_breakpoints_by_method(debug_context, klass, mid, self);
         if(breakpoint != Qnil)
         {
             debug_frame_t *debug_frame;
@@ -1058,6 +853,9 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         {
             debug_context->stop_next = 1;
             debug_context->stop_frame = 0;
+            /* NOTE: can't use call_at_line function here to trigger a debugger event.
+               this can lead to segfault. We should only unroll the stack on this event.
+             */
         }
         while(debug_context->stack_size > 0)
         {
@@ -1092,21 +890,48 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         }
 
         expn_class = rb_obj_class(ruby_errinfo);
+
+	/* This code goes back to the earliest days of ruby-debug. It
+	   tends to disallow catching an exception via the
+	   "catchpoint" command. To address this one possiblilty is to
+	   move this after testing for catchponts. Kent however thinks
+	   there may be a misfeature in Ruby's eval.c: the problem was
+	   in the fact that Ruby doesn't reset exception flag on the
+	   current thread before it calls a notification handler.
+
+	   See also the #ifdef'd code below as well.
+	 */
+#ifdef NORMAL_CODE
         if( !NIL_P(rb_class_inherited_p(expn_class, rb_eSystemExit)) )
         {
             debug_stop(mDebugger);
             break;
         }
+#endif
 
-        if(catchpoint == Qnil)
+        if (rdebug_catchpoints == Qnil || 
+        RHASH(rdebug_catchpoints)->tbl->num_entries == 0)
             break;
 
         ancestors = rb_mod_ancestors(expn_class);
         for(i = 0; i < RARRAY(ancestors)->len; i++)
         {
-            aclass = rb_ary_entry(ancestors, i);
-            if(rb_str_cmp(rb_mod_name(aclass), catchpoint) == 0)
+            VALUE mod_name;
+            VALUE hit_count;
+
+            aclass    = rb_ary_entry(ancestors, i);
+            mod_name  = rb_mod_name(aclass);
+            hit_count = rb_hash_aref(rdebug_catchpoints, mod_name);
+            if(hit_count != Qnil)
             {
+		/* On 64-bit systems with gcc and -O2 there seems to be
+		   an optimization bug in running INT2FIX(FIX2INT...)..)
+		   So we do this in two steps.
+		*/
+		int c_hit_count = FIX2INT(rb_hash_aref(rdebug_catchpoints, 
+						       mod_name)) + 1;
+                hit_count = INT2FIX(c_hit_count);
+                rb_hash_aset(rdebug_catchpoints, mod_name, hit_count);
                 debug_context->stop_reason = CTX_STOP_CATCHPOINT;
                 rb_funcall(context, idAtCatchpoint, 1, ruby_errinfo);
                 if(self && binding == Qnil)
@@ -1117,6 +942,18 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             }
         }
 
+	/* If we stop the debugger, we may not be able to trace into
+	   code that has an exception handler wrapped around it. So
+	   the alternative is to force the user to do his own
+	   Debugger.stop. */
+#ifdef NORMAL_CODE_MOVING_AFTER_
+        if( !NIL_P(rb_class_inherited_p(expn_class, rb_eSystemExit)) )
+        {
+            debug_stop(mDebugger);
+            break;
+        }
+#endif
+
         break;
     }
     }
@@ -1150,16 +987,29 @@ debug_stop_i(VALUE self)
 
 /*
  *   call-seq:
- *      Debugger.start -> bool
- *      Debugger.start { ... } -> obj
+ *      Debugger.start_ -> bool
+ *      Debugger.start_ { ... } -> bool
  *
- *   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. When the block is finished
- *   executing it stops the debugger with Debugger.stop method.
+ *   This method is internal and activates the debugger. Use
+ *   Debugger.start (from <tt>lib/ruby-debug-base.rb</tt>) instead.
+ *
+ *   The return value is the value of !Debugger.started? <i>before</i>
+ *   issuing the +start+; That is, +true+ is returned, unless debugger
+ *   was previously started.
+
+ *   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. Inside the block you will probably want to
+ *   have a call to Debugger.debugger. For example:
+ *     Debugger.start{debugger; foo}  # Stop inside of foo
+ * 
+ *   Also, ruby-debug only allows
+ *   one invocation of debugger at a time; nested Debugger.start's
+ *   have no effect and you can't use this inside the debugger itself.
  *
- *   <i>Note that if you want to stop debugger, you must call Debugger.stop as many time as you
- *   called Debugger.start method.</i>
+ *   <i>Note that if you want to completely remove the debugger hook,
+ *   you must call Debugger.stop as many times as you called
+ *   Debugger.start method.</i>
  */
 static VALUE
 debug_start(VALUE self)
@@ -1171,16 +1021,18 @@ debug_start(VALUE self)
         result = Qfalse;
     else
     {
-        breakpoints = rb_ary_new();
-        locker      = Qnil;
-        threads_tbl = threads_table_create();
+        locker             = Qnil;
+        rdebug_breakpoints = rb_ary_new();
+        rdebug_catchpoints = rb_hash_new();
+        rdebug_threads_tbl = threads_table_create();
 
         rb_add_event_hook(debug_event_hook, RUBY_EVENT_ALL);
         result = Qtrue;
     }
 
-    if(rb_block_given_p())
-        return rb_ensure(rb_yield, self, debug_stop_i, self);
+    if(rb_block_given_p()) 
+      rb_ensure(rb_yield, self, debug_stop_i, self);
+
     return result;
 }
 
@@ -1191,9 +1043,9 @@ debug_start(VALUE self)
  *   This method disables the debugger. It returns +true+ if the debugger is disabled,
  *   otherwise it returns +false+.
  *
- *   <i>Note that if you want to stop debugger, you must call
- *   Debugger.stop as many times as you called Debugger.start
- *   method.</i>
+ *   <i>Note that if you want to complete remove the debugger hook,
+ *   you must call Debugger.stop as many times as you called
+ *   Debugger.start method.</i>
  */
 static VALUE
 debug_stop(VALUE self)
@@ -1206,156 +1058,13 @@ debug_stop(VALUE self)
 
     rb_remove_event_hook(debug_event_hook);
 
-    locker      = Qnil;
-    breakpoints = Qnil;
-    threads_tbl = Qnil;
+    locker             = Qnil;
+    rdebug_breakpoints = Qnil;
+    rdebug_threads_tbl = Qnil;
 
     return Qtrue;
 }
 
-static void
-breakpoint_mark(void *data)
-{
-    debug_breakpoint_t *breakpoint;
-    breakpoint = (debug_breakpoint_t *)data;
-    rb_gc_mark(breakpoint->source);
-    rb_gc_mark(breakpoint->expr);
-}
-
-static VALUE
-create_breakpoint_from_args(int argc, VALUE *argv, int id)
-{
-    VALUE source, pos, expr;
-    debug_breakpoint_t *breakpoint;
-    int type;
-
-    if(rb_scan_args(argc, argv, "21", &source, &pos, &expr) == 2)
-    {
-        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->id = id;
-    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->enabled = Qtrue;
-    breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
-    breakpoint->hit_count = 0;
-    breakpoint->hit_value = 0;
-    breakpoint->hit_condition = HIT_COND_NONE;
-    return Data_Wrap_Struct(cBreakpoint, breakpoint_mark, xfree, breakpoint);
-}
-
-/*
- *   call-seq:
- *      Debugger.add_breakpoint(source, pos, condition = nil) -> breakpoint
- *
- *   Adds a new breakpoint.
- *   <i>source</i> is a name of a file or a class.
- *   <i>pos</i> is a line number or a method name if <i>source</i> is a class name.
- *   <i>condition</i> is a string which is evaluated to +true+ when this breakpoint
- *   is activated.
- */
-static VALUE
-debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
-{
-    VALUE result;
-
-    debug_check_started();
-
-    result = create_breakpoint_from_args(argc, argv, ++bkp_count);
-    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
- *
- *   Returns an array of breakpoints.
- */
-static VALUE
-debug_breakpoints(VALUE self)
-{
-    debug_check_started();
-
-    return breakpoints;
-}
-
-/*
- *   call-seq:
- *      Debugger.checkpoint -> string
- *
- *   Returns a current checkpoint, which is a name of exception that will
- *   trigger a debugger when raised.
- */
-static VALUE
-debug_catchpoint(VALUE self)
-{
-    debug_check_started();
-
-    return catchpoint;
-}
-
-/*
- *   call-seq:
- *      Debugger.checkpoint = string -> string
- *
- *   Sets checkpoint.
- */
-static VALUE
-debug_set_catchpoint(VALUE self, VALUE value)
-{
-    debug_check_started();
-
-    if (!NIL_P(value) && TYPE(value) != T_STRING) {
-        rb_raise(rb_eTypeError, "value of checkpoint must be String");
-    }
-    if(NIL_P(value))
-    catchpoint = Qnil;
-    else
-    catchpoint = rb_str_dup(value);
-    return value;
-}
-
 static int
 find_last_context_func(VALUE key, VALUE value, VALUE *result)
 {
@@ -1383,7 +1092,7 @@ debug_last_interrupted(VALUE self)
 
     debug_check_started();
 
-    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    Data_Get_Struct(rdebug_threads_tbl, threads_table_t, threads_table);
 
     st_foreach(threads_table->tbl, find_last_context_func, (st_data_t)&result);
     return result;
@@ -1451,8 +1160,8 @@ debug_contexts(VALUE self)
         thread_context_lookup(thread, &context, NULL);
         rb_ary_push(new_list, context);
     }
-    threads_table_clear(threads_tbl);
-    Data_Get_Struct(threads_tbl, threads_table_t, threads_table);
+    threads_table_clear(rdebug_threads_tbl);
+    Data_Get_Struct(rdebug_threads_tbl, threads_table_t, threads_table);
     for(i = 0; i < RARRAY(new_list)->len; i++)
     {
         context = rb_ary_entry(new_list, i);
@@ -1665,30 +1374,57 @@ debug_thread_inherited(VALUE klass)
 
 /*
  *   call-seq:
- *      Debugger.debug_load(file, stop = false) -> nil
+ *      Debugger.debug_load(file, stop = false, increment_start = false) -> nil
  *
  *   Same as Kernel#load but resets current context's frames.
- *   +stop+ parameter force the debugger to stop at the first line of code in the +file+
+ *   +stop+ parameter forces the debugger to stop at the first line of code in the +file+
+ *   +increment_start+ determines if start_count should be incremented. When
+ *    control threads are used, they have to be set up before loading the
+ *    debugger; so here +increment_start+ will be false.    
  *   FOR INTERNAL USE ONLY.
  */
 static VALUE
 debug_debug_load(int argc, VALUE *argv, VALUE self)
 {
-    VALUE file, stop, context;
+    VALUE file, stop, context, increment_start;
     debug_context_t *debug_context;
-
-    if(rb_scan_args(argc, argv, "11", &file, &stop) == 1)
-      stop = Qfalse;
+    int state = 0;
+    
+    if(rb_scan_args(argc, argv, "12", &file, &stop, &increment_start) == 1) 
+    {
+	stop = Qfalse;
+	increment_start = Qtrue;
+    }
 
     debug_start(self);
+    if (Qfalse == increment_start) start_count--;
+    
     context = debug_current_context(self);
     Data_Get_Struct(context, debug_context_t, debug_context);
     debug_context->stack_size = 0;
     if(RTEST(stop))
       debug_context->stop_next = 1;
-    rb_load(file, 0);
+    /* Initializing $0 to the script's path */
+    ruby_script(RSTRING(file)->ptr);
+    rb_load_protect(file, 0, &state);
+    if (0 != state) {
+      VALUE errinfo = ruby_errinfo;
+      debug_suspend(self);
+      reset_stepping_stop_points(debug_context);
+      ruby_errinfo = Qnil;
+      return errinfo;
+    }
+
+    /* We should run all at_exit handler's in order to provide, 
+     * for instance, a chance to run all defined test cases */
+    rb_exec_end_proc();
+
+    /* We could have issued a Debugger.stop inside the debug
+       session. */
+    if (start_count > 0) {
+      debug_stop(self);
+    }
 
-    debug_stop(self);
     return Qnil;
 }
 
@@ -1836,7 +1572,7 @@ context_step_over(int argc, VALUE *argv, VALUE self)
  *   call-seq:
  *      context.stop_frame(frame)
  *
- *   Stops when a frame with number +frame+ is activated. Implements +up+ and +down+ commands.
+ *   Stops when a frame with number +frame+ is activated. Implements +finish+ and +next+ commands.
  */
 static VALUE
 context_stop_frame(VALUE self, VALUE frame)
@@ -2341,7 +2077,7 @@ context_tracing(VALUE self)
 
 /*
  *   call-seq:
- *      context.tracking = bool
+ *      context.tracing = bool
  *
  *   Controls the tracing for this context.
  */
@@ -2395,50 +2131,6 @@ context_dead(VALUE self)
     return CTX_FL_TEST(debug_context, CTX_FL_DEAD) ? Qtrue : Qfalse;
 }
 
-/*
- *   call-seq:
- *      context.breakpoint -> breakpoint
- *
- *   Returns a context-specific temporary Breakpoint object.
- */
-static VALUE
-context_breakpoint(VALUE self)
-{
-    debug_context_t *debug_context;
-
-    debug_check_started();
-
-    Data_Get_Struct(self, debug_context_t, debug_context);
-    return debug_context->breakpoint;
-}
-
-/*
- *   call-seq:
- *      context.set_breakpoint(source, pos, condition = nil) -> breakpoint
- *
- *   Sets a context-specific temporary breakpoint, which can be used to implement
- *   'Run to Cursor' debugger function. When this breakpoint is reached, it will be
- *   cleared out.
- *
- *   <i>source</i> is a name of a file or a class.
- *   <i>pos</i> is a line number or a method name if <i>source</i> is a class name.
- *   <i>condition</i> is a string which is evaluated to +true+ when this breakpoint
- *   is activated.
- */
-static VALUE
-context_set_breakpoint(int argc, VALUE *argv, VALUE self)
-{
-    VALUE result;
-    debug_context_t *debug_context;
-
-    debug_check_started();
-
-    Data_Get_Struct(self, debug_context_t, debug_context);
-    result = create_breakpoint_from_args(argc, argv, 0);
-    debug_context->breakpoint = result;
-    return result;
-}
-
 /*
  *   call-seq:
  *      context.stop_reason -> sym
@@ -2478,262 +2170,13 @@ context_stop_reason(VALUE self)
 }
 
 
-/*
- *   call-seq:
- *      breakpoint.enabled?
- *
- *   Returns whether breakpoint is enabled or not.
- */
-static VALUE
-breakpoint_enabled(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return breakpoint->enabled;
-}
-
-/*
- *   call-seq:
- *      breakpoint.enabled = bool
- *
- *   Enables or disables breakpoint.
- */
-static VALUE
-breakpoint_set_enabled(VALUE self, VALUE bool)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return breakpoint->enabled = bool;
-}
-
-/*
- *   call-seq:
- *      breakpoint.source -> string
- *
- *   Returns a source of the breakpoint.
- */
-static VALUE
-breakpoint_source(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return breakpoint->source;
-}
-
-/*
- *   call-seq:
- *      breakpoint.source = string
- *
- *   Sets the source of the breakpoint.
- */
-static VALUE
-breakpoint_set_source(VALUE self, VALUE value)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    breakpoint->source = StringValue(value);
-    return value;
-}
-
-/*
- *   call-seq:
- *      breakpoint.pos -> string or int
- *
- *   Returns a position of this breakpoint.
- */
-static VALUE
-breakpoint_pos(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    if(breakpoint->type == BP_METHOD_TYPE)
-        return rb_str_new2(rb_id2name(breakpoint->pos.mid));
-    else
-        return INT2FIX(breakpoint->pos.line);
-}
-
-/*
- *   call-seq:
- *      breakpoint.pos = string or int
- *
- *   Sets the position of this breakpoint.
- */
-static VALUE
-breakpoint_set_pos(VALUE self, VALUE value)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    if(breakpoint->type == BP_METHOD_TYPE)
-    {
-        breakpoint->pos.mid = rb_to_id(StringValue(value));
-    }
-    else
-        breakpoint->pos.line = FIX2INT(value);
-    return value;
-}
-
-/*
- *   call-seq:
- *      breakpoint.expr -> string
- *
- *   Returns a codition expression when this breakpoint should be activated.
- */
-static VALUE
-breakpoint_expr(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return breakpoint->expr;
-}
-
-/*
- *   call-seq:
- *      breakpoint.expr = string
- *
- *   Sets the codition expression when this breakpoint should be activated.
- */
-static VALUE
-breakpoint_set_expr(VALUE self, VALUE value)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    breakpoint->expr = StringValue(value);
-    return value;
-}
-
-/*
- *   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);
-}
-
-/*
- *   call-seq:
- *      breakpoint.hit_count -> int
- *
- *   Returns the hit count of the breakpoint.
- */
-static VALUE
-breakpoint_hit_count(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return INT2FIX(breakpoint->hit_count);
-}
-
-/*
- *   call-seq:
- *      breakpoint.hit_value -> int
- *
- *   Returns the hit value of the breakpoint.
- */
-static VALUE
-breakpoint_hit_value(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    return INT2FIX(breakpoint->hit_value);
-}
-
-/*
- *   call-seq:
- *      breakpoint.hit_value = int
- *
- *   Sets the hit value of the breakpoint.
- */
-static VALUE
-breakpoint_set_hit_value(VALUE self, VALUE value)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    breakpoint->hit_value = FIX2INT(value);
-    return value;
-}
-
-/*
- *   call-seq:
- *      breakpoint.hit_condition -> symbol
- *
- *   Returns the hit condition of the breakpoint:
- *
- *   +nil+ if it is an unconditional breakpoint, or
- *   :greater_or_equal, :equal, :modulo
- */
-static VALUE
-breakpoint_hit_condition(VALUE self)
-{
-    debug_breakpoint_t *breakpoint;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    switch(breakpoint->hit_condition)
-    {
-        case HIT_COND_GE:
-            return ID2SYM(rb_intern("greater_or_equal"));
-        case HIT_COND_EQ:
-            return ID2SYM(rb_intern("equal"));
-        case HIT_COND_MOD:
-            return ID2SYM(rb_intern("modulo"));
-        case HIT_COND_NONE:
-        default:
-            return Qnil;
-    }
-}
-
-/*
- *   call-seq:
- *      breakpoint.hit_condition = symbol
- *
- *   Sets the hit condition of the breakpoint which must be one of the following values:
- *
- *   +nil+ if it is an unconditional breakpoint, or
- *   :greater_or_equal(:ge), :equal(:eq), :modulo(:mod)
- */
-static VALUE
-breakpoint_set_hit_condition(VALUE self, VALUE value)
-{
-    debug_breakpoint_t *breakpoint;
-    ID id_value;
-
-    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
-    id_value = rb_to_id(value);
-    
-    if(rb_intern("greater_or_equal") == id_value || rb_intern("ge") == id_value)
-        breakpoint->hit_condition = HIT_COND_GE;
-    else if(rb_intern("equal") == id_value || rb_intern("eq") == id_value)
-        breakpoint->hit_condition = HIT_COND_EQ;
-    else if(rb_intern("modulo") == id_value || rb_intern("mod") == id_value)
-        breakpoint->hit_condition = HIT_COND_MOD;
-    else
-        rb_raise(rb_eArgError, "Invalid condition parameter");
-    return value;
-}
-
 /*
  *   Document-class: Context
  *
- *   == Summary
- *
- *   Debugger keeps a single instance of this class for each Ruby thread.
+ *   The Debugger module keeps a single instance of this class for
+ *   each Ruby thread. It contains a call-stack information, thread
+ *   information, breakpoint information and the reason the program is
+ *   stopped.
  */
 static void
 Init_context()
@@ -2764,46 +2207,53 @@ Init_context()
     rb_define_method(cContext, "frame_self", context_frame_self, -1);
     rb_define_method(cContext, "stack_size", context_stack_size, 0);
     rb_define_method(cContext, "dead?", context_dead, 0);
-    rb_define_method(cContext, "breakpoint", context_breakpoint, 0);
-    rb_define_method(cContext, "set_breakpoint", context_set_breakpoint, -1);
+    rb_define_method(cContext, "breakpoint", 
+		     context_breakpoint, 0);      /* in breakpoint.c */
+    rb_define_method(cContext, "set_breakpoint", 
+		     context_set_breakpoint, -1); /* in breakpoint.c */
 }
 
 /*
- *   Document-class: Breakpoint
- *
- *   == Summary
+ *   call-seq:
+ *      Debugger.breakpoints -> Array
  *
- *   This class represents a breakpoint. It defines position of the breakpoint and
- *   condition when this breakpoint should be triggered.
+ *   Returns an Array of Breakpoint objects; all the breakpoints that
+ *   have been created.
  */
-static void
-Init_breakpoint()
-{
-    cBreakpoint = rb_define_class_under(mDebugger, "Breakpoint", rb_cObject);
-    rb_define_method(cBreakpoint, "id", breakpoint_id, 0);
-    rb_define_method(cBreakpoint, "source", breakpoint_source, 0);
-    rb_define_method(cBreakpoint, "source=", breakpoint_set_source, 1);
-    rb_define_method(cBreakpoint, "enabled?", breakpoint_enabled, 0);
-    rb_define_method(cBreakpoint, "enabled=", breakpoint_set_enabled, 1);
-    rb_define_method(cBreakpoint, "pos", breakpoint_pos, 0);
-    rb_define_method(cBreakpoint, "pos=", breakpoint_set_pos, 1);
-    rb_define_method(cBreakpoint, "expr", breakpoint_expr, 0);
-    rb_define_method(cBreakpoint, "expr=", breakpoint_set_expr, 1);
-    rb_define_method(cBreakpoint, "hit_count", breakpoint_hit_count, 0);
-    rb_define_method(cBreakpoint, "hit_value", breakpoint_hit_value, 0);
-    rb_define_method(cBreakpoint, "hit_value=", breakpoint_set_hit_value, 1);
-    rb_define_method(cBreakpoint, "hit_condition", breakpoint_hit_condition, 0);
-    rb_define_method(cBreakpoint, "hit_condition=", breakpoint_set_hit_condition, 1);
+static VALUE
+debug_breakpoints(VALUE self)
+{
+    debug_check_started();
+
+    return rdebug_breakpoints;
 }
 
+/*
+ *   call-seq:
+ *      Debugger.add_breakpoint(source, pos, condition = nil) -> breakpoint
+ *
+ *   Adds a new breakpoint.
+ *   <i>source</i> is a name of a file or a class.
+ *   <i>pos</i> is a line number or a method name if <i>source</i> is a class name.
+ *   <i>condition</i> is a string which is evaluated to +true+ when this breakpoint
+ *   is activated.
+ */
+static VALUE
+debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
+{
+    VALUE result;
+
+    debug_check_started();
+
+    result = create_breakpoint_from_args(argc, argv, ++bkp_count);
+    rb_ary_push(rdebug_breakpoints, result);
+    return result;
+}
 
 /*
  *   Document-class: Debugger
  *
- *   == Summary
- *
- *   This is a singleton class allows controlling the debugger. Use it to start/stop debugger,
- *   set/remove breakpoints, etc.
+ *   _Debugger_ is the module name space for ruby-debug.
  */
 #if defined(_WIN32)
 __declspec(dllexport)
@@ -2813,15 +2263,18 @@ Init_ruby_debug()
 {
     mDebugger = rb_define_module("Debugger");
     rb_define_const(mDebugger, "VERSION", rb_str_new2(DEBUG_VERSION));
-    rb_define_module_function(mDebugger, "start", debug_start, 0);
+    rb_define_module_function(mDebugger, "start_", debug_start, 0);
     rb_define_module_function(mDebugger, "stop", debug_stop, 0);
     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);
+			      rdebug_remove_breakpoint, 
+			      1);                        /* in breakpoint.c */
+    rb_define_module_function(mDebugger, "add_catchpoint", 
+			      rdebug_add_catchpoint, 1); /* in breakpoint.c */
+    rb_define_module_function(mDebugger, "catchpoints", 
+			      debug_catchpoints, 0);     /* in breakpoint.c */
     rb_define_module_function(mDebugger, "last_context", debug_last_interrupted, 0);
     rb_define_module_function(mDebugger, "contexts", debug_contexts, 0);
     rb_define_module_function(mDebugger, "current_context", debug_current_context, 0);
@@ -2835,8 +2288,10 @@ 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_binding?", debug_keep_frame_binding, 0);
-    rb_define_module_function(mDebugger, "keep_frame_binding=", debug_set_keep_frame_binding, 1);
+    rb_define_module_function(mDebugger, "keep_frame_binding?", 
+			      debug_keep_frame_binding, 0);
+    rb_define_module_function(mDebugger, "keep_frame_binding=", 
+			      debug_set_keep_frame_binding, 1);
     rb_define_module_function(mDebugger, "track_frame_args?", 
 			      debug_track_frame_args, 0);
     rb_define_module_function(mDebugger, "track_frame_args=", 
@@ -2847,24 +2302,25 @@ Init_ruby_debug()
     cThreadsTable = rb_define_class_under(mDebugger, "ThreadsTable", rb_cObject);
 
     cDebugThread  = rb_define_class_under(mDebugger, "DebugThread", rb_cThread);
-    rb_define_singleton_method(cDebugThread, "inherited", debug_thread_inherited, 1);
+    rb_define_singleton_method(cDebugThread, "inherited", 
+			       debug_thread_inherited, 1);
 
     Init_context();
     Init_breakpoint();
 
-    idAtLine       = rb_intern("at_line");
     idAtBreakpoint = rb_intern("at_breakpoint");
     idAtCatchpoint = rb_intern("at_catchpoint");
+    idAtLine       = rb_intern("at_line");
+    idAtReturn     = rb_intern("at_return");
     idAtTracing    = rb_intern("at_tracing");
-    idEval         = rb_intern("eval");
     idList         = rb_intern("list");
 
     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(&last_context);
     rb_global_variable(&last_thread);
+    rb_global_variable(&locker);
+    rb_global_variable(&rdebug_breakpoints);
+    rb_global_variable(&rdebug_catchpoints);
+    rb_global_variable(&rdebug_threads_tbl);
 }