call_stack 0.1.0.0

data/LICENSE

@@ -0,0 +1,56 @@
+call_stack is copyrighted free software by Mauricio Fernandez <mfp@acm.org>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see the file GPL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.en

@@ -0,0 +1,76 @@
+call_stack  copyright (c) 2006 Mauricio Fernandez <mfp@acm.org>
+Use and redistribution subject to the same terms as Ruby.
+
+== Overview
+
+call_stack allows you to obtain backtrace data in your Ruby code.
+It is used as follows:
+
+    require 'call_stack'
+
+    call_stack_on    # start recording information
+
+    #.... somewhere else
+    def b; foo end
+    def foo
+      backtrace = call_stack(-1)
+    end
+
+    b     # => [[:unknown, :unknown, "-", 3, nil, nil], 
+                [Object, :b, "-", 7, #<Binding:0xa7dbe6b8>, :Ruby], 
+		[Object, :foo, "-", 8, #<Binding:0xa7dbe690>, :Ruby]]
+ 
+    call_stack_off
+
+Kernel#call_stack returns an array of 
+[class, mid, filename, line, binding, language]
+arrays, where language is either :Ruby, :C or nil. Older stack frames come
+first, newer last.
+
+Information from stack frames which existed before #call_stack_on was called
+will be incomplete.
+
+With no arguments, #call_stack will return an array with only one element
+(with the structure described above), corresponding to the context where
+#call_stack was called, e.g.
+
+    require 'call_stack'
+    call_stack_on
+    def foo; call_stack end
+    foo          # => [[Object, :foo, "-", 4, #<Binding:0xa7d90880>, :Ruby]]
+
+With a negative argument, #call_stack returns the whole call stack.
+If a positive argument is given, as many levels as indicated will be returned;
+call_stack()  is equivalent to  call_stack(1).
+
+
+== Binding.of_caller compatibility
+
+binding_of_caller.rb contains an implementation of Binding.of_caller built on
+top of call_stack. It will make your program somewhat slower, so you might
+want to write your own (it takes 3 lines of code) and postpone the call to
+#call_stack_on until it's needed.
+
+== Use with Ruby on Rails
+
+Rails' breakpoint functionality doesn't work with 1.8.5, since it depends on
+the "standard" Binding.of_caller, which won't run on Ruby > 1.8.4. 
+
+This can be overcome by using call_stack with Rails' breakpointer as follows:
+    ruby -rbreakpoint185 script/server
+and then, in another console
+    script/breakpointer
+
+== Installing
+
+De-compress the archive and enter its top directory.
+Then type:
+
+   ($ su)
+    # ruby setup.rb
+
+Run  ruby setup.rb --help  for information on the install options.
+
+== License
+
+call_stack is licensed under the same terms as Ruby. See LICENSE.

data/Rakefile

@@ -0,0 +1,95 @@
+
+# {{{ Package tasks
+
+CALL_STACK_VERSION = File.read("VERSION").chomp
+
+PKG_REVISION = ".0"
+PKG_FILES = FileList[
+"ext/call_stack/*.c",
+"ext/call_stack/*.h",
+"ext/call_stack/extconf.rb",
+"lib/**/*.rb",
+"LICENSE", "Rakefile", "README.*", "THANKS", "VERSION", "example.rb",
+"mingw-rbconfig.rb", "setup.rb"
+]
+
+require 'rake/gempackagetask'
+Spec = Gem::Specification.new do |s|
+  s.name = "call_stack"
+  s.version = CALL_STACK_VERSION + PKG_REVISION
+  s.summary = "Call stack information and Binding.of_caller/breakpoint workaround for Ruby 1.8.5"
+  s.description = <<EOF
+call_stack can be used to obtain backtrace information in a running program.
+It also contains a new Binding.of_caller implementation that works with Ruby 1.8.5.
+
+It can be used with Rails' breakpointer as follows:
+    ruby -rbreakpoint185 script/server
+and then, in another console
+    script/breakpointer
+EOF
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+  s.extensions << "ext/call_stack/extconf.rb"
+  s.author = "Mauricio Fernandez"
+  s.email = "mfp@acm.org"
+  s.homepage = "http://eigenclass.org/"
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w[README.en]
+  s.rdoc_options << "--main" << "README.en" << "--title" << 'call_stack'
+  s.post_install_message = <<EOF
+
+=============================================================================
+
+call_stack provides an alternative implementation of Binding.of_caller that
+works on Ruby > 1.8.4. You can use it by loading breakpoint185.rb before
+running your program.
+
+If you're using Rails, you can do
+    ruby -rbreakpoint185 script/server
+and then, in another console
+    script/breakpointer
+
+=============================================================================
+
+EOF
+end
+
+Rake::GemPackageTask.new(Spec) do |p|
+  p.need_tar = true
+end
+
+# {{{ Cross-compilation and building of a binary RubyGems package for mswin32
+
+require 'rake/clean'
+
+WIN32_PKG_DIR = "call_stack-" + CALL_STACK_VERSION + PKG_REVISION
+
+file "#{WIN32_PKG_DIR}" => [:package] do
+  sh "tar zxf pkg/#{WIN32_PKG_DIR}.tgz"
+end
+
+desc "Cross-compile the rcovrt.so extension for win32"
+file "call_stack_win32" => ["#{WIN32_PKG_DIR}"] do
+  cp "mingw-rbconfig.rb", "#{WIN32_PKG_DIR}/ext/call_stack/rbconfig.rb"
+  sh "cd #{WIN32_PKG_DIR}/ext/call_stack/ && ruby -I. extconf.rb && make"
+  mv "#{WIN32_PKG_DIR}/ext/call_stack/call_stack.so", "#{WIN32_PKG_DIR}/lib"
+end
+
+Win32Spec = Spec.clone
+Win32Spec.platform = Gem::Platform::WIN32
+Win32Spec.extensions = []
+Win32Spec.files += ["lib/call_stack.so"]
+
+desc "Build the binary RubyGems package for win32"
+task :rubygems_win32 => ["call_stack_win32"] do
+  Dir.chdir("#{WIN32_PKG_DIR}") do
+    Gem::Builder.new(Win32Spec).build
+    verbose(true) {
+      mv Dir["*.gem"].first, "../pkg/call_stack-#{CALL_STACK_VERSION + PKG_REVISION}-mswin32.gem"
+    }
+  end
+end
+
+CLEAN.include "#{WIN32_PKG_DIR}"
+
+# vim: set sw=2 ft=ruby:

data/THANKS

@@ -0,0 +1,5 @@
+
+Kent Sibilev
+* create_binding() was stolen from his excellent ruby-debug, replacing
+  an rb_funcall()
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/example.rb

@@ -0,0 +1,42 @@
+
+require 'call_stack'
+def a; _a = 1; b end
+def b; _b = 2; c end
+def c; _c = 3; d end
+def d; _d = 4; send(:e) end
+def e
+  levels = call_stack(10)
+  levels.each do |klass, id, file, line, binding, lang|
+    puts "=" * 80
+    p [klass, id, file, line, lang]
+    next unless binding
+    p eval("local_variables", binding).map{|x| [x, eval(x, binding)]}
+  end
+end
+
+def x
+  call_stack_on
+  a
+  call_stack_off
+end
+
+x
+
+
+# binding of caller
+require 'binding_of_caller'
+
+def foo
+  a = b = 1
+  puts bar.inspect, a, b
+end
+
+def bar
+  Binding.of_caller do |binding|
+    ret = eval("[a,b]", binding)
+    eval("a, b = 2, 3", binding)
+    ret
+  end
+end
+
+foo

data/ext/call_stack/call_stack.c

@@ -0,0 +1,493 @@
+
+#include <ruby.h>
+#include <node.h>
+#include <st.h>
+#include <stdlib.h>
+
+#define CALLSITE_DEBUG 0
+#define CALLSITE_DEBUG_EVENTS 0
+
+static char callsite_hook_set_p;
+
+typedef struct {
+        char *sourcefile;
+        unsigned int sourceline;
+        ID mid;
+        VALUE klass;
+        VALUE binding;
+        VALUE type;
+} code_site_t;
+static VALUE additional_gc_roots = 0;
+
+static caller_stack_len = 1;
+static ID id_unknown;
+static ID id_binding;
+static VALUE sym_C;
+static VALUE sym_Ruby;
+
+typedef struct {
+    code_site_t *start;
+    code_site_t *end;
+    code_site_t *ptr;
+} callsite_stack_t;
+static callsite_stack_t *callsite_stack;
+static VALUE callsite_last_thread;
+static st_table* callsite_stack_tbl;
+static st_table* callsite_filename_tbl;
+
+static st_table* callsite_defsite_data;
+static st_table* callsite_caller_data;
+
+static VALUE module_to_s_proc;
+
+#define INITIAL_STACK_SIZE 8
+
+
+static int
+value_cmp(VALUE x, VALUE y)
+{
+  return x != y;
+}
+
+static int
+value_hash(VALUE v)
+{
+  return v;
+}
+
+static struct st_hash_type type_value_hash = {
+        value_cmp,
+        value_hash,
+#if RUBY_VERSION_CODE >= 190
+        st_nothing_key_free,
+        st_nothing_key_clone
+#endif
+};
+
+
+typedef struct {
+        VALUE klass;
+        ID    mid;
+} meth_selector;
+
+static int
+meth_selector_cmp(meth_selector* x, meth_selector* y)
+{
+  return (x->klass != y->klass || x->mid != y->mid);
+}
+
+static int
+meth_selector_hash(meth_selector* x)
+{
+  return (x->mid << 10) | (x->klass >> 2);
+}
+
+static struct st_hash_type type_meth_selector_hash = {
+        meth_selector_cmp,
+        meth_selector_hash,
+#if RUBY_VERSION_CODE >= 190
+        HeyFIXME,
+        HeyFIXME
+#endif
+};
+        
+
+/*
+ *
+ * callsite hook and associated functions
+ *
+ * */
+
+static VALUE
+callsite_gen_backtrace_info(int argc, VALUE *argv, VALUE self)
+{
+  VALUE backtrace;
+  VALUE level;
+  VALUE klass;
+  VALUE depth = Qnil;
+  unsigned int i;
+  code_site_t *csite;
+  int len;
+
+  if(!callsite_hook_set_p) {
+          return Qnil;
+  }
+  rb_scan_args(argc, argv, "01", &depth);
+  if(NIL_P(depth)) {
+          len = 1;
+  } else {
+          len = NUM2INT(depth);
+  }
+  if(len < 0) {
+          len = 0x7FFFFFFF;
+  }
+  backtrace = rb_ary_new();
+  for(i = 0, csite = callsite_stack->ptr-2; i < len; i++, csite--) {
+          if(csite < callsite_stack->start)
+                  break;
+          level = rb_ary_new();
+          klass = csite->klass ? csite->klass : Qnil;
+          rb_ary_push(level, klass);
+          rb_ary_push(level, csite->mid ? ID2SYM(csite->mid) : Qnil);
+          if(csite->sourcefile) {
+                  rb_ary_push(level, rb_str_new2(csite->sourcefile));
+                  rb_ary_push(level, UINT2NUM(csite->sourceline));
+          }
+          else {
+                  rb_ary_push(level, Qnil);
+                  rb_ary_push(level, Qnil);
+          }
+          rb_ary_push(level, csite->binding);
+          rb_ary_push(level, csite->type);
+
+          rb_ary_unshift(backtrace, level);
+  }
+
+
+  return backtrace;
+}
+
+
+static callsite_stack_t *
+callsite_stack_create()
+{
+    callsite_stack_t *stack;
+
+    stack = ALLOC(callsite_stack_t);
+    stack->start = stack->ptr =
+	ALLOC_N(code_site_t, INITIAL_STACK_SIZE);
+    stack->end = stack->start + INITIAL_STACK_SIZE;
+    return stack;
+}
+
+static void
+callsite_stack_free(callsite_stack_t *stack)
+{
+  xfree(stack->start);
+  xfree(stack);
+}
+
+static void
+callsite_stack_push(VALUE klass, ID mid, 
+                    char *filename, unsigned int line, VALUE binding,
+                    VALUE type)
+{
+  char *sourcefile;
+
+  if (callsite_stack->ptr == callsite_stack->end) {
+          code_site_t *new_start;
+          int len, new_capa;
+
+          len = callsite_stack->ptr - callsite_stack->start;
+          new_capa = (callsite_stack->end - callsite_stack->start) * 2;
+          new_start = ALLOC_N(code_site_t, new_capa);
+          memcpy(new_start, callsite_stack->start, sizeof(code_site_t) * len);
+          callsite_stack->start = new_start;
+          callsite_stack->end = new_start + new_capa;
+          callsite_stack->ptr = new_start + len;
+  }
+  callsite_stack->ptr->klass = klass ? klass : Qnil;
+  callsite_stack->ptr->mid = mid ? mid : id_unknown;
+  if(filename) {
+          /* have to copy the filename, since it could be reclaimed by Ruby */
+          if(!st_lookup(callsite_filename_tbl, (st_data_t)filename, (st_data_t*)&sourcefile)) {
+                  sourcefile = strdup(filename);
+                  st_insert(callsite_filename_tbl, (st_data_t)sourcefile, (st_data_t)sourcefile);
+          }
+          callsite_stack->ptr->sourcefile = sourcefile;
+  } else {
+          callsite_stack->ptr->sourcefile = 0;
+  }        
+  callsite_stack->ptr->sourceline = line ? line : 0;
+  callsite_stack->ptr->binding = binding;
+  callsite_stack->ptr->type = type;
+  rb_hash_aset(additional_gc_roots, binding, binding);
+
+  callsite_stack->ptr++;
+}
+
+
+static VALUE
+remove_gc_root(VALUE arg)
+{
+  rb_hash_delete(additional_gc_roots, arg);
+}
+
+static VALUE
+dummy(VALUE arg1, VALUE arg2)
+{
+  return Qnil;
+}
+
+static inline code_site_t *
+callsite_stack_pop(callsite_stack_t *stack)
+{
+    if (stack->ptr == stack->start) {
+        return stack->ptr;
+        //rb_raise(rb_eException, "empty stack");
+    }
+    /* this is what we want to do, but it's not safe because rb_hash_delete
+     * will reuse the current block ... */
+    /* rb_hash_delete(additional_gc_roots, (stack->ptr-1)->binding); */
+    rb_iterate(remove_gc_root, (stack->ptr-1)->binding, dummy, Qnil);
+    return --stack->ptr;
+}
+
+
+static st_table *
+callsite_stack_table_create()
+{
+    return st_init_table(&type_value_hash);
+}
+
+
+static inline callsite_stack_t*
+callsite_stack_find(VALUE thread)
+{ 
+  st_data_t val;
+
+  if(st_lookup(callsite_stack_tbl, (st_data_t)thread, &val))
+          return (callsite_stack_t *) val;
+  else
+          return NULL;
+}
+
+
+static inline int
+callsite_stack_table_insert(VALUE thread, callsite_stack_t *stack)
+{
+    return st_insert(callsite_stack_tbl, (st_data_t ) thread, (st_data_t) stack);
+}
+
+
+static void
+callsite_stack_dump()
+{
+  code_site_t *csite;
+  int status;
+  VALUE klass_desc;
+  char *desc;
+  VALUE old_exception;
+
+  old_exception = rb_gv_get("$!");
+  printf("+++++++++\n");
+  printf("CALL STACK FOR CURRENT THREAD:\n");
+  for(csite = callsite_stack->start; csite < callsite_stack->ptr; csite++) {
+          klass_desc = rb_protect(rb_inspect, csite->klass, &status);
+          if(!status) {
+                  desc = RSTRING(klass_desc)->ptr;
+          } else {
+                  desc = rb_obj_classname(csite->klass);
+          }
+          printf("%30s %20s %s %d\n", desc,
+                 csite->mid ? rb_id2name(csite->mid) : "",
+                 csite->sourcefile ? csite->sourcefile : "unknown",
+                 csite->sourceline);
+  }
+  printf("---------\n");
+  
+  rb_gv_set("$!", old_exception);
+  
+}
+
+/* This function stolen from Kent Sibilev's ruby-debug. */
+/*
+ * This is a NASTY HACK. For some reasons rb_f_binding is declared 
+ * 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)
+    {
+        NODE *body, *method;
+        st_lookup(RCLASS(rb_mKernel)->m_tbl, rb_intern("binding"), (st_data_t *)&body);
+        method       = (NODE *)body->u2.value;
+        f_binding    = (bind_func_t)method->u1.value;
+    }
+    return f_binding(self);
+}
+
+static void
+callsite_select_callsite_stack()
+{
+  VALUE curr_thread;
+  curr_thread = rb_thread_current();
+  if (curr_thread != callsite_last_thread) {
+          callsite_stack = callsite_stack_find(curr_thread);
+          if (!callsite_stack) {
+                  callsite_stack = callsite_stack_create();
+                  callsite_stack_table_insert(curr_thread, callsite_stack);
+                  /* no need to add curr_thread to the additional root list for
+                   * the GC: we will never it if the Thread disappears anyway,
+                   * so no access is done to the (dead) Ruby object. */
+          }
+          callsite_last_thread = curr_thread;
+  }
+}
+
+  
+static void
+coverage_event_callsite_hook(rb_event_t event, NODE *node, VALUE self, 
+                ID mid, VALUE klass)
+{
+ VALUE curr_meth;
+ VALUE args[4];
+ VALUE binding;
+ int status;
+ static int in_hook = 0;
+
+ if(in_hook)
+         return;
+ in_hook++;
+ callsite_select_callsite_stack();
+
+ if(TYPE(klass) == T_ICLASS) {
+         klass = RBASIC(klass)->klass;
+ }
+#if CALLSITE_DEBUG_EVENTS
+ do {
+         VALUE old_exception;
+         old_exception = rb_gv_get("$!");
+         rb_protect(rb_inspect, klass, &status);
+         if(!status) {
+                 printf("EVENT: %d %s %s %s %d\n", event,
+                                 klass ? RSTRING(rb_inspect(klass))->ptr : "", 
+                                 mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid))
+                                 : "unknown",
+                                 node ? node->nd_file : "", node ? nd_line(node) : 0);
+         } else {
+                 printf("EVENT: %d %s %s %d\n", event,
+                                 mid ? (mid == ID_ALLOCATOR ? "ID_ALLOCATOR" : rb_id2name(mid)) 
+                                 : "unknown",
+                                 node ? node->nd_file : "", node ? nd_line(node) : 0);
+         }
+         rb_gv_set("$!", old_exception);
+ } while (0); 
+#endif
+ switch(event) {
+ case RUBY_EVENT_CALL:
+         binding = create_binding(rb_mKernel);
+         callsite_stack_push(klass, mid, node->nd_file, nd_line(node) + 1, binding, sym_Ruby);
+#if CALLSITE_DEBUG
+         callsite_stack_dump();
+#endif
+         break;
+ case RUBY_EVENT_C_CALL:
+         callsite_stack_push(klass, mid, 0, 0, Qnil, sym_C);
+         break;
+ case RUBY_EVENT_RETURN:
+ case RUBY_EVENT_C_RETURN:
+         callsite_stack_pop(callsite_stack);
+#if CALLSITE_DEBUG
+         callsite_stack_dump();
+#endif
+         break;
+ }
+ in_hook--;
+}
+
+
+static void
+callsite_prefill_callsite_stack()
+{
+  VALUE backtrace;
+  VALUE str;
+  VALUE parts;
+  int i;
+  char *sourcefile;
+  unsigned int sourceline;
+  VALUE meth;
+  ID aref;
+  VALUE regex;
+  ID mid;
+  VALUE sym_unknown;
+  
+  callsite_select_callsite_stack();
+  aref = rb_intern("[]");
+  regex = rb_eval_string("/in `([^']*)'/");
+  sym_unknown = ID2SYM(rb_intern("unknown"));
+  /* reset before refilling */
+  callsite_stack->ptr = callsite_stack->start;
+
+  backtrace = rb_funcall(rb_mKernel, rb_intern("caller"), 0);
+  if(TYPE(backtrace) == T_ARRAY) {
+         for(i = RARRAY(backtrace)->len - 1; i >= 0; i--) {
+                 str = RARRAY(backtrace)->ptr[i];
+                 parts = rb_str_split(str, ":");
+                 if(RARRAY(parts)->len < 2) {
+                         sourcefile = "unknown";
+                         sourceline = 0;
+                 } else { 
+                         sourcefile = RSTRING(RARRAY(parts)->ptr[0])->ptr;
+                         sscanf(RSTRING((RARRAY(parts)->ptr[1]))->ptr,
+                                "%d", &sourceline);
+                 }
+                 if( RTEST(meth = rb_funcall(str, aref, 2, regex, INT2FIX(1))) ) {
+                         /* FIXME: check type */
+                         mid = rb_intern(RSTRING(meth)->ptr);
+                 } else {
+                         mid = rb_intern("unknown");
+                 }
+                 callsite_stack_push(sym_unknown, mid, sourcefile, sourceline, 
+                                     Qnil, Qnil);
+         }
+
+  }
+  else {
+          rb_raise(rb_eRuntimeError, "Your Kernel#caller is weird.");
+  }
+}
+
+static VALUE
+cov_install_callsite_hook(VALUE self)
+{
+  if(!callsite_hook_set_p) {
+          callsite_hook_set_p = 1;
+          /* for each thread */
+          callsite_prefill_callsite_stack();
+          rb_add_event_hook(coverage_event_callsite_hook, 
+                          RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | 
+                          RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN);
+          
+          return Qtrue;
+  } else
+          return Qfalse;
+}
+
+
+static VALUE
+cov_remove_callsite_hook(VALUE self)
+{
+ if(!callsite_hook_set_p) 
+         return Qfalse;
+ else {
+         rb_remove_event_hook(coverage_event_callsite_hook);
+         callsite_hook_set_p = 0;
+         return Qtrue;
+ }
+}
+
+
+
+void
+Init_call_stack()
+{
+ id_unknown = rb_intern("unknown");
+ sym_C = ID2SYM(rb_intern("C"));
+ sym_Ruby = ID2SYM(rb_intern("Ruby"));
+ id_binding = rb_intern("binding");
+
+ additional_gc_roots = rb_hash_new();
+ rb_gc_register_address(&additional_gc_roots);
+ callsite_stack_tbl = st_init_table(&type_value_hash);
+ callsite_filename_tbl = st_init_strtable();
+
+ rb_define_global_function("call_stack_on", cov_install_callsite_hook, 0);
+ rb_define_global_function("call_stack_off", cov_remove_callsite_hook, 0);
+ rb_define_global_function("call_stack", callsite_gen_backtrace_info, -1);
+}
+/* vim: set sw=8 expandtab: */