ruby-debug-base 0.8.1 → 0.9

data/CHANGES

@@ -1,3 +1,18 @@
+0.9
+- Kernel#debugger method will start the debugger if it's not running.
+- Added Context#stop_reason method.
+- Calling a method with a block will create a new frame. This changes the behavior of 'next' command. So in order to step into a block, 'step' command must be used. That fixes bug #9629.
+- Added the possibility to add a temporary context-specific breakpoint. Context#breakpoint and Context#set_breakpoint methods are added. 
+- 'cont' command now accepts a numerical parameter which implements 'Continue until line' behavior.
+- Added new Context.frame_class method
+- Added new 'framefullpath' setting.
+- Added new 'frameclassname' setting.
+- All Ruby's 'eval' and require/load methods create a new frame. Fixes bug #9686.
+
+0.8.1
+- Added a shortcut module 'debugger'. require "ruby-debug/debugger" will start the debugger and stop at the next line (similar to require 'debug').
+- Fixed remote debugging.
+
 0.8
 - Extract the base debugger API into a separate gem (ruby-debug-base), so it will be easier to add a new interface.
 - Added 'set autoirb' setting.

data/ext/ruby_debug.c

@@ -4,7 +4,7 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.8.1"
+#define DEBUG_VERSION "0.9"
 
 #ifdef _WIN32
 struct FRAME {
@@ -42,16 +42,17 @@ RUBY_EXTERN struct RVarmap *ruby_dyna_vars;
 #include <env.h>
 #endif
 
-#define CTX_FL_MOVED        (1<<1)
-#define CTX_FL_SUSPEND      (1<<2)
-#define CTX_FL_TRACING      (1<<3)
-#define CTX_FL_SKIPPED      (1<<4)
-#define CTX_FL_IGNORE       (1<<5)
-#define CTX_FL_DEAD         (1<<6)
-#define CTX_FL_WAS_RUNNING  (1<<7)
-
-#define CTX_FL_TEST(c,f) ((c)->flags & (f))
-#define CTX_FL_SET(c,f) do { (c)->flags |= (f); } while (0)
+#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_MOVED        (1<<7)
+#define CTX_FL_STEPPED      (1<<8)
+
+#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
+#define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
 #define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
 
 #define DID_MOVED   (debug_context->last_line != line || \
@@ -60,7 +61,7 @@ RUBY_EXTERN struct RVarmap *ruby_dyna_vars;
 
 #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)))
+#define GET_FRAME   (FRAME_N(check_frame_number(debug_context, frame)))
 
 #ifndef min
 #define min(x,y) ((x) < (y) ? (x) : (y))
@@ -88,10 +89,13 @@ typedef struct {
     } info;
 } debug_frame_t;
 
+enum ctx_stop_reason {CTX_STOP_INIT, 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;
@@ -101,13 +105,14 @@ typedef struct {
     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};
 
 typedef struct {
     int   id;
-    int   type;
+    enum bp_type type;
     VALUE source;
     union
     {
@@ -146,8 +151,8 @@ static ID idAtLine;
 static ID idAtBreakpoint;
 static ID idAtCatchpoint;
 static ID idAtTracing;
-static ID idEval;
 static ID idList;
+static ID idEval;
 
 static int start_count = 0;
 static int thnum_max = 0;
@@ -171,6 +176,20 @@ typedef struct locked_thread_t {
 static locked_thread_t *locked_head = NULL;
 static locked_thread_t *locked_tail = NULL;
 
+inline static VALUE
+real_class(VALUE klass)
+{
+    if (klass) {
+        if (TYPE(klass) == T_ICLASS) {
+            return RBASIC(klass)->klass;
+        }
+        else if (FL_TEST(klass, FL_SINGLETON)) {
+            return rb_iv_get(klass, "__attached__");
+        }
+    }
+    return klass;
+}
+
 inline static void *
 ruby_method_ptr(VALUE class, ID meth_id)
 {
@@ -391,6 +410,7 @@ debug_context_mark(void *data)
             rb_gc_mark(frame->info.copy.locals);
         }
     }
+    rb_gc_mark(debug_context->breakpoint);
 }
 
 static void
@@ -416,10 +436,12 @@ debug_context_create(VALUE thread)
     debug_context->dest_frame = -1;
     debug_context->stop_line = -1;
     debug_context->stop_frame = -1;
+    debug_context->stop_reason = CTX_STOP_INIT;
     debug_context->stack_len = STACK_SIZE_INCREMENT;
     debug_context->frames = ALLOC_N(debug_frame_t, STACK_SIZE_INCREMENT);
     debug_context->stack_size = 0;
     debug_context->thread_id = ref2id(thread);
+    debug_context->breakpoint = Qnil;
     if(rb_obj_class(thread) == cDebugThread)
       CTX_FL_SET(debug_context, CTX_FL_IGNORE);
     return Data_Wrap_Struct(cContext, debug_context_mark, debug_context_free, debug_context);
@@ -438,6 +460,7 @@ debug_context_dup(debug_context_t *debug_context)
     new_debug_context->dest_frame = -1;
     new_debug_context->stop_line = -1;
     new_debug_context->stop_frame = -1;
+    new_debug_context->breakpoint = Qnil;
     CTX_FL_SET(new_debug_context, CTX_FL_DEAD);
     new_debug_context->frames = ALLOC_N(debug_frame_t, debug_context->stack_size);
     new_debug_context->stack_len = debug_context->stack_size;
@@ -567,29 +590,43 @@ filename_cmp(VALUE source, char *file)
 }
 
 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(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 VALUE
 check_breakpoints_by_pos(debug_context_t *debug_context, char *file, int line)
 {
     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;
+        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);
-        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;
+        if(check_breakpoint_by_pos(breakpoint, file, line))
+            return breakpoint;
     }
-    return -1;
+    return Qnil;
 }
 
 inline static int
@@ -599,28 +636,43 @@ classname_cmp(VALUE name, VALUE klass)
 }
 
 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(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_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;
+        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);
-        Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
-        if(debug_breakpoint->type != BP_METHOD_TYPE)
-            continue;
-        if(debug_breakpoint->pos.mid != mid)
-            continue;
-        if(classname_cmp(debug_breakpoint->source, klass))
-            return i;
+        if(check_breakpoint_by_method(breakpoint, klass, mid))
+            return breakpoint;
     }
-    return -1;
+    return Qnil;
 }
 
 /*
@@ -640,12 +692,6 @@ create_binding(VALUE self)
     return f_binding(self);
 }
 
-static VALUE
-get_breakpoint_at(int index)
-{
-    return rb_ary_entry(breakpoints, index);
-}
-
 static VALUE
 eval_expression(VALUE args)
 {
@@ -700,6 +746,17 @@ set_frame_source(rb_event_t event, debug_context_t *debug_context, VALUE self, c
     }
 }
 
+inline static void
+reset_frame_mid(debug_context_t *debug_context)
+{
+    debug_frame_t *top_frame;
+    top_frame = get_top_frame(debug_context);
+    if(top_frame)
+    {
+        top_frame->id = 0;
+    }
+}
+
 static void
 save_current_position(debug_context_t *debug_context)
 {
@@ -710,9 +767,10 @@ save_current_position(debug_context_t *debug_context)
     debug_context->last_file = debug_frame->file;
     debug_context->last_line = debug_frame->line;
     CTX_FL_UNSET(debug_context, CTX_FL_MOVED);
+    CTX_FL_UNSET(debug_context, CTX_FL_STEPPED);
 }
 
-static char *
+inline static char *
 get_event_name(rb_event_t event)
 {
   switch (event) {
@@ -737,16 +795,23 @@ get_event_name(rb_event_t event)
   }
 }
 
+inline static int
+c_call_new_frame_p(VALUE klass, ID mid)
+{
+    klass = real_class(klass);
+    if(rb_block_given_p()) return 1;
+    if(klass == rb_cProc || klass == rb_mKernel || klass == rb_cModule) return 1;
+    return 0;
+}
 
 static void
 debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 {
-    VALUE thread, context, breakpoint;
-    VALUE binding = Qnil;
+    VALUE thread, context;
+    VALUE breakpoint = Qnil, binding = Qnil;
     debug_context_t *debug_context;
     char *file = NULL;
     int line = 0;
-    int breakpoint_index = -1;
 
     hook_count++;
 
@@ -806,12 +871,23 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             fprintf(stderr, "return [%s] %s\n", get_event_name(event), rb_id2name(mid));
         goto cleanup;
     }
+    
+    if(event != RUBY_EVENT_LINE)
+        CTX_FL_SET(debug_context, CTX_FL_STEPPED);
 
     switch(event)
     {
     case RUBY_EVENT_LINE:
     {
-        set_frame_source(event, debug_context, self, file, line, mid);
+        
+        if(debug_context->stack_size == 0)
+            save_call_frame(event, self, file, line, mid, debug_context);
+        else
+            set_frame_source(event, debug_context, self, file, line, mid);
+        
+        /* avoid useless step on the beginning of 'if' statement */
+        if(nd_type(node) == NODE_IF)
+            break;
 
         if(RTEST(tracing) || CTX_FL_TEST(debug_context, CTX_FL_TRACING))
             rb_funcall(context, idAtTracing, 2, rb_str_new2(file), INT2FIX(line));
@@ -822,30 +898,37 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             debug_context->stop_next--;
             if(debug_context->stop_next < 0)
                 debug_context->stop_next = -1;
-            /* we check that we actualy moved to another line */
-            if(DID_MOVED)
+            if(CTX_FL_TEST(debug_context, CTX_FL_STEPPED) || CTX_FL_TEST(debug_context, CTX_FL_MOVED))
+            {
                 debug_context->stop_line--;
+                CTX_FL_UNSET(debug_context, CTX_FL_STEPPED);
+            }
         }
         else if(debug_context->stack_size < debug_context->dest_frame)
         {
             debug_context->stop_next = 0;
         }
 
-        if(debug_context->stack_size == 0)
-            save_call_frame(event, self, file, line, mid, debug_context);
-
         if(debug_context->stop_next == 0 || debug_context->stop_line == 0 ||
-            (breakpoint_index = check_breakpoints_by_pos(debug_context, file, line)) != -1)
+            (breakpoint = check_breakpoints_by_pos(debug_context, file, line)) != Qnil)
         {
             binding = self? create_binding(self) : Qnil;
+            save_top_binding(debug_context, binding);
+
+            debug_context->stop_reason = CTX_STOP_STEP;
+
             /* check breakpoint expression */
-            if(breakpoint_index != -1)
+            if(breakpoint != Qnil)
             {
-                breakpoint = get_breakpoint_at(breakpoint_index);
-                if(check_breakpoint_expression(breakpoint, binding))
-                    rb_funcall(context, idAtBreakpoint, 1, breakpoint);
-                else
+                if(!check_breakpoint_expression(breakpoint, binding))
                     break;
+                if(breakpoint != debug_context->breakpoint)
+                {
+                  debug_context->stop_reason = CTX_STOP_BREAKPOINT;
+                  rb_funcall(context, idAtBreakpoint, 1, breakpoint);
+                }
+                else
+                    debug_context->breakpoint = Qnil;
             }
 
             /* reset all pointers */
@@ -853,21 +936,15 @@ 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;
 
-            save_top_binding(debug_context, binding);
             call_at_line(context, debug_context, rb_str_new2(file), INT2FIX(line));
         }
         break;
     }
-    case RUBY_EVENT_C_CALL:
-    {
-        set_frame_source(event, debug_context, self, file, line, mid);
-        break;
-    }
     case RUBY_EVENT_CALL:
     {
         save_call_frame(event, self, file, line, mid, debug_context);
-        breakpoint_index = check_breakpoints_by_method(debug_context, klass, mid);
-        if(breakpoint_index != -1)
+        breakpoint = check_breakpoints_by_method(debug_context, klass, mid);
+        if(breakpoint != Qnil)
         {
             debug_frame_t *debug_frame;
             debug_frame = get_top_frame(debug_context);
@@ -875,16 +952,35 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
                 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);
+
+            if(!check_breakpoint_expression(breakpoint, binding))
+                break;
+            if(breakpoint != debug_context->breakpoint)
             {
-                save_top_binding(debug_context, binding);
+                debug_context->stop_reason = CTX_STOP_BREAKPOINT;
                 rb_funcall(context, idAtBreakpoint, 1, breakpoint);
-                call_at_line(context, debug_context, rb_str_new2(file), INT2FIX(line));
             }
+            else
+                debug_context->breakpoint = Qnil;
+            call_at_line(context, debug_context, rb_str_new2(file), INT2FIX(line));
         }
         break;
     }
+    case RUBY_EVENT_C_CALL:
+    {
+        if(c_call_new_frame_p(klass, mid))
+            save_call_frame(event, self, file, line, mid, debug_context);
+        else
+            set_frame_source(event, debug_context, self, file, line, mid);
+        break;
+    }
+    case RUBY_EVENT_C_RETURN:
+    {
+        /* note if a block is given we fall through! */
+        if(!c_call_new_frame_p(klass, mid))
+            break;
+    }
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_END:
     {
@@ -903,6 +999,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     }
     case RUBY_EVENT_CLASS:
     {
+        reset_frame_mid(debug_context);
         save_call_frame(event, self, file, line, mid, debug_context);
         break;
     }
@@ -939,6 +1036,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             aclass = rb_ary_entry(ancestors, i);
             if(rb_str_cmp(rb_mod_name(aclass), catchpoint) == 0)
             {
+                debug_context->stop_reason = CTX_STOP_CATCHPOINT;
                 rb_funcall(context, idAtCatchpoint, 1, ruby_errinfo);
                 if(self && binding == Qnil)
                     binding = create_binding(self);
@@ -950,10 +1048,6 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
 
         break;
     }
-    case RUBY_EVENT_C_RETURN:
-    {
-        break;
-    }
     }
 
     cleanup:
@@ -1054,26 +1148,13 @@ breakpoint_mark(void *data)
     rb_gc_mark(breakpoint->expr);
 }
 
-/*
- *   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)
+create_breakpoint_from_args(int argc, VALUE *argv, int id)
 {
     VALUE source, pos, expr;
-    VALUE result;
     debug_breakpoint_t *breakpoint;
     int type;
 
-    debug_check_started();
-
     if(rb_scan_args(argc, argv, "21", &source, &pos, &expr) == 2)
     {
         expr = Qnil;
@@ -1084,7 +1165,7 @@ debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
     else
         pos = StringValue(pos);
     breakpoint = ALLOC(debug_breakpoint_t);
-    breakpoint->id = ++bkp_count;
+    breakpoint->id = id;
     breakpoint->source = source;
     breakpoint->type = type;
     if(type == BP_POS_TYPE)
@@ -1092,7 +1173,27 @@ debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
     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);
+    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;
 }
@@ -1552,9 +1653,8 @@ static VALUE
 debug_at_exit(VALUE self)
 {
     VALUE proc;
-    if (!rb_block_given_p()) {
+    if (!rb_block_given_p())
         rb_raise(rb_eArgError, "called without a block");
-    }
     proc = rb_block_proc();
     rb_set_end_proc(debug_at_exit_i, proc);
     return proc;
@@ -1574,7 +1674,7 @@ context_stop_next(VALUE self, VALUE steps)
     debug_check_started();
     Data_Get_Struct(self, debug_context_t, debug_context);
     if(FIX2INT(steps) < 0)
-    rb_raise(rb_eRuntimeError, "Steps argument can't be negative.");
+        rb_raise(rb_eRuntimeError, "Steps argument can't be negative.");
     debug_context->stop_next = FIX2INT(steps);
 
     return steps;
@@ -1599,6 +1699,7 @@ context_step_over(int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "11", &lines, &frame);
     debug_context->stop_line = FIX2INT(lines);
+    CTX_FL_UNSET(debug_context, CTX_FL_STEPPED);
     if(argc == 1)
     {
         debug_context->dest_frame = debug_context->stack_size;
@@ -1663,7 +1764,7 @@ context_frame_binding(VALUE self, VALUE frame)
 
 /*
  *   call-seq:
- *      context.frame_id(frame) -> sym
+ *      context.frame_method(frame) -> sym
  *
  *   Returns the sym of the called method.
  */
@@ -1790,6 +1891,36 @@ context_frame_self(VALUE self, VALUE frame)
     return debug_frame->self;
 }
 
+/*
+ *   call-seq:
+ *      context.frame_class(frame) -> obj
+ *
+ *   Returns the real class of the frame. 
+ *   It could be different than context.frame_self(frame).class
+ */
+static VALUE
+context_frame_class(VALUE self, VALUE frame)
+{
+    debug_context_t *debug_context;
+    debug_frame_t *debug_frame;
+    VALUE klass;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+
+    debug_frame = GET_FRAME;
+    
+    if(CTX_FL_TEST(debug_context, CTX_FL_DEAD))
+        return Qnil;
+    
+    klass = debug_frame->info.runtime.frame->last_class;
+    klass = real_class(klass);
+    if(TYPE(klass) == T_CLASS || TYPE(klass) == T_MODULE)
+        return klass;
+    return Qnil;
+}
+
+
 /*
  *   call-seq:
  *      context.stack_size-> int
@@ -1977,7 +2108,7 @@ context_ignored(VALUE self)
 
 /*
  *   call-seq:
- *      context.dead? = bool
+ *      context.dead? -> bool
  *
  *   Returns +true+ if context doesn't represent a live context and is created
  *   during post-mortem exception handling.
@@ -1993,6 +2124,89 @@ 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
+ *   
+ *   Returns the reason for the stop. It maybe of the following values:
+ *   :initial, :step, :breakpoint, :catchpoint, :post-mortem
+ */
+static VALUE
+context_stop_reason(VALUE self)
+{
+    debug_context_t *debug_context;
+    char * sym_name;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    
+    switch(debug_context->stop_reason)
+    {
+        case CTX_STOP_STEP:
+            sym_name = "step";
+            break;
+        case CTX_STOP_BREAKPOINT:
+            sym_name = "breakpoint";
+            break;
+        case CTX_STOP_CATCHPOINT:
+            sym_name = "catchpoint";
+            break;
+        case CTX_STOP_INIT:
+        default:
+            sym_name = "initial";
+    }
+    if(CTX_FL_TEST(debug_context, CTX_FL_DEAD))
+        sym_name = "post-mortem";
+    
+    return ID2SYM(rb_intern(sym_name));
+}
+
+
 /*
  *   call-seq:
  *      breakpoint.source -> string
@@ -2072,6 +2286,7 @@ Init_context()
     rb_define_method(cContext, "stop_frame=", context_stop_frame, 1);
     rb_define_method(cContext, "thread", context_thread, 0);
     rb_define_method(cContext, "thnum", context_thnum, 0);
+    rb_define_method(cContext, "stop_reason", context_stop_reason, 0);
     rb_define_method(cContext, "suspend", context_suspend, 0);
     rb_define_method(cContext, "suspended?", context_is_suspended, 0);
     rb_define_method(cContext, "resume", context_resume, 0);
@@ -2080,12 +2295,16 @@ Init_context()
     rb_define_method(cContext, "ignored?", context_ignored, 0);
     rb_define_method(cContext, "frame_binding", context_frame_binding, 1);
     rb_define_method(cContext, "frame_id", context_frame_id, 1);
+    rb_define_method(cContext, "frame_method", context_frame_id, 1);
     rb_define_method(cContext, "frame_line", context_frame_line, 1);
     rb_define_method(cContext, "frame_file", context_frame_file, 1);
     rb_define_method(cContext, "frame_locals", context_frame_locals, 1);
     rb_define_method(cContext, "frame_self", context_frame_self, 1);
+    rb_define_method(cContext, "frame_class", context_frame_class, 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);
 }
 
 /*

data/lib/ruby-debug-base.rb

@@ -181,6 +181,7 @@ module Kernel
   # Stops the current thread after a number of _steps_ made.
   #
   def debugger(steps = 1)
+    Debugger.start unless Debugger.started?
     Debugger.current_context.stop_next = steps
   end
   

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: ruby-debug-base
 version: !ruby/object:Gem::Version 
-  version: 0.8.1
-date: 2007-03-19 03:56:11 -04:00
+  version: "0.9"
+date: 2007-04-01 12:48:34 -04:00
 summary: Fast Ruby debugger
 require_paths: 
 - lib