debase 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b4c8f78116379934df37e337705708147ce878c3
+  data.tar.gz: 6a037e645748a877e64fd2548025b9d72c2fb698
+SHA512:
+  metadata.gz: f35b489310522fe41416655463caceb0c63c527c37e446d79629b6aa8850c00f7787b9a805b2d35ddf25cd1d96de57daa5dabc0fbab00ac1869fa1de9e0f3206
+  data.tar.gz: fcaf13c8b8eb973d419a2ead16c8a2c35904685888ea7382be6a9d627538126e5380666955fcd6d09c556fe723a3a991512622be725f5ac7745e6a932b7056d3

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+ext/*.o
+ext/*.bundle
+ext/Makefile
+ext/*.log

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - ruby-head
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in debase.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (C) 2005  Kent Sibilev <ksibilev@yahoo.com>
+All rights reserved.
+ *
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ *
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/MIT_LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007-2008, debug-commons team
+Copyright (c) 2012, Dennis Ushakov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,22 @@
+= debase
+
+== Overview
+
+debase is a fast implementation of the standard debugger debug.rb for
+Ruby 2.0.0. The faster execution speed and 2.0.0 compatibility is achieved
+by utilizing a TracePoint mechanism in the Ruby C API.
+
+== Requirements
+
+debase requires Ruby 2.0.0 or higher.
+
+== Install
+
+debase is provided as a RubyGem.  To install:
+
+<tt>gem install debase</tt>
+
+== License
+
+debase contains parts of the code from ruby-debug-base gem.
+See MIT_LICENSE and LICENSE for license information.

data/Rakefile

@@ -0,0 +1,34 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+BASE_TEST_FILE_LIST = Dir['test/**/test_*.rb']
+
+desc "Remove built files"
+task :clean do
+  cd "ext" do
+    if File.exists?("Makefile")
+      sh "make clean"
+      rm  "Makefile"
+    end
+    derived_files = Dir.glob(".o") + Dir.glob("*.so") + Dir.glob("*.bundle") 
+    rm derived_files unless derived_files.empty?
+  end
+end
+
+desc "Create the core debase shared library extension"
+task :lib => :clean do
+  Dir.chdir("ext") do
+    system("#{Gem.ruby} extconf.rb && make")
+    exit $?.to_i if $?.to_i != 0
+  end
+end
+
+desc "Test debase."
+Rake::TestTask.new(:test) do |t|
+    t.libs += ['./ext', './lib']
+    t.test_files = FileList[BASE_TEST_FILE_LIST]
+    t.verbose = true
+  end
+task :test => :lib
+
+task :default => :test

data/debase.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "debase/version"
+
+Gem::Specification.new do |s|
+  s.name        = "debase"
+  s.version     = Debase::VERSION
+  s.authors     = ["Dennis Ushakov"]
+  s.email       = ["dennis.ushakov@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{debase is a fast implementation of the standard Ruby debugger debug.rb for Ruby 2.0}
+  s.description = <<-EOF
+    debase is a fast implementation of the standard Ruby debugger debug.rb for Ruby 2.0.
+    It is implemented by utilizing a new Ruby TracePoint class. The core component
+    provides support that front-ends can build on. It provides breakpoint
+    handling, bindings for stack frames among other things.
+  EOF
+
+  s.rubyforge_project = "debase"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.extensions = ["ext/extconf.rb"]
+
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "rake"
+end

data/ext/breakpoint.c

@@ -0,0 +1,233 @@
+#include <debase_internals.h>
+
+#ifdef _WIN32
+#include <ctype.h>
+#endif
+
+#if defined DOSISH
+#define isdirsep(x) ((x) == '/' || (x) == '\\')
+#else
+#define isdirsep(x) ((x) == '/')
+#endif
+
+static VALUE cBreakpoint;
+static int breakpoint_max;
+
+extern VALUE
+catchpoint_hit_count(VALUE catchpoints, VALUE exception, VALUE *exception_name) {
+  VALUE ancestors;
+  VALUE expn_class;
+  VALUE aclass;
+  VALUE mod_name;
+  VALUE hit_count;
+  int i;
+
+  if (catchpoints == Qnil /*|| st_get_num_entries(RHASH_TBL(rdebug_catchpoints)) == 0)*/)
+    return Qnil;
+  expn_class = rb_obj_class(exception);
+  ancestors = rb_mod_ancestors(expn_class);
+  for(i = 0; i < RARRAY_LEN(ancestors); i++)
+  {
+    aclass    = rb_ary_entry(ancestors, i);
+    mod_name  = rb_mod_name(aclass);
+    hit_count = rb_hash_aref(catchpoints, mod_name);
+    if(hit_count != Qnil)
+    {
+      *exception_name = mod_name;	
+      return hit_count;
+    }
+  }
+  return Qnil;
+}
+
+static void
+Breakpoint_mark(breakpoint_t *breakpoint)
+{
+  rb_gc_mark(breakpoint->source);
+  rb_gc_mark(breakpoint->expr);
+}
+
+static VALUE
+Breakpoint_create(VALUE klass)
+{
+    breakpoint_t *breakpoint;
+
+    breakpoint = ALLOC(breakpoint_t);
+    return Data_Wrap_Struct(klass, Breakpoint_mark, xfree, breakpoint);
+}
+
+static VALUE
+Breakpoint_initialize(VALUE self, VALUE source, VALUE pos, VALUE expr)
+{
+  breakpoint_t *breakpoint;
+
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  breakpoint->id = ++breakpoint_max;
+  breakpoint->source = StringValue(source);
+  breakpoint->line = FIX2INT(pos);
+  breakpoint->enabled = Qtrue;
+  breakpoint->expr = NIL_P(expr) ? expr : StringValue(expr);
+
+  return Qnil;
+}
+
+static VALUE
+Breakpoint_remove(VALUE self, VALUE breakpoints, VALUE id_value)
+{
+  int i;
+  int id;
+  VALUE breakpoint_object;
+  breakpoint_t *breakpoint;
+
+  if (breakpoints == Qnil) return Qnil;
+
+  id = FIX2INT(id_value);
+
+  for(i = 0; i < RARRAY_LEN(breakpoints); i++)
+  {
+    breakpoint_object = rb_ary_entry(breakpoints, i);
+    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
+    if(breakpoint->id == id)
+    {
+      rb_ary_delete_at(breakpoints, i);
+      return breakpoint_object;
+    }
+  }
+  return Qnil;
+}
+
+static VALUE
+Breakpoint_id(VALUE self)
+{
+  breakpoint_t *breakpoint;
+
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  return INT2FIX(breakpoint->id);
+}
+
+static VALUE
+Breakpoint_source(VALUE self)
+{
+  breakpoint_t *breakpoint;
+
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  return breakpoint->source;
+}
+
+static VALUE
+Breakpoint_pos(VALUE self)
+{
+  breakpoint_t *breakpoint;
+
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  return INT2FIX(breakpoint->line);
+}
+
+int
+filename_cmp_impl(VALUE source, char *file)
+{
+  char *source_ptr, *file_ptr;
+  long s_len, f_len, min_len;
+  long s,f;
+  int dirsep_flag = 0;
+
+  s_len = RSTRING_LEN(source);
+  f_len = strlen(file);
+  min_len = s_len < f_len ? s_len : f_len;
+
+  source_ptr = RSTRING_PTR(source);
+  file_ptr   = file;
+
+  for( s = s_len - 1, f = f_len - 1; s >= s_len - min_len && f >= f_len - min_len; s--, f-- )
+  {
+    if((source_ptr[s] == '.' || file_ptr[f] == '.') && dirsep_flag)
+      return 1;
+    if(isdirsep(source_ptr[s]) && isdirsep(file_ptr[f]))
+      dirsep_flag = 1;
+#ifdef DOSISH_DRIVE_LETTER
+    else if (s == 0)
+      return(toupper(source_ptr[s]) == toupper(file_ptr[f]));
+#endif
+    else if(source_ptr[s] != file_ptr[f])
+      return 0;
+  }
+  return 1;
+}
+
+int
+filename_cmp(VALUE source, char *file)
+{
+#ifdef _WIN32
+  return filename_cmp_impl(source, file);
+#else
+#ifdef PATH_MAX
+  char path[PATH_MAX + 1];    
+  path[PATH_MAX] = 0;
+  return filename_cmp_impl(source, realpath(file, path) != NULL ? path : file);
+#else
+  char *path;
+  int result;
+  path = realpath(file, NULL);
+  result = filename_cmp_impl(source, path == NULL ? file : path);
+  free(path);
+  return result;
+#endif  
+#endif  
+}
+
+static int
+check_breakpoint_by_pos(VALUE breakpoint_object, char *file, int line)
+{
+    breakpoint_t *breakpoint;
+
+    if(breakpoint_object == Qnil)
+        return 0;
+    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
+    if (Qtrue != breakpoint->enabled) return 0;
+    if(breakpoint->line != line)
+        return 0;
+    if(filename_cmp(breakpoint->source, file))
+        return 1;
+    return 0;
+}
+
+static VALUE
+Breakpoint_find(VALUE self, VALUE breakpoints, VALUE source, VALUE pos, VALUE binding)
+{
+  return breakpoint_find(breakpoints, source, pos, binding);
+}
+
+extern VALUE
+breakpoint_find(VALUE breakpoints, VALUE source, VALUE pos, VALUE binding)
+{
+  VALUE breakpoint_object;
+  char *file;
+  int line;
+  int i;
+
+  file = RSTRING_PTR(source);
+  line = FIX2INT(pos);
+  for(i = 0; i < RARRAY_LEN(breakpoints); i++)
+  {
+    breakpoint_object = rb_ary_entry(breakpoints, i);
+    if (check_breakpoint_by_pos(breakpoint_object, file, line))
+    {
+      return breakpoint_object;
+    }
+  }
+  return Qnil;
+}
+
+extern void
+Init_breakpoint(VALUE mDebase)
+{
+  breakpoint_max = 0;
+  cBreakpoint = rb_define_class_under(mDebase, "Breakpoint", rb_cObject);
+  rb_define_singleton_method(cBreakpoint, "find", Breakpoint_find, 4);
+  rb_define_singleton_method(cBreakpoint, "remove", Breakpoint_remove, 2);
+  rb_define_method(cBreakpoint, "initialize", Breakpoint_initialize, 3);
+  rb_define_method(cBreakpoint, "id", Breakpoint_id, 0);
+  rb_define_method(cBreakpoint, "source", Breakpoint_source, 0);
+  rb_define_method(cBreakpoint, "pos", Breakpoint_pos, 0);
+  rb_define_alloc_func(cBreakpoint, Breakpoint_create);
+}

data/ext/context.c

@@ -0,0 +1,377 @@
+#include <debase_internals.h>
+
+static VALUE cContext;
+static int thnum_current = 0;
+
+static VALUE idAlive;
+
+/* "Step", "Next" and "Finish" do their work by saving information
+   about where to stop next. reset_stopping_points removes/resets this
+   information. */
+extern void
+reset_stepping_stop_points(debug_context_t *context)
+{
+  context->dest_frame = -1;
+  context->stop_line  = -1;
+  context->stop_next  = -1;
+}
+
+static inline VALUE
+Context_thnum(VALUE self) {
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return INT2FIX(context->thnum);
+}
+
+static inline void
+delete_frame(debug_context_t *context)
+{
+  debug_frame_t *frame;
+
+  frame = context->stack;
+  context->stack = frame->prev;
+  context->stack_size--;
+  xfree(frame);
+}
+
+static inline void
+fill_frame(debug_frame_t *frame, char* file, int line, VALUE binding, VALUE self)
+{ 
+  frame->file = file;
+  frame->line = line;
+  frame->binding = binding;
+  frame->self = self;  
+}
+
+static inline VALUE 
+Context_stack_size(VALUE self) 
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return INT2FIX(context->stack_size);
+}
+
+static inline VALUE 
+Context_thread(VALUE self) 
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return context->thread;
+}
+
+static inline VALUE 
+Context_dead(VALUE self) 
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return IS_THREAD_ALIVE(context->thread) ? Qfalse : Qtrue;
+}
+
+extern VALUE 
+Context_ignored(VALUE self) 
+{
+  debug_context_t *context;
+
+  if (self == Qnil) return Qtrue;
+  Data_Get_Struct(self, debug_context_t, context);
+  return CTX_FL_TEST(context, CTX_FL_IGNORE) ? Qtrue : Qfalse;
+}
+
+extern void  
+push_frame(VALUE context_object, char* file, int line, VALUE binding, VALUE self) 
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  frame = ALLOC(debug_frame_t);
+  fill_frame(frame, file, line, binding, self);
+  frame->prev = context->stack;
+  context->stack = frame;
+  context->stack_size++;
+}
+
+extern void
+pop_frame(VALUE context_object) 
+{
+  debug_context_t *context;
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  if (context->stack_size > 0) {
+    delete_frame(context);
+  }
+}
+
+extern void
+update_frame(VALUE context_object, char* file, int line, VALUE binding, VALUE self) 
+{
+  debug_context_t *context;
+  Data_Get_Struct(context_object, debug_context_t, context);
+
+  if (context->stack_size == 0) {
+  	push_frame(context_object, file, line, binding, self);
+    return;
+  }
+  fill_frame(context->stack, file, line, binding, self);
+}
+
+static void 
+Context_mark(debug_context_t *context) 
+{
+  debug_frame_t *frame;
+
+  rb_gc_mark(context->thread);
+  frame = context->stack;
+  while (frame != NULL) {
+    rb_gc_mark(frame->self);
+    rb_gc_mark(frame->binding);
+    frame = frame->prev;
+  }
+}
+
+static void
+Context_free(debug_context_t *context) {
+  while(context->stack_size > 0) {
+    delete_frame(context);
+  }
+  xfree(context);
+}
+
+extern VALUE
+context_create(VALUE thread, VALUE cDebugThread) {
+  debug_context_t *context;
+
+  context = ALLOC(debug_context_t);
+  context->stack_size = 0;
+  context->stack = NULL;
+  context->thnum = ++thnum_current;
+  context->thread = thread;
+  context->flags = 0;
+  context->last_file = NULL;
+  context->last_line = -1;
+  context->stop_frame = -1;
+  reset_stepping_stop_points(context);
+  if(rb_obj_class(thread) == cDebugThread) CTX_FL_SET(context, CTX_FL_IGNORE);
+  return Data_Wrap_Struct(cContext, Context_mark, Context_free, context);
+}
+
+static inline void
+check_frame_number_valid(debug_context_t *context, int frame_no)
+{
+  if (frame_no < 0 || frame_no >= context->stack_size) {
+    rb_raise(rb_eArgError, "Invalid frame number %d, stack (0...%d)",
+        frame_no, context->stack_size);
+  }
+}
+
+static debug_frame_t*
+get_frame_no(debug_context_t *context, int frame_n)
+{
+  debug_frame_t *frame;
+  int i;
+
+  check_frame_number_valid(context, frame_n);
+  frame = context->stack;
+  for (i = 0; i < frame_n; i++) {
+    frame = frame->prev;
+  }
+  return frame;
+}
+
+static VALUE
+Context_frame_file(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return rb_str_new2(frame->file);
+}
+
+static VALUE
+Context_frame_line(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return INT2FIX(frame->line);
+}
+
+static VALUE
+Context_frame_binding(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return frame->binding;
+}
+
+static VALUE
+Context_frame_self(int argc, VALUE *argv, VALUE self)
+{
+  debug_context_t *context;
+  debug_frame_t *frame;
+  VALUE frame_no;
+  int frame_n;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  frame_n = rb_scan_args(argc, argv, "01", &frame_no) == 0 ? 0 : FIX2INT(frame_no);
+  frame = get_frame_no(context, frame_n);
+  return frame->self;
+}
+
+static VALUE
+Context_stop_reason(VALUE self)
+{
+    debug_context_t *context;
+    const char *symbol;
+
+    Data_Get_Struct(self, debug_context_t, context);
+    
+    switch(context->stop_reason)
+    {
+        case CTX_STOP_STEP:
+            symbol = "step";
+            break;
+        case CTX_STOP_BREAKPOINT:
+            symbol = "breakpoint";
+            break;
+        case CTX_STOP_CATCHPOINT:
+            symbol = "catchpoint";
+            break;
+        case CTX_STOP_NONE:
+        default:
+            symbol = "none";
+    }
+    if(CTX_FL_TEST(context, CTX_FL_DEAD))
+        symbol = "post-mortem";
+    
+    return ID2SYM(rb_intern(symbol));
+}
+
+static VALUE
+Context_stop_next(int argc, VALUE *argv, VALUE self)
+{
+  VALUE steps;
+  VALUE force;
+  debug_context_t *context;
+
+  rb_scan_args(argc, argv, "11", &steps, &force);
+  if(FIX2INT(steps) < 0) rb_raise(rb_eRuntimeError, "Steps argument can't be negative.");
+
+  Data_Get_Struct(self, debug_context_t, context);
+  context->stop_next = FIX2INT(steps);
+  if(RTEST(force))
+      CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
+  else
+      CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
+
+  return steps;
+}
+
+static VALUE
+Context_step_over(int argc, VALUE *argv, VALUE self)
+{
+  VALUE lines, frame, force;
+  debug_context_t *context;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  if(context->stack_size == 0)
+    rb_raise(rb_eRuntimeError, "No frames collected.");
+
+  rb_scan_args(argc, argv, "12", &lines, &frame, &force);
+  context->stop_line = FIX2INT(lines);
+  CTX_FL_UNSET(context, CTX_FL_STEPPED);
+  if(frame == Qnil)
+  {
+    context->dest_frame = context->stack_size;
+  }
+  else
+  {
+    if(FIX2INT(frame) < 0 && FIX2INT(frame) >= context->stack_size)
+      rb_raise(rb_eRuntimeError, "Destination frame is out of range.");
+    context->dest_frame = context->stack_size - FIX2INT(frame);
+  }
+  if(RTEST(force))
+    CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
+  else
+    CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
+
+  return Qnil;
+}
+
+static VALUE
+Context_stop_frame(VALUE self, VALUE frame)
+{
+  debug_context_t *debug_context;
+
+  Data_Get_Struct(self, debug_context_t, debug_context);
+  if(FIX2INT(frame) < 0 && FIX2INT(frame) >= debug_context->stack_size)
+    rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+  debug_context->stop_frame = debug_context->stack_size - FIX2INT(frame);
+
+  return frame;
+}
+
+/*
+ *   Document-class: Context
+ *
+ *   == Summary
+ *
+ *   Debugger keeps a single instance of this class for each Ruby thread.
+ */
+VALUE
+Init_context(VALUE mDebase)
+{
+  cContext = rb_define_class_under(mDebase, "Context", rb_cObject);
+  rb_define_method(cContext, "stack_size", Context_stack_size, 0);
+  rb_define_method(cContext, "thread", Context_thread, 0);
+  rb_define_method(cContext, "dead?", Context_dead, 0);
+  rb_define_method(cContext, "ignored?", Context_ignored, 0);
+  rb_define_method(cContext, "thnum", Context_thnum, 0);
+  rb_define_method(cContext, "stop_reason", Context_stop_reason, 0);
+  rb_define_method(cContext, "frame_file", Context_frame_file, -1);
+  rb_define_method(cContext, "frame_line", Context_frame_line, -1);
+  rb_define_method(cContext, "frame_binding", Context_frame_binding, -1);
+  rb_define_method(cContext, "frame_self", Context_frame_self, -1);
+  rb_define_method(cContext, "stop_next=", Context_stop_next, -1);
+  rb_define_method(cContext, "step", Context_stop_next, -1);
+  rb_define_method(cContext, "step_over", Context_step_over, -1);
+  rb_define_method(cContext, "stop_frame=", Context_stop_frame, 1);
+
+  idAlive = rb_intern("alive?");
+
+  return cContext;
+    // 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, "ignored?", context_ignored, 0);
+    // rb_define_method(cContext, "frame_args", context_frame_args, -1);
+    // rb_define_method(cContext, "frame_args_info", context_frame_args_info, -1);
+    // rb_define_method(cContext, "frame_class", context_frame_class, -1);
+    // rb_define_method(cContext, "frame_id", context_frame_id, -1);
+    // rb_define_method(cContext, "frame_locals", context_frame_locals, -1);
+    // rb_define_method(cContext, "frame_method", context_frame_id, -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 */
+    // rb_define_method(cContext, "jump", context_jump, 2);
+    // rb_define_method(cContext, "pause", context_pause, 0);
+}