ruby-debug 0.6.2-mswin32 → 0.7-mswin32

data/CHANGES

@@ -1,3 +1,10 @@
+0.7
+- Eliminated explicit Frame object. Use Context.frame_[binding,file,line] instead.
+- Fixed help command.
+- Renamed Debugger.keep_frame_info to Debugger.keep_frame_binding
+- 'eval' command is available, even when keep_frame_binding is not used.
+- New 'set' command is available.
+
 0.6.2
 - Added thread lookup cache.
 - Control thread is always started by rdebug script.
@@ -105,4 +112,4 @@
 0.1.2 (2006-07-16)
 ========================
 
-- Initial release.
+- Initial release.

data/bin/rdebug

@@ -16,7 +16,7 @@ options = OpenStruct.new(
   'post_mortem' => false,
   'script'      => nil,
   'tracing'     => false,
-  'frame_info'  => false
+  'frame_bind'  => false
 )
 
 opts = OptionParser.new do |opts|
@@ -31,10 +31,9 @@ EOB
   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("--cport PORT", Integer, "Port used for contol commands, implies -s option") {|options.port|}
+  opts.on("--cport PORT", Integer, "Port used for contol commands") {|options.cport|}
   opts.on("-x", "--trace", "turn on line tracing") {options.tracing = true}
   opts.on("-n", "--nostop", "Do not stop when stript is loaded") {options.nostop = true}
-  opts.on("-f", "--keep-frame-info", "Keep frame info") {options.frame_info = true}
   opts.on("-m", "--post-mortem", "Activate post-mortem mode") {options.post_mortem = true}
   opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
     $LOAD_PATH.unshift(path)
@@ -45,6 +44,7 @@ EOB
       exit
     end
   end
+  opts.on("--keep-frame-binding", "Keep frame bindings") {options.frame_bind = true}
   opts.separator ""
   opts.separator "Common options:"
   opts.on_tail("--help", "Show this message") do
@@ -91,7 +91,7 @@ else
   # set options
   Debugger.stop_on_connect = !options.nostop
   Debugger.wait_connection = options.wait
-  Debugger.keep_frame_info = options.frame_info
+  Debugger.keep_frame_binding = options.frame_bind
   
   # load user script
   load "#{ENV["HOME"]}/.rdebugrc" if File.exists?("#{ENV["HOME"]}/.rdebugrc")
@@ -121,4 +121,4 @@ else
     # load script
     Debugger.debug_load Debugger::PROG_SCRIPT
   end
-end
+end

data/ext/ruby_debug.c

@@ -4,13 +4,50 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.6.2"
+#define DEBUG_VERSION "0.7"
+
+#ifdef _WIN32
+struct FRAME {
+	VALUE self;
+	int argc;
+	ID last_func;
+	ID orig_func;
+	VALUE last_class;
+	struct FRAME *prev;
+	struct FRAME *tmp;
+	struct RNode *node;
+	int iter;
+	int flags;
+	unsigned long uniq;
+};
+
+struct SCOPE {
+	struct RBasic super;
+	ID *local_tbl;
+	VALUE *local_vars;
+	int flags;
+};
+
+struct RVarmap {
+	struct RBasic super;
+	ID id;
+	VALUE val;
+	struct RVarmap *next;
+};
+
+RUBY_EXTERN struct SCOPE   *ruby_scope;
+RUBY_EXTERN struct FRAME   *ruby_frame;
+RUBY_EXTERN struct RVarmap *ruby_dyna_vars;
+#else
+#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_TEST(c,f) ((c)->flags & (f))
 #define CTX_FL_SET(c,f) do { (c)->flags |= (f); } while (0)
@@ -21,28 +58,45 @@
                           strcmp(debug_context->last_file, file) != 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)))
 
 #ifndef min
 #define min(x,y) ((x) < (y) ? (x) : (y))
 #endif
 
+#define STACK_SIZE_INCREMENT 128
+				     
 typedef struct {
-    ID id;
     VALUE binding;
+    ID id;
     int line;
     const char * file;
+    short dead;
+    VALUE self;
+    union {
+	struct {
+	    struct FRAME *frame;
+	    struct SCOPE *scope;
+	    struct RVarmap *dyna_vars;
+	} runtime;
+	struct {
+	    VALUE locals;
+	} copy;
+    } info;
 } debug_frame_t;
 
 typedef struct {
+    VALUE thread_id;
     int thnum;
     int flags;
     int stop_next;
     int dest_frame;
     int stop_line;
     int stop_frame;
-    unsigned long thread_id;
-    VALUE frames;
-    debug_frame_t *top_frame;
+    int stack_size;
+    int stack_len;
+    debug_frame_t *frames;
     const char * last_file;
     int last_line;
 } debug_context_t;
@@ -65,13 +119,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 keep_frame_info = 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_binding = Qfalse;
 
 static VALUE last_context = Qnil;
 static VALUE last_thread  = Qnil;
@@ -80,7 +134,6 @@ static debug_context_t *last_debug_context = NULL;
 static VALUE mDebugger;
 static VALUE cThreadsTable;
 static VALUE cContext;
-static VALUE cFrame;
 static VALUE cBreakpoint;
 
 static VALUE rb_mObjectSpace;
@@ -102,9 +155,10 @@ static unsigned long hook_count = 0;
 static VALUE create_binding(VALUE);
 static VALUE debug_stop(VALUE);
 static void save_current_position(debug_context_t *);
+static VALUE context_copy_locals(debug_frame_t *);
 
 typedef struct locked_thread_t { 
-    unsigned long thread_id;
+    VALUE thread_id;
     struct locked_thread_t *next;
 } locked_thread_t;
 
@@ -120,10 +174,10 @@ ruby_method_ptr(VALUE class, ID meth_id)
     return (void *)method->u1.value;
 }
 
-inline static unsigned long 
+inline static VALUE
 ref2id(VALUE obj)
 {
-    return NUM2ULONG(rb_obj_id(obj));
+    return rb_obj_id(obj);
 }
 
 static VALUE
@@ -141,13 +195,14 @@ id2ref_unprotected(VALUE id)
 static VALUE
 id2ref_error()
 {
+    rb_p(ruby_errinfo);
     return Qnil;
 }
 
 static VALUE
-id2ref(unsigned long id)
+id2ref(VALUE id)
 {
-    return rb_rescue(id2ref_unprotected, ULONG2NUM(id), id2ref_error, 0);
+    return rb_rescue(id2ref_unprotected, id, id2ref_error, 0);
 }
 
 inline static VALUE
@@ -157,7 +212,7 @@ context_thread_0(debug_context_t *debug_context)
 }
 
 static int
-is_in_locked(unsigned long thread_id)
+is_in_locked(VALUE thread_id)
 {
     locked_thread_t *node;
     
@@ -175,7 +230,7 @@ static void
 add_to_locked(VALUE thread)
 {
     locked_thread_t *node;
-    unsigned long thread_id = ref2id(thread);
+    VALUE thread_id = ref2id(thread);
     
     if(is_in_locked(thread_id))
         return;
@@ -314,16 +369,34 @@ debug_check_started()
 }
 
 static void
-debug_context_mark(void* data)
+debug_context_mark(void *data)
 {
+    debug_frame_t *frame;
+    int i;
+    
     debug_context_t *debug_context = (debug_context_t *)data;
-    rb_gc_mark(debug_context->frames);
+    for(i = 0; i < debug_context->stack_size; i++)
+    {
+	frame = &(debug_context->frames[i]);
+	rb_gc_mark(frame->binding);
+	rb_gc_mark(frame->self);
+	if(frame->dead)
+	{
+	    rb_gc_mark(frame->info.copy.locals);
+	}
+    }
+}
+
+static void
+debug_context_free(void *data)
+{
+    debug_context_t *debug_context = (debug_context_t *)data;
+    xfree(debug_context->frames);
 }
 
 static VALUE
 debug_context_create(VALUE thread)
 {
-    VALUE result;
     debug_context_t *debug_context;
     
     debug_context = ALLOC(debug_context_t);
@@ -337,18 +410,45 @@ debug_context_create(VALUE thread)
     debug_context->dest_frame = -1;
     debug_context->stop_line = -1;
     debug_context->stop_frame = -1;
-    debug_context->frames = rb_ary_new();
-    debug_context->top_frame = NULL;
+    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);
-    result = Data_Wrap_Struct(cContext, debug_context_mark, xfree, debug_context);
-    return result;
+    return Data_Wrap_Struct(cContext, debug_context_mark, debug_context_free, debug_context);
+}
+
+static VALUE
+debug_context_dup(debug_context_t *debug_context)
+{
+    debug_context_t *new_debug_context;
+    debug_frame_t *new_frame, *old_frame;
+    int i;
+
+    new_debug_context = ALLOC(debug_context_t);
+    memcpy(new_debug_context, debug_context, sizeof(debug_context_t));
+    new_debug_context->stop_next = -1;
+    new_debug_context->dest_frame = -1;
+    new_debug_context->stop_line = -1;
+    new_debug_context->stop_frame = -1;
+    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;
+    memcpy(new_debug_context->frames, debug_context->frames, sizeof(debug_frame_t) * debug_context->stack_size);
+    for(i = 0; i < debug_context->stack_size; i++)
+    {
+	new_frame = &(new_debug_context->frames[i]);
+	old_frame = &(debug_context->frames[i]);
+	new_frame->dead = 1;
+	new_frame->info.copy.locals = context_copy_locals(old_frame);
+    }
+    return Data_Wrap_Struct(cContext, debug_context_mark, debug_context_free, new_debug_context);
 }
 
 static void
 thread_context_lookup(VALUE thread, VALUE *context, debug_context_t **debug_context)
 {
     threads_table_t *threads_table;
-    unsigned long thread_id;
+    VALUE thread_id;
     debug_context_t *l_debug_context;
 
     debug_check_started();
@@ -377,13 +477,6 @@ thread_context_lookup(VALUE thread, VALUE *context, debug_context_t **debug_cont
     last_debug_context = l_debug_context;
 }
 
-static void
-debug_frame_mark(void *data)
-{
-    debug_frame_t *debug_frame = (debug_frame_t *)data;
-    rb_gc_mark(debug_frame->binding);
-}
-
 static VALUE
 call_at_line_unprotected(VALUE args)
 {
@@ -407,19 +500,28 @@ call_at_line(VALUE context, debug_context_t *debug_context, VALUE file, VALUE li
 static void
 save_call_frame(VALUE self, char *file, int line, ID mid, debug_context_t *debug_context)
 {
-    VALUE frame, binding;
+    VALUE binding;
     debug_frame_t *debug_frame;
+    int frame_n;
+    
+    binding = self && RTEST(keep_frame_binding)? create_binding(self) : Qnil;
     
-    binding = self && RTEST(keep_frame_info)? create_binding(self) : Qnil;
-    debug_frame = ALLOC(debug_frame_t);
+    frame_n = debug_context->stack_size++;
+    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);
+    }
+    debug_frame = &debug_context->frames[frame_n];
     debug_frame->file = file;
     debug_frame->line = line;
     debug_frame->binding = binding;
     debug_frame->id = mid;
-    frame = Data_Wrap_Struct(cFrame, debug_frame_mark, xfree, debug_frame);
-    
-    debug_context->top_frame = debug_frame;
-    rb_ary_push(debug_context->frames, frame);
+    debug_frame->dead = 0;
+    debug_frame->self = self;
+    debug_frame->info.runtime.frame = ruby_frame;
+    debug_frame->info.runtime.scope = ruby_scope;
+    debug_frame->info.runtime.dyna_vars = ruby_dyna_vars;
 }
 
 #if defined DOSISH
@@ -559,22 +661,10 @@ check_breakpoint_expression(VALUE breakpoint, VALUE binding)
 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)
+    if(debug_context->stack_size == 0)
         return NULL;
     else 
-    {
-        if(debug_context->top_frame == NULL)
-        {
-            frame = RARRAY(debug_context->frames)->ptr[RARRAY(debug_context->frames)->len-1];
-            Data_Get_Struct(frame, debug_frame_t, debug_frame);
-            debug_context->top_frame = debug_frame;
-        }
-        else
-            debug_frame = debug_context->top_frame;
-        return debug_frame;
-    }
+	return &(debug_context->frames[debug_context->stack_size-1]);
 }
 
 inline static void
@@ -586,7 +676,7 @@ save_top_binding(debug_context_t *debug_context, VALUE binding)
         debug_frame->binding = binding;
 }
 
-static void
+inline static void
 set_frame_source(debug_context_t *debug_context, char *file, int line)
 {
     debug_frame_t *top_frame;
@@ -598,6 +688,17 @@ set_frame_source(debug_context_t *debug_context, char *file, int line)
     }
 }
 
+inline static void 
+set_dyna_vars(debug_context_t *debug_context)
+{
+    debug_frame_t *top_frame;
+    top_frame = get_top_frame(debug_context);
+    if(top_frame)
+    {
+        top_frame->info.runtime.dyna_vars = ruby_dyna_vars;
+    }
+}
+
 static void
 save_current_position(debug_context_t *debug_context)
 {
@@ -670,12 +771,13 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     case RUBY_EVENT_LINE:
     {
         set_frame_source(debug_context, file, line);
+	set_dyna_vars(debug_context);
 
         if(RTEST(tracing) || CTX_FL_TEST(debug_context, CTX_FL_TRACING))
             rb_funcall(context, idAtTracing, 2, rb_str_new2(file), INT2FIX(line));
         
         if(debug_context->dest_frame == -1 || 
-            RARRAY(debug_context->frames)->len == debug_context->dest_frame)
+            debug_context->stack_size == debug_context->dest_frame)
         {
             debug_context->stop_next--;
             if(debug_context->stop_next < 0)
@@ -684,12 +786,12 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             if(DID_MOVED)
                 debug_context->stop_line--;
         }
-        else if(RARRAY(debug_context->frames)->len < debug_context->dest_frame)
+        else if(debug_context->stack_size < debug_context->dest_frame)
         {
             debug_context->stop_next = 0;
         }
 
-        if(RARRAY(debug_context->frames)->len == 0)
+        if(debug_context->stack_size == 0)
             save_call_frame(self, file, line, mid, debug_context);
 
         if(debug_context->stop_next == 0 || debug_context->stop_line == 0 ||
@@ -746,13 +848,13 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_END:
     {
-        if(RARRAY(debug_context->frames)->len == debug_context->stop_frame)
+        if(debug_context->stack_size == debug_context->stop_frame)
         {
             debug_context->stop_next = 1;
             debug_context->stop_frame = 0;
         }
-        rb_ary_pop(debug_context->frames);
-        debug_context->top_frame = NULL;
+	if(debug_context->stack_size > 0)
+	    debug_context->stack_size--;
         break;
     }
     case RUBY_EVENT_CLASS:
@@ -772,7 +874,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             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));
+            rb_ivar_set(ruby_errinfo, rb_intern("@__debug_context"), debug_context_dup(debug_context));
         }
 
         expn_class = rb_obj_class(ruby_errinfo);
@@ -1270,26 +1372,26 @@ debug_set_post_mortem(VALUE self, VALUE value)
 
 /*
  *   call-seq:
- *      Debugger.post_mortem? -> bool
+ *      Debugger.keep_frame_binding? -> bool
  *   
  *   Returns +true+ if the debugger will collect frame bindings.
  */
 static VALUE
-debug_keep_frame_info(VALUE self)
+debug_keep_frame_binding(VALUE self)
 {
-    return keep_frame_info;
+    return keep_frame_binding;
 }
 
 /*
  *   call-seq:
- *      Debugger.post_mortem = bool
+ *      Debugger.keep_frame_binding = bool
  *   
- *   Setting to +true+ will make the debugger keep frame bindings.
+ *   Setting to +true+ will make the debugger create frame bindings.
  */
 static VALUE
-debug_set_keep_frame_info(VALUE self, VALUE value)
+debug_set_keep_frame_binding(VALUE self, VALUE value)
 {
-    keep_frame_info = RTEST(value) ? Qtrue : Qfalse;
+    keep_frame_binding = RTEST(value) ? Qtrue : Qfalse;
     return value;
 }
 
@@ -1310,7 +1412,7 @@ debug_debug_load(VALUE self, VALUE file)
     
     context = debug_current_context(self);
     Data_Get_Struct(context, debug_context_t, debug_context);
-    rb_ary_clear(debug_context->frames);
+    debug_context->stack_size = 0;
     rb_load(file, 0);
     
     debug_stop(self);
@@ -1401,7 +1503,6 @@ context_stop_next(VALUE self, VALUE steps)
     debug_context_t *debug_context;
 
     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.");
@@ -1423,22 +1524,21 @@ context_step_over(int argc, VALUE *argv, VALUE self)
     debug_context_t *debug_context;
 
     debug_check_started();
-
     Data_Get_Struct(self, debug_context_t, debug_context);
-    if(RARRAY(debug_context->frames)->len == 0)
+    if(debug_context->stack_size == 0)
         rb_raise(rb_eRuntimeError, "No frames collected.");
 
     rb_scan_args(argc, argv, "11", &lines, &frame);
     debug_context->stop_line = FIX2INT(lines);
     if(argc == 1)
     {
-        debug_context->dest_frame = RARRAY(debug_context->frames)->len;
+        debug_context->dest_frame = debug_context->stack_size;
     }
     else
     {
-        if(FIX2INT(frame) < 0 && FIX2INT(frame) >= RARRAY(debug_context->frames)->len)
+        if(FIX2INT(frame) < 0 && FIX2INT(frame) >= debug_context->stack_size)
             rb_raise(rb_eRuntimeError, "Destination frame is out of range.");
-        debug_context->dest_frame = RARRAY(debug_context->frames)->len - FIX2INT(frame);
+        debug_context->dest_frame = debug_context->stack_size - FIX2INT(frame);
     }
 
     return Qnil;
@@ -1456,28 +1556,182 @@ context_stop_frame(VALUE self, VALUE frame)
     debug_context_t *debug_context;
 
     debug_check_started();
-
     Data_Get_Struct(self, debug_context_t, debug_context);
-    if(FIX2INT(frame) < 0 && FIX2INT(frame) >= RARRAY(debug_context->frames)->len)
+    if(FIX2INT(frame) < 0 && FIX2INT(frame) >= debug_context->stack_size)
         rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
-    debug_context->stop_frame = RARRAY(debug_context->frames)->len - FIX2INT(frame);
+    debug_context->stop_frame = debug_context->stack_size - FIX2INT(frame);
 
     return frame;
 }
 
+inline static int
+check_frame_number(debug_context_t *debug_context, VALUE frame)
+{
+    int frame_n;
+
+    frame_n = FIX2INT(frame);
+    if(frame_n < 0 || frame_n >= debug_context->stack_size)
+	rb_raise(rb_eArgError, "Invalid frame number %d, stack (0...%d)",
+		frame_n, debug_context->stack_size); 
+    return frame_n;
+}
+
+/*
+ *   call-seq:
+ *      context.frame_binding(frame) -> binding
+ *   
+ *   Returns frame's binding.
+ */
+static VALUE
+context_frame_binding(VALUE self, VALUE frame)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return GET_FRAME->binding;
+}
+
+/*
+ *   call-seq:
+ *      context.frame_id(frame) -> sym
+ *   
+ *   Returns the sym of the called method.
+ */
+static VALUE
+context_frame_id(VALUE self, VALUE frame)
+{
+
+    debug_context_t *debug_context;
+    ID id;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+
+    id = GET_FRAME->id;
+    return id ? ID2SYM(id): Qnil;
+}
+
+/*
+ *   call-seq:
+ *      context.frame_line(frame) -> int
+ *   
+ *   Returns the line number in the file.
+ */
+static VALUE
+context_frame_line(VALUE self, VALUE frame)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+
+    return INT2FIX(GET_FRAME->line);
+}
+
+/*
+ *   call-seq:
+ *      context.frame_file(frame) -> string
+ *   
+ *   Returns the name of the file.
+ */
+static VALUE
+context_frame_file(VALUE self, VALUE frame)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+
+    return rb_str_new2(GET_FRAME->file);
+}
+
+static VALUE
+context_copy_locals(debug_frame_t *debug_frame)
+{
+    ID *tbl;
+    int n, i;
+    struct SCOPE *scope;
+    struct RVarmap *vars;
+    VALUE hash = rb_hash_new();
+
+    scope = debug_frame->info.runtime.scope;
+    tbl = scope->local_tbl;
+
+    if (tbl && scope->local_vars) {
+	n = *tbl++;
+	for (i=2; i<n; i++) {   /* skip first 2 ($_ and $~) */
+	    if (!rb_is_local_id(tbl[i])) continue; /* skip flip states */
+	    rb_hash_aset(hash, rb_str_new2(rb_id2name(tbl[i])), scope->local_vars[i]);
+	}
+    }
+
+    vars = debug_frame->info.runtime.dyna_vars;
+    while (vars) {
+	if (vars->id && rb_is_local_id(vars->id)) { /* skip $_, $~ and flip states */
+	    rb_hash_aset(hash, rb_str_new2(rb_id2name(vars->id)), vars->val);
+	}
+	vars = vars->next;
+    }
+    return hash;
+}
+
 /*
  *   call-seq:
- *      context.frames -> array
+ *      context.frame_locals(frame) -> hash
  *   
- *   Returns an array of frames.
+ *   Returns frame's local variables.
  */
 static VALUE
-context_frames(VALUE self)
+context_frame_locals(VALUE self, VALUE frame)
 {
     debug_context_t *debug_context;
+    debug_frame_t *debug_frame;
 
+    debug_check_started();
     Data_Get_Struct(self, debug_context_t, debug_context);
-    return debug_context->frames;
+    
+    debug_frame = GET_FRAME;
+    if(debug_frame->dead)
+	return debug_frame->info.copy.locals;
+    else
+	return context_copy_locals(debug_frame);
+}
+
+/*
+ *   call-seq:
+ *      context.frame_self(frame) -> obj
+ *   
+ *   Returns self object of the frame.
+ */
+static VALUE
+context_frame_self(VALUE self, VALUE frame)
+{
+    debug_context_t *debug_context;
+    debug_frame_t *debug_frame;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+
+    debug_frame = GET_FRAME;
+    return debug_frame->self;
+}
+
+/*
+ *   call-seq:
+ *      context.stack_size-> int
+ *   
+ *   Returns the size of the context stack.
+ */
+static VALUE
+context_stack_size(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+    Data_Get_Struct(self, debug_context_t, debug_context);
+
+    return INT2FIX(debug_context->stack_size);
 }
 
 /*
@@ -1491,6 +1745,7 @@ context_thread(VALUE self)
 {
     debug_context_t *debug_context;
 
+    debug_check_started();
     Data_Get_Struct(self, debug_context_t, debug_context);
     return context_thread_0(debug_context);
 }
@@ -1530,6 +1785,23 @@ context_suspend(VALUE self)
     return Qnil;
 }
 
+/*
+ *   call-seq:
+ *      context.suspended? -> bool
+ *   
+ *   Returns +true+ if the thread is suspended by debugger.
+ */
+static VALUE
+context_is_suspended(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return CTX_FL_TEST(debug_context, CTX_FL_SUSPEND) ? Qtrue : Qfalse;
+}
+
 /*
  *   call-seq:
  *      context.resume -> nil
@@ -1629,62 +1901,20 @@ context_set_ignore(VALUE self, VALUE value)
 
 /*
  *   call-seq:
- *      frame.file -> string
+ *      context.dead? = bool
  *   
- *   Returns the name of the file.
+ *   Returns +true+ if context doesn't represent a live context and is created
+ *   during post-mortem exception handling.
  */
 static VALUE
-frame_file(VALUE self)
+context_dead(VALUE self)
 {
-    debug_frame_t *debug_frame;
-
-    Data_Get_Struct(self, debug_frame_t, debug_frame);
-    return rb_str_new2(debug_frame->file);
-}
-
-/*
- *   call-seq:
- *      frame.line -> int
- *   
- *   Returns the line number in the file.
- */
-static VALUE
-frame_line(VALUE self)
-{
-    debug_frame_t *debug_frame;
-
-    Data_Get_Struct(self, debug_frame_t, debug_frame);
-    return INT2FIX(debug_frame->line);
-}
-
-/*
- *   call-seq:
- *      frame.binding -> binding
- *   
- *   Returns the binding captured at the moment this frame was created.
- */
-static VALUE
-frame_binding(VALUE self)
-{
-    debug_frame_t *debug_frame;
-
-    Data_Get_Struct(self, debug_frame_t, debug_frame);
-    return debug_frame->binding;
-}
+    debug_context_t *debug_context;
 
-/*
- *   call-seq:
- *      frame.id -> sym
- *   
- *   Returns the sym of the called method.
- */
-static VALUE
-frame_id(VALUE self)
-{
-    debug_frame_t *debug_frame;
+    debug_check_started();
 
-    Data_Get_Struct(self, debug_frame_t, debug_frame);
-    return debug_frame->id ? ID2SYM(debug_frame->id): Qnil;
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return CTX_FL_TEST(debug_context, CTX_FL_DEAD) ? Qtrue : Qfalse;
 }
 
 /*
@@ -1756,8 +1986,6 @@ breakpoint_id(VALUE self)
  *   == Summary
  *   
  *   Debugger keeps a single instance of this class for each Ruby thread. 
- *   This class provides access to stack frames (see Frame class). Also it
- *   gives you ability to step thought the code.
  */
 static void
 Init_context()
@@ -1766,32 +1994,23 @@ Init_context()
     rb_define_method(cContext, "stop_next=", context_stop_next, 1);
     rb_define_method(cContext, "step_over", context_step_over, -1);
     rb_define_method(cContext, "stop_frame=", context_stop_frame, 1);
-    rb_define_method(cContext, "frames", context_frames, 0);
     rb_define_method(cContext, "thread", context_thread, 0);
     rb_define_method(cContext, "thnum", context_thnum, 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);
     rb_define_method(cContext, "tracing", context_tracing, 0);
     rb_define_method(cContext, "tracing=", context_set_tracing, 1);
     rb_define_method(cContext, "ignore", context_ignore, 0);
     rb_define_method(cContext, "ignore=", context_set_ignore, 1);
-}
-
-/*
- *   Document-class: Frame
- *   
- *   == Summary
- *   
- *   This class holds infomation about a particular call frame.
- */
-static void
-Init_frame()
-{
-    cFrame = rb_define_class_under(cContext, "Frame", rb_cObject);
-    rb_define_method(cFrame, "file", frame_file, 0);
-    rb_define_method(cFrame, "line", frame_line, 0);
-    rb_define_method(cFrame, "binding", frame_binding, 0);
-    rb_define_method(cFrame, "id", frame_id, 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_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, "stack_size", context_stack_size, 0);
+    rb_define_method(cContext, "dead?", context_dead, 0);
 }
 
 /*
@@ -1812,6 +2031,7 @@ Init_breakpoint()
     rb_define_method(cBreakpoint, "id", breakpoint_id, 0);
 }
 
+
 /*
  *   Document-class: Debugger
  *   
@@ -1849,13 +2069,12 @@ 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);
+    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);
     
     cThreadsTable = rb_define_class_under(mDebugger, "ThreadsTable", rb_cObject);
     
     Init_context();
-    Init_frame();
     Init_breakpoint();
 
     idAtLine       = rb_intern("at_line");