ruby-debug 0.1.2

data/ext/ruby_debug.c

@@ -0,0 +1,922 @@
+#include <stdio.h>
+#include <ruby.h>
+#include <node.h>
+#include <rubysig.h>
+#include <st.h>
+
+#define DEBUG_VERSION "0.1.2"
+
+typedef struct {
+    int thnum;
+    int stop_next;
+    int dest_frame;
+    int src_line;
+    int stop_line;
+    int stop_frame;
+    int suspend;
+    int tracing;
+    VALUE frames;
+    VALUE thread;
+} debug_context_t;
+
+typedef struct {
+    VALUE file;
+    VALUE line;
+    VALUE binding;
+    ID id;
+} debug_frame_t;
+
+typedef struct {
+    VALUE source;
+    VALUE pos;
+    VALUE disabled;
+} debug_breakpoint_t;
+
+static VALUE threads_tbl = Qnil;
+static VALUE breakpoints = Qnil;
+static VALUE catchpoint  = Qnil;
+static VALUE waiting     = Qnil;
+static VALUE tracing     = Qfalse;
+
+static VALUE mDebugger;
+static VALUE cContext;
+static VALUE cFrame;
+static VALUE cBreakpoint;
+
+static ID idDebugCommand;
+static ID idAtBreakpoint;
+static ID idAtCatchpoint;
+static ID idAtTracing;
+static ID idBinding;
+
+static int thnum_max = 0;
+static int last_debugged_thnum = 0;
+
+static VALUE debug_suspend(VALUE);
+static VALUE create_binding(VALUE);
+static VALUE debug_stop(VALUE);
+
+static VALUE
+debug_is_started(VALUE self)
+{
+    return threads_tbl != Qnil ? Qtrue : Qfalse;
+}
+
+static VALUE
+debug_check_started()
+{
+    if(threads_tbl == Qnil)
+    {
+        rb_raise(rb_eRuntimeError, "Debugger.start is not called yet.");
+    }
+}
+
+static void
+debug_context_mark(void* data)
+{
+    debug_context_t *debug_context = (debug_context_t *)data;
+    rb_gc_mark(debug_context->frames);
+    rb_gc_mark(debug_context->thread);
+}
+
+static VALUE
+debug_context_create(VALUE thread)
+{
+    VALUE result;
+    debug_context_t *debug_context;
+    
+    debug_context = ALLOC(debug_context_t);
+    debug_context-> thnum = ++thnum_max;
+    debug_context->stop_next = -1;
+    debug_context->dest_frame = -1;
+    debug_context->src_line = -1;
+    debug_context->stop_line = -1;
+    debug_context->stop_frame = -1;
+    debug_context->suspend = 0;
+    debug_context->tracing = 0;
+    debug_context->frames = rb_ary_new();
+    debug_context->thread = thread;
+    result = Data_Wrap_Struct(cContext, debug_context_mark, xfree, debug_context);
+    return result;
+}
+
+static VALUE
+thread_context_lookup(VALUE thread)
+{
+    VALUE context;
+
+    debug_check_started();
+
+    context = rb_hash_aref(threads_tbl, thread);
+    if(context == Qnil)
+    {
+	context = debug_context_create(thread);
+	rb_hash_aset(threads_tbl, thread, context);
+    }
+    return context;
+}
+
+static void
+debug_frame_mark(void *data)
+{
+    debug_frame_t *debug_frame = (debug_frame_t *)data;
+    rb_gc_mark(debug_frame->binding);
+    rb_gc_mark(debug_frame->file);
+    rb_gc_mark(debug_frame->line);
+}
+
+static VALUE
+debug_frame_create(VALUE file, VALUE line, VALUE binding, ID id)
+{
+    VALUE result;
+    debug_frame_t *debug_frame;
+    
+    debug_frame = ALLOC(debug_frame_t);
+    debug_frame->file = file;
+    debug_frame->line = line;
+    debug_frame->binding = binding;
+    debug_frame->id = id;
+    result = Data_Wrap_Struct(cFrame, debug_frame_mark, xfree, debug_frame);
+    
+    return result;
+}
+
+static VALUE
+call_debug_command(VALUE context, int thnum, VALUE self, ID mid, VALUE file, VALUE line)
+{
+    VALUE id, binding;
+
+    id = mid ? ID2SYM(mid) : Qnil;
+    binding = self? create_binding(self) : Qnil;
+
+    last_debugged_thnum = thnum;
+    debug_suspend(mDebugger);
+    return rb_funcall(context, idDebugCommand, 4, file, line, id, binding);
+}
+
+static void
+set_frame_source(debug_context_t *debug_context, VALUE file, VALUE line)
+{
+    VALUE frame;
+    debug_frame_t *top_frame;
+
+    if(RARRAY(debug_context->frames)->len > 0)
+    {
+	frame = *RARRAY(debug_context->frames)->ptr;
+	Data_Get_Struct(frame, debug_frame_t, top_frame);
+	top_frame->file = file;
+	top_frame->line = line;
+    }
+}
+
+static void
+save_call_frame(VALUE self, VALUE file, VALUE line, ID mid, debug_context_t *debug_context)
+{
+    VALUE frame, binding;
+    
+    binding = self? create_binding(self) : Qnil;
+    frame = debug_frame_create(file, line, binding, mid);
+    rb_ary_unshift(debug_context->frames, frame);
+}
+
+static int
+check_breakpoints(VALUE context, VALUE file, VALUE klass, VALUE pos, ID id)
+{
+    VALUE breakpoint; 
+    debug_breakpoint_t *debug_breakpoint;
+    int i;
+    int result = 0;
+
+    if(RARRAY(breakpoints)->len == 0)
+	return 0;
+    for(i = 0; i < RARRAY(breakpoints)->len; i++)
+    {
+	breakpoint = rb_ary_entry(breakpoints, i);
+	Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+	if(debug_breakpoint->pos != pos && !(TYPE(pos) == T_STRING && 
+		    TYPE(debug_breakpoint->pos) == T_STRING && rb_str_cmp(debug_breakpoint->pos, pos) == 0))
+	    continue;
+	if(TYPE(debug_breakpoint->source) == T_STRING &&
+		rb_str_cmp(debug_breakpoint->source, file) == 0 ||
+		klass != Qnil && debug_breakpoint->source == klass)
+	{
+	    result = 1;
+	    rb_funcall(context, idAtBreakpoint, 2, breakpoint, id ? rb_str_new2(rb_id2name(id)) : Qnil);
+	    continue;
+	}
+
+    }
+    return result;
+}
+
+/*
+ * This is a NASTY HACK. For some reasons rb_f_binding is decalred 
+ * static in eval.c
+ */
+static VALUE
+create_binding(VALUE self)
+{
+    typedef VALUE (*bind_func_t)(VALUE);
+    static bind_func_t f_binding = NULL;
+
+    if(f_binding == NULL)
+    {
+	ID idBinding = rb_intern("binding");
+	NODE *body, *method;
+	st_lookup(RCLASS(rb_mKernel)->m_tbl, idBinding, (st_data_t *)&body);
+	method = (NODE *)body->u2.value;
+	f_binding = (bind_func_t)method->u1.value;
+    }
+    return f_binding(self);
+}
+
+static void
+check_suspend(debug_context_t *debug_context)
+{
+    if(rb_thread_critical == Qtrue)
+	return;
+    while(1)
+    {
+	rb_thread_critical = Qtrue;
+	if(!debug_context->suspend)
+	    break;
+	rb_ary_push(waiting, rb_thread_current());
+	debug_context->suspend = 0;
+	rb_thread_stop();
+    }
+    rb_thread_critical = Qfalse;
+}
+
+static void
+debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
+{
+    VALUE thread;
+    VALUE context;
+    debug_context_t *debug_context;
+    VALUE file = Qnil, line = Qnil;
+
+    static int debugging = 0;
+
+    if(debugging) return;
+
+    debugging++;
+
+    thread = rb_thread_current();
+    context = thread_context_lookup(thread);
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    check_suspend(debug_context);
+
+    if(node)
+    {
+	file = rb_str_new2(node->nd_file);
+	line = INT2FIX(nd_line(node));
+    }
+
+    switch(event)
+    {
+	case RUBY_EVENT_LINE:
+	    {
+		set_frame_source(debug_context, file, line);
+
+		if(RTEST(tracing) || debug_context->tracing )
+		{
+		    rb_funcall(context, idAtTracing, 2, file, line);
+		}
+
+		if(debug_context->dest_frame == -1 || 
+			RARRAY(debug_context->frames)->len == debug_context->dest_frame)
+		{
+		    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(line != Qnil && debug_context->src_line != FIX2INT(line))
+		    {
+			debug_context->stop_line--;
+		    }
+		}
+		else if(RARRAY(debug_context->frames)->len < debug_context->dest_frame)
+		{
+		    debug_context->stop_next = 0;
+		}
+
+		if(RARRAY(debug_context->frames)->len == 0)
+		{
+		    save_call_frame(self, file, line, mid, debug_context);
+		}
+
+		if(debug_context->stop_next == 0 || debug_context->stop_line == 0 ||
+			check_breakpoints(context, file, klass, line, mid))
+		{
+		    /* reset all pointers */
+		    debug_context->dest_frame = -1;
+		    debug_context->src_line = -1;
+		    debug_context->stop_line = -1;
+		    debug_context->stop_next = -1;
+
+		    call_debug_command(context, debug_context->thnum, self, mid, file, line);
+		}
+		break;
+	    }
+	case RUBY_EVENT_C_CALL:
+	    {
+		if(node)
+		{
+		    set_frame_source(debug_context, file, line);
+		}
+		break;
+	    }
+	case RUBY_EVENT_CALL:
+	    {
+		save_call_frame(self, file, line, mid, debug_context);
+		if(check_breakpoints(context, file, klass, rb_str_new2(rb_id2name(mid)), mid))
+		{
+		    call_debug_command(context, debug_context->thnum, self, mid, file, line);
+		}
+		break;
+	    }
+	case RUBY_EVENT_RETURN:
+	case RUBY_EVENT_END:
+	    {
+		if(RARRAY(debug_context->frames)->len == debug_context->stop_frame)
+		{
+		    debug_context->stop_next = 1;
+		    debug_context->stop_frame = 0;
+		}
+		rb_ary_shift(debug_context->frames);
+		break;
+	    }
+	case RUBY_EVENT_CLASS:
+	    {
+		save_call_frame(self, file, line, mid, debug_context);
+		break;
+	    }
+	case RUBY_EVENT_RAISE:
+	    {
+		VALUE ancestors;
+		VALUE expn_class, aclass;
+		int i, found = 0;
+
+		expn_class = rb_obj_class(ruby_errinfo);
+		if( !NIL_P(rb_class_inherited_p(expn_class, rb_eSystemExit)) )
+		{
+		    debug_stop(mDebugger);
+		    rb_exit(0);
+		}
+
+		if(catchpoint == Qnil)
+		    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)
+		    {
+			rb_funcall(context, idAtCatchpoint, 0);
+			call_debug_command(context, debug_context->thnum, self, mid, file, line);
+			break;
+		    }
+		}
+
+		break;
+	    }
+	case RUBY_EVENT_C_RETURN:
+	    {
+		break;
+	    }
+    }
+
+    debugging--;
+}
+
+static VALUE
+debug_thnum(VALUE self)
+{
+    VALUE thread, context;
+    debug_context_t *debug_context;
+    
+    thread = rb_thread_current();
+    context = thread_context_lookup(thread);
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    return INT2FIX(debug_context->thnum);
+}
+
+static VALUE
+debug_start(VALUE self)
+{
+    threads_tbl = rb_hash_new();
+    breakpoints = rb_ary_new();
+    waiting     = rb_ary_new();
+
+    rb_add_event_hook(debug_event_hook, 
+	    RUBY_EVENT_LINE | RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN |
+	    RUBY_EVENT_CALL | RUBY_EVENT_RETURN | RUBY_EVENT_CLASS |
+	    RUBY_EVENT_END | RUBY_EVENT_RAISE
+	    );
+    return Qnil;
+}
+
+static VALUE
+debug_stop(VALUE self)
+{
+    debug_check_started();
+    rb_remove_event_hook(debug_event_hook);
+
+    waiting     = Qnil;
+    breakpoints = Qnil;
+    threads_tbl = Qnil;
+
+    return Qnil;
+}
+
+static void
+breakpoint_mark(void *data)
+{
+    debug_breakpoint_t *breakpoint;
+    breakpoint = (debug_breakpoint_t *)data;
+    rb_gc_mark(breakpoint->source);
+    rb_gc_mark(breakpoint->pos);
+}
+
+static VALUE
+debug_add_breakpoint(VALUE self, VALUE source, VALUE pos)
+{
+    VALUE result;
+    debug_breakpoint_t *breakpoint;
+
+    debug_check_started();
+
+    breakpoint = ALLOC(debug_breakpoint_t);
+    breakpoint->source = source;
+    breakpoint->pos = pos;
+    breakpoint->disabled = Qfalse;
+    result = Data_Wrap_Struct(cBreakpoint, breakpoint_mark, xfree, breakpoint);
+    rb_ary_push(breakpoints, result);
+    return result;
+}
+
+static VALUE
+debug_breakpoints(VALUE self)
+{
+    debug_check_started();
+
+    return breakpoints;
+}
+
+static VALUE
+debug_catchpoint(VALUE self)
+{
+    debug_check_started();
+
+    return catchpoint;
+}
+
+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 VALUE
+debug_interrupt(VALUE self)
+{
+    VALUE thread, context;
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    thread = rb_thread_current();
+    context = thread_context_lookup(thread);
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    debug_context->stop_next = 1;
+
+    return Qnil;
+}
+
+static int
+find_last_context_func(VALUE key, VALUE value, VALUE *result)
+{
+    debug_context_t *debug_context;
+    Data_Get_Struct(value, debug_context_t, debug_context);
+    if(debug_context->thnum == last_debugged_thnum)
+    {
+	*result = value;
+	return ST_STOP;
+    }
+    return ST_CONTINUE;
+}
+
+static VALUE
+find_last_context()
+{
+    VALUE result = Qnil;
+    rb_hash_foreach(threads_tbl, find_last_context_func, (st_data_t)&result);
+    return result;
+}
+
+static VALUE
+debug_interrupt_last(VALUE self)
+{
+    VALUE thread, context = Qnil;
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    context = find_last_context();
+    if(context != Qnil)
+    {
+	Data_Get_Struct(context, debug_context_t, debug_context);
+	debug_context->stop_next = 1;
+    }
+
+    return Qnil;
+}
+
+static VALUE
+debug_current_context(VALUE self)
+{
+    VALUE thread, context;
+
+    debug_check_started();
+
+    thread = rb_thread_current();
+    context = thread_context_lookup(thread);
+
+    return context;
+}
+
+static VALUE
+debug_contexts(VALUE self)
+{
+    volatile VALUE list;
+    volatile VALUE new_list;
+    VALUE thread, context;
+    debug_context_t *debug_context;
+    int i;
+
+    debug_check_started();
+
+    new_list = rb_ary_new();
+    list = rb_funcall(rb_cThread, rb_intern("list"), 0);
+    for(i = 0; i < RARRAY(list)->len; i++)
+    {
+	thread = rb_ary_entry(list, i);
+	context = thread_context_lookup(thread);
+	rb_ary_push(new_list, context);
+    }
+    /*
+     * I wonder why rb_hash_clear is declared static?
+     */
+    rb_funcall(threads_tbl, rb_intern("clear"), 0);
+    for(i = 0; i < RARRAY(new_list)->len; i++)
+    {
+	context = rb_ary_entry(new_list, i);
+	Data_Get_Struct(context, debug_context_t, debug_context);
+	rb_hash_aset(threads_tbl, debug_context->thread, context);
+    }
+
+    return new_list;
+}
+
+static VALUE
+debug_suspend(VALUE self)
+{
+    VALUE current, context;
+    VALUE saved_crit;
+    VALUE context_list;
+    debug_context_t *debug_context;
+    int i;
+
+    debug_check_started();
+
+    saved_crit = rb_thread_critical;
+    rb_thread_critical = Qtrue;
+    context_list = debug_contexts(self);
+    current = thread_context_lookup(rb_thread_current());
+
+    for(i = 0; i < RARRAY(context_list)->len; i++)
+    {
+	context = rb_ary_entry(context_list, i);
+	if(current == context)
+	    continue;
+	Data_Get_Struct(context, debug_context_t, debug_context);
+	debug_context->suspend = 1;
+    }
+    rb_thread_critical = saved_crit;
+
+    if(rb_thread_critical == Qfalse)
+	rb_thread_schedule();
+
+    return context;
+}
+
+static VALUE
+debug_resume(VALUE self)
+{
+    VALUE current, context;
+    VALUE saved_crit;
+    VALUE thread;
+    VALUE context_list;
+    debug_context_t *debug_context;
+    int i;
+
+    debug_check_started();
+
+    saved_crit = rb_thread_critical;
+    rb_thread_critical = Qtrue;
+    context_list = debug_contexts(self);
+
+    current = thread_context_lookup(rb_thread_current());
+    for(i = 0; i < RARRAY(context_list)->len; i++)
+    {
+	context = rb_ary_entry(context_list, i);
+	if(current == context)
+	    continue;
+	Data_Get_Struct(context, debug_context_t, debug_context);
+	debug_context->suspend = 0;
+    }
+    for(i = 0; i < RARRAY(waiting)->len; i++)
+    {
+	thread = rb_ary_entry(waiting, i);
+	rb_thread_run(thread);
+    }
+    rb_ary_clear(waiting);
+    rb_thread_critical = saved_crit;
+
+    rb_thread_schedule();
+
+    return context;
+}
+
+static VALUE
+debug_tracing(VALUE self)
+{
+    return tracing;
+}
+
+static VALUE
+debug_set_tracing(VALUE self, VALUE value)
+{
+    tracing = RTEST(value) ? Qtrue : Qfalse;
+    return value;
+}
+
+static VALUE
+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.");
+    debug_context->stop_next = FIX2INT(steps);
+    
+    return steps;
+}
+
+static VALUE
+context_step_over(int argc, VALUE *argv, VALUE self)
+{
+    VALUE lines, frame, cur_frame;
+    debug_context_t *debug_context;
+    debug_frame_t *debug_frame;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    if(RARRAY(debug_context->frames)->len == 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;
+    }
+    else
+    {
+	if(FIX2INT(frame) < 0 && FIX2INT(frame) >= RARRAY(debug_context->frames)->len)
+	    rb_raise(rb_eRuntimeError, "Destination frame is out of range.");
+	debug_context->dest_frame = FIX2INT(frame);
+    }
+    
+    cur_frame = *RARRAY(debug_context->frames)->ptr;
+    Data_Get_Struct(cur_frame, debug_frame_t, debug_frame);
+    debug_context->src_line = FIX2INT(debug_frame->line);
+    
+    return Qnil;
+}
+
+static VALUE
+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)
+	rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+    debug_context->stop_frame = FIX2INT(frame);
+    
+    return frame;
+}
+
+static VALUE
+context_frames(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return debug_context->frames;
+}
+
+static VALUE
+context_thread(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return debug_context->thread;
+}
+
+static VALUE
+context_thnum(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return INT2FIX(debug_context->thnum);
+}
+
+static VALUE
+context_set_suspend(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    debug_context->suspend = 1;
+    return Qnil;
+}
+
+static VALUE
+context_clear_suspend(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    debug_context->suspend = 0;
+    return Qnil;
+}
+
+static VALUE
+context_tracing(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return debug_context->tracing ? Qtrue : Qfalse;
+}
+
+static VALUE
+context_set_tracing(VALUE self, VALUE value)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    debug_context->tracing = RTEST(value) ? 1 : 0;
+    return value;
+}
+
+static VALUE
+frame_file(VALUE self)
+{
+    debug_frame_t *debug_frame;
+
+    Data_Get_Struct(self, debug_frame_t, debug_frame);
+    return debug_frame->file;
+}
+
+static VALUE
+frame_line(VALUE self)
+{
+    debug_frame_t *debug_frame;
+
+    Data_Get_Struct(self, debug_frame_t, debug_frame);
+    return debug_frame->line;
+}
+
+static VALUE
+frame_binding(VALUE self)
+{
+    debug_frame_t *debug_frame;
+
+    Data_Get_Struct(self, debug_frame_t, debug_frame);
+    return debug_frame->binding;
+}
+
+static VALUE
+frame_id(VALUE self)
+{
+    debug_frame_t *debug_frame;
+
+    Data_Get_Struct(self, debug_frame_t, debug_frame);
+    return debug_frame->id ? ID2SYM(debug_frame->id): Qnil;
+}
+
+static VALUE
+breakpoint_source(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return breakpoint->source;
+}
+
+static VALUE
+breakpoint_pos(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return breakpoint->pos;
+}
+
+#if defined(_WIN32)
+__declspec(dllexport) 
+#endif
+void
+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, "stop", debug_stop, 0);
+    rb_define_module_function(mDebugger, "started?", debug_is_started, 0);
+    rb_define_module_function(mDebugger, "thnum", debug_thnum, 0);
+    rb_define_module_function(mDebugger, "breakpoints", debug_breakpoints, 0);
+    rb_define_module_function(mDebugger, "add_breakpoint", debug_add_breakpoint, 2);
+    rb_define_module_function(mDebugger, "catchpoint", debug_catchpoint, 0);
+    rb_define_module_function(mDebugger, "catchpoint=", debug_set_catchpoint, 1);
+    rb_define_module_function(mDebugger, "interrupt", debug_interrupt, 0);
+    rb_define_module_function(mDebugger, "interrupt_last", debug_interrupt_last, 0);
+    rb_define_module_function(mDebugger, "contexts", debug_contexts, 0);
+    rb_define_module_function(mDebugger, "current_context", debug_current_context, 0);
+    rb_define_module_function(mDebugger, "suspend", debug_suspend, 0);
+    rb_define_module_function(mDebugger, "resume", debug_resume, 0);
+    rb_define_module_function(mDebugger, "tracing", debug_tracing, 0);
+    rb_define_module_function(mDebugger, "tracing=", debug_set_tracing, 1);
+
+    cContext = rb_define_class_under(mDebugger, "Context", rb_cObject);
+    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, "set_suspend", context_set_suspend, 0);
+    rb_define_method(cContext, "clear_suspend", context_clear_suspend, 0);
+    rb_define_method(cContext, "tracing", context_tracing, 0);
+    rb_define_method(cContext, "tracing=", context_set_tracing, 1);
+
+    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);
+
+    cBreakpoint = rb_define_class_under(mDebugger, "Breakpoint", rb_cObject);
+    rb_define_method(cBreakpoint, "source", breakpoint_source, 0);
+    rb_define_method(cBreakpoint, "pos", breakpoint_pos, 0);
+
+    idDebugCommand = rb_intern("debug_command");
+    idAtBreakpoint = rb_intern("at_breakpoint");
+    idAtCatchpoint = rb_intern("at_catchpoint");
+    idAtTracing    = rb_intern("at_tracing");
+    idBinding      = rb_intern("binding");
+
+    rb_global_variable(&threads_tbl);
+    rb_global_variable(&breakpoints);
+    rb_global_variable(&catchpoint);
+    rb_global_variable(&waiting);
+}