ruby-debug-base19 0.11.18 → 0.11.19

data/ext/ruby_debug/ruby_debug.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
 #include <stdio.h>
+#include <ctype.h>
 #include <vm_core.h>
 #include <iseq.h>
 #include <version.h>
@@ -43,6 +44,7 @@ static debug_context_t *last_debug_context = NULL;
 VALUE rdebug_threads_tbl = Qnil; /* Context for each of the threads */
 VALUE mDebugger;                 /* Ruby Debugger Module object */
 
+static VALUE opt_call_c_function;
 static VALUE cThreadsTable;
 static VALUE cContext;
 static VALUE cDebugThread;
@@ -71,7 +73,6 @@ static VALUE context_copy_locals(debug_context_t *,debug_frame_t *, VALUE);
 static void context_suspend_0(debug_context_t *);
 static void context_resume_0(debug_context_t *);
 static void copy_scalar_args(debug_frame_t *);
-static void debug_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass);
 
 typedef struct locked_thread_t {
     VALUE thread_id;
@@ -383,6 +384,8 @@ debug_context_create(VALUE thread)
     debug_context->stack_size = 0;
     debug_context->thread_id = ref2id(thread);
     debug_context->breakpoint = Qnil;
+    debug_context->jump_pc = NULL;
+    debug_context->jump_cfp = NULL;
     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);
@@ -418,7 +421,7 @@ debug_context_dup(debug_context_t *debug_context, VALUE self)
 }
 
 static void
-thread_context_lookup(VALUE thread, VALUE *context, debug_context_t **debug_context)
+thread_context_lookup(VALUE thread, VALUE *context, debug_context_t **debug_context, int create)
 {
     threads_table_t *threads_table;
     VALUE thread_id;
@@ -437,8 +440,18 @@ thread_context_lookup(VALUE thread, VALUE *context, debug_context_t **debug_cont
     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);
-        st_insert(threads_table->tbl, thread_id, *context);
+        if (create)
+        {
+            *context = debug_context_create(thread);
+            st_insert(threads_table->tbl, thread_id, *context);
+        }
+        else
+        {
+            *context = 0;
+            if (debug_context)
+                *debug_context = NULL;
+            return;
+        }
     }
 
     Data_Get_Struct(*context, debug_context_t, l_debug_context);
@@ -709,7 +722,7 @@ debug_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE kl
 
     if ((iseq == NULL) && (event != RUBY_EVENT_RAISE))
         return;
-    thread_context_lookup(thread->self, &context, &debug_context);
+    thread_context_lookup(thread->self, &context, &debug_context, 1);
 
     if ((event == RUBY_EVENT_LINE) || (event == RUBY_EVENT_CALL))
     {
@@ -803,12 +816,7 @@ debug_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE kl
         else
             set_frame_source(event, debug_context, self, file, line, mid);
 
-        if (CTX_FL_TEST(debug_context, CTX_FL_JUMPING))
-        {
-            CTX_FL_UNSET(debug_context, CTX_FL_JUMPING);
-            break;
-        }
-        else if (CTX_FL_TEST(debug_context, CTX_FL_CATCHING))
+        if (CTX_FL_TEST(debug_context, CTX_FL_CATCHING))
         {
             debug_frame_t *top_frame = get_top_frame(debug_context);
             
@@ -1195,7 +1203,7 @@ debug_current_context(VALUE self)
     debug_check_started();
 
     thread = rb_thread_current();
-    thread_context_lookup(thread, &context, NULL);
+    thread_context_lookup(thread, &context, NULL, 1);
 
     return context;
 }
@@ -1212,7 +1220,7 @@ debug_thread_context(VALUE self, VALUE thread)
     VALUE context;
 
     debug_check_started();
-    thread_context_lookup(thread, &context, NULL);
+    thread_context_lookup(thread, &context, NULL, 1);
     return context;
 }
 
@@ -1239,7 +1247,7 @@ debug_contexts(VALUE self)
     for(i = 0; i < RARRAY_LEN(list); i++)
     {
         thread = rb_ary_entry(list, i);
-        thread_context_lookup(thread, &context, NULL);
+        thread_context_lookup(thread, &context, NULL, 1);
         rb_ary_push(new_list, context);
     }
     threads_table_clear(rdebug_threads_tbl);
@@ -1271,7 +1279,7 @@ debug_suspend(VALUE self)
     debug_check_started();
 
     context_list = debug_contexts(self);
-    thread_context_lookup(rb_thread_current(), &current, NULL);
+    thread_context_lookup(rb_thread_current(), &current, NULL, 1);
 
     for(i = 0; i < RARRAY_LEN(context_list); i++)
     {
@@ -1303,7 +1311,7 @@ debug_resume(VALUE self)
 
     context_list = debug_contexts(self);
 
-    thread_context_lookup(rb_thread_current(), &current, NULL);
+    thread_context_lookup(rb_thread_current(), &current, NULL, 1);
     for(i = 0; i < RARRAY_LEN(context_list); i++)
     {
         context = rb_ary_entry(context_list, i);
@@ -1440,7 +1448,7 @@ debug_set_debug(VALUE self, VALUE value)
 static VALUE
 debug_thread_inherited(VALUE klass)
 {
-  rb_raise(rb_eRuntimeError, "Can't inherit Debugger::DebugThread class");
+    rb_raise(rb_eRuntimeError, "Can't inherit Debugger::DebugThread class");
 }
 
 /*
@@ -1755,12 +1763,32 @@ context_frame_line(int argc, VALUE *argv, VALUE self)
 {
     VALUE frame;
     debug_context_t *debug_context;
+    debug_frame_t *debug_frame;
+    rb_control_frame_t *cfp;
+    rb_control_frame_t *cfp_end;
+    rb_thread_t *th;
+    VALUE *pc;
 
     debug_check_started();
     frame = optional_frame_position(argc, argv);
     Data_Get_Struct(self, debug_context_t, debug_context);
+    GetThreadPtr(context_thread_0(debug_context), th);
+
+    debug_frame = get_top_frame(debug_context);
+    if (debug_frame == NULL)
+        return(INT2FIX(0));
 
-    return(INT2FIX(rb_vm_get_sourceline(GET_FRAME->info.runtime.cfp)));
+    pc = GET_FRAME->info.runtime.last_pc;
+    cfp_end = RUBY_VM_END_CONTROL_FRAME(th);
+    cfp = GET_FRAME->info.runtime.cfp;
+    while (cfp > (rb_control_frame_t*)th->stack)
+    {
+        if ((cfp->iseq != NULL) && (pc >= cfp->iseq->iseq_encoded) && (pc < cfp->iseq->iseq_encoded + cfp->iseq->iseq_size))
+            return(INT2FIX(rb_vm_get_sourceline(cfp)));
+        cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
+    }
+
+    return(INT2FIX(0));
 }
 
 /*
@@ -1883,7 +1911,7 @@ context_copy_locals(debug_context_t *debug_context, debug_frame_t *debug_frame,
     {
         rb_thread_t *th;
         rb_control_frame_t *block_frame = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
-        Data_Get_Struct(context_thread_0(debug_context), rb_thread_t, th);
+        GetThreadPtr(context_thread_0(debug_context), th);
         while (block_frame > (rb_control_frame_t*)th->stack)
         {
             if (block_frame->iseq == cfp->block_iseq)
@@ -2243,6 +2271,32 @@ context_stop_reason(VALUE self)
     return ID2SYM(rb_intern(sym_name));
 }
 
+static rb_control_frame_t *
+FUNC_FASTCALL(do_jump)(rb_thread_t *th, rb_control_frame_t *cfp)
+{
+    VALUE context;
+    debug_context_t *debug_context;
+
+    thread_context_lookup(th->self, &context, &debug_context, 0);
+    if (debug_context == NULL)
+        rb_raise(rb_eRuntimeError, "Lost context in jump");
+    cfp->pc[-2] = debug_context->saved_jump_ins[0];
+    cfp->pc[-1] = debug_context->saved_jump_ins[1];
+
+    cfp = debug_context->jump_cfp;
+    if ((debug_context->jump_pc < cfp->iseq->iseq_encoded) || (debug_context->jump_pc >= cfp->iseq->iseq_encoded + cfp->iseq->iseq_size))
+        rb_raise(rb_eRuntimeError, "Invalid jump PC target");
+    cfp->pc = debug_context->jump_pc;
+
+    debug_context->jump_pc = NULL;
+    debug_context->jump_cfp = NULL;
+    debug_context->last_line = 0;
+    debug_context->last_file = NULL;
+    debug_context->stop_next = 1;
+    th->cfp = cfp;
+    return(cfp);
+}
+
 /*
  *   call-seq:
  *      context.jump(line, file) -> bool
@@ -2255,39 +2309,74 @@ context_jump(int argc, VALUE *argv, VALUE self)
     debug_context_t *debug_context;
     debug_frame_t *debug_frame;
     VALUE line, file;
-    const char *file_str;
     int i;
-    struct rb_iseq_struct *iseq;
+    rb_thread_t *th;
+    rb_control_frame_t *cfp;
+    rb_control_frame_t *cfp_end;
+    rb_control_frame_t *cfp_start = NULL;
+
+    debug_check_started();
 
     Data_Get_Struct(self, debug_context_t, debug_context);
+    GetThreadPtr(context_thread_0(debug_context), th);
     debug_frame = get_top_frame(debug_context);
+    if (debug_frame == NULL)
+        rb_raise(rb_eRuntimeError, "No frames collected.");
 
-    if ((argc <= 0) || (argc > 2))
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
-    rb_scan_args(argc, argv, "11", &line, &file);
+    if (argc != 2)
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
+    rb_scan_args(argc, argv, "2", &line, &file);
 
     line = FIX2INT(line);
-    if (file == Qnil)
-        file_str = debug_frame->file;
-    else
-        file_str = RSTRING_PTR(file);
 
-    iseq = debug_frame->info.runtime.cfp->iseq;
-    for (i = 0; i < iseq->insn_info_size; i++)
+    /* find topmost frame of the debugged code */
+    cfp = th->cfp;
+    cfp_end = RUBY_VM_END_CONTROL_FRAME(th);
+    while (RUBY_VM_VALID_CONTROL_FRAME_P(cfp, cfp_end))
     {
-        if (iseq->insn_info_table[i].line_no == line)
+        if (cfp->pc == debug_frame->info.runtime.last_pc)
         {
-            if (*debug_frame->info.runtime.cfp->pc == BIN(pop))
-                debug_frame->info.runtime.cfp->sp--;
-            debug_frame->info.runtime.cfp->pc = 
-                iseq->iseq_encoded + iseq->insn_info_table[i].position;
-            CTX_FL_SET(debug_context, CTX_FL_JUMPING);
-            return Qtrue;
+            cfp_start = cfp;
+            if ((cfp->pc - cfp->iseq->iseq_encoded) >= (cfp->iseq->iseq_size - 1))
+                return(INT2FIX(1)); /* no space for opt_call_c_function hijack */
+            break;
         }
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
-    return Qfalse;
+    if (cfp_start == NULL)
+        return(INT2FIX(2)); /* couldn't find frame; should never happen */
+
+    /* find target frame to jump to */
+    while (RUBY_VM_VALID_CONTROL_FRAME_P(cfp, cfp_end))
+    {
+        if ((cfp->iseq != NULL) && (rb_str_cmp(file, cfp->iseq->filename) == 0))
+        {
+            for (i = 0; i < cfp->iseq->insn_info_size; i++)
+            {
+                if (cfp->iseq->insn_info_table[i].line_no != line)
+                    continue;
+
+                /* hijack the currently running code so that we can change the frame PC(s) */
+                debug_context->saved_jump_ins[0] = cfp_start->pc[0];
+                debug_context->saved_jump_ins[1] = cfp_start->pc[1];
+                cfp_start->pc[0] = opt_call_c_function;
+                cfp_start->pc[1] = (VALUE)do_jump;
+
+                debug_context->jump_cfp = cfp;
+                debug_context->jump_pc =
+                    cfp->iseq->iseq_encoded + cfp->iseq->insn_info_table[i].position;
+
+                return(INT2FIX(0)); /* success */
+            }
+        }
+
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+    }
+
+    return(INT2FIX(3)); /* couldn't find a line and file frame match */
 }
 
+
 /*
  *   Document-class: Context
  *
@@ -2378,6 +2467,19 @@ debug_add_breakpoint(int argc, VALUE *argv, VALUE self)
 void
 Init_ruby_debug()
 {
+    rb_iseq_t iseq;
+    iseq.iseq = &opt_call_c_function;
+    iseq.iseq_size = 1;
+    iseq.iseq_encoded = NULL;
+
+    opt_call_c_function = (VALUE)BIN(opt_call_c_function);
+    rb_iseq_translate_threaded_code(&iseq);
+    if (iseq.iseq_encoded != iseq.iseq)
+    {
+        opt_call_c_function = iseq.iseq_encoded[0];
+        xfree(iseq.iseq_encoded);
+    }
+
     mDebugger = rb_define_module("Debugger");
     rb_define_const(mDebugger, "VERSION", rb_str_new2(DEBUG_VERSION));
     rb_define_module_function(mDebugger, "start_", debug_start, 0);

data/ext/ruby_debug/ruby_debug.h

@@ -13,7 +13,6 @@ enum ctx_stop_reason {CTX_STOP_NONE, CTX_STOP_STEP, CTX_STOP_BREAKPOINT,
 #define CTX_FL_STEPPED      (1<<8)
 #define CTX_FL_FORCE_MOVE   (1<<9)
 #define CTX_FL_CATCHING     (1<<10)
-#define CTX_FL_JUMPING      (1<<11)
 
 #define CTX_FL_TEST(c,f)  ((c)->flags & (f))
 #define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
@@ -69,6 +68,9 @@ typedef struct {
     int last_line;
     VALUE breakpoint;
     debug_catch_t catch_table;
+    VALUE saved_jump_ins[2];
+    rb_control_frame_t *jump_cfp;
+    VALUE *jump_pc;
 } debug_context_t;
 
 /* variables in ruby_debug.c */

data/lib/ruby-debug-base.rb

@@ -90,7 +90,7 @@ module Debugger
     end
     
     def source_reload
-      LineCache::clear_file_cache(true)
+      LineCache::clear_file_cache
     end
     
     # Get line +line_number+ from file named +filename+. Return "\n"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-debug-base19
 version: !ruby/object:Gem::Version 
-  version: 0.11.18
+  version: 0.11.19
 platform: ruby
 authors: 
 - Kent Sibilev
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-30 00:00:00 -07:00
+date: 2009-09-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency