relevance-rcov 0.8.3.2 → 0.8.3.3

data/ext/rcovrt/1.9/callsite.c

@@ -2,27 +2,22 @@
 #include <ruby/st.h>
 #include <stdlib.h>
 
+#define DEBUG 0
+
 static char callsite_hook_set_p;
 
 typedef struct {
-        const char *sourcefile;
-        unsigned int sourceline;
-        VALUE curr_meth;
+  const char *sourcefile;
+  unsigned int sourceline;
+  VALUE curr_meth;
 } type_def_site;       
+
 static VALUE caller_info = 0;
 static VALUE method_def_site_info = 0;
 
 static int caller_stack_len = 1;
 
-/*
- *
- * callsite hook and associated functions
- *
- * */
-
-static VALUE
-record_callsite_info(VALUE args)
-{
+static VALUE record_callsite_info(VALUE args) {
   VALUE caller_ary;
   VALUE curr_meth;
   VALUE count_hash;
@@ -32,58 +27,57 @@ record_callsite_info(VALUE args)
   caller_ary = pargs[0];
   curr_meth = pargs[1];
   count_hash = rb_hash_aref(caller_info, curr_meth);
+  
   if(TYPE(count_hash) != T_HASH) { 
-          /* Qnil, anything else should be impossible unless somebody's been
-           * messing with ObjectSpace */
-          count_hash = rb_hash_new();
-          rb_hash_aset(caller_info, curr_meth, count_hash);
+    /* Qnil, anything else should be impossible unless somebody's been
+     * messing with ObjectSpace */
+    count_hash = rb_hash_new();
+    rb_hash_aset(caller_info, curr_meth, count_hash);
   }
+  
   count = rb_hash_aref(count_hash, caller_ary);
+  
   if(count == Qnil) 
-          count = INT2FIX(0);
+    count = INT2FIX(0);
+  
   count = INT2FIX(FIX2UINT(count) + 1);
   rb_hash_aset(count_hash, caller_ary, count);
-  /* * /
-  printf("CALLSITE: %s -> %s   %d\n", RSTRING_PTR(rb_inspect(curr_meth)),
-                  RSTRING_PTR(rb_inspect(caller_ary)), FIX2INT(count));
-  / * */
+
+  if(DEBUG == 1)
+    printf("CALLSITE: %s -> %s   %d\n", RSTRING_PTR(rb_inspect(curr_meth)), RSTRING_PTR(rb_inspect(caller_ary)), FIX2INT(count));
 
   return Qnil;
 }
 
-
-static VALUE
-record_method_def_site(VALUE args)
-{
+static VALUE record_method_def_site(VALUE args) {
   type_def_site *pargs = (type_def_site *)args;
   VALUE def_site_info;
-  // VALUE hash;
 
   if( RTEST(rb_hash_aref(method_def_site_info, pargs->curr_meth)) )
-          return Qnil;
+    return Qnil;
+  
   def_site_info = rb_ary_new();
   rb_ary_push(def_site_info, rb_str_new2(pargs->sourcefile));
   rb_ary_push(def_site_info, INT2NUM(pargs->sourceline+1));
   rb_hash_aset(method_def_site_info, pargs->curr_meth, def_site_info);
-  /* * /
-  printf("DEFSITE: %s:%d  for %s\n", pargs->sourcefile, pargs->sourceline+1,
-                  RSTRING_PTR(rb_inspect(pargs->curr_meth)));
-  / * */
+
+  if(DEBUG == 1)
+    printf("DEFSITE: %s:%d  for %s\n", pargs->sourcefile, pargs->sourceline+1, RSTRING_PTR(rb_inspect(pargs->curr_meth)));
   
   return Qnil;
 }
 
-static VALUE
-callsite_custom_backtrace(int lev)
-{
+static VALUE callsite_custom_backtrace(int lev) {
   ID id;
   VALUE klass;
   VALUE klass_path;
   VALUE eval_string;
   
   rb_frame_method_id_and_class(&id, &klass);
+  
   if (id == ID_ALLOCATOR)
     return Qnil;
+  
   if (klass) {
     if (TYPE(klass) == T_ICLASS) {
       klass = RBASIC(klass)->klass;
@@ -100,6 +94,7 @@ callsite_custom_backtrace(int lev)
   
   klass_path = rb_class_path(klass);
   VALUE reciever = rb_funcall(rb_binding_new(), rb_intern("eval"), 1, rb_str_new2("self"));
+  
   if (rb_funcall(klass, rb_intern("=="), 1, reciever) == Qtrue) {
     klass_path = rb_sprintf("\"#<Class:%s>\"", RSTRING_PTR(klass_path));
     OBJ_FREEZE(klass_path);
@@ -109,10 +104,7 @@ callsite_custom_backtrace(int lev)
   return rb_eval_string(RSTRING_PTR(eval_string));
 }
 
-static void
-coverage_event_callsite_hook(rb_event_flag_t event, VALUE node, 
-                VALUE self, ID mid, VALUE klass)
-{
+static void coverage_event_callsite_hook(rb_event_flag_t event, VALUE node,  VALUE self, ID mid, VALUE klass) {
   VALUE caller_ary;
   VALUE curr_meth;
   VALUE args[2];
@@ -142,9 +134,10 @@ coverage_event_callsite_hook(rb_event_flag_t event, VALUE node,
   
   klass_path = rb_class_path(klass);
   VALUE reciever = rb_funcall(rb_binding_new(), rb_intern("eval"), 1, rb_str_new2("self"));
+
   if (rb_funcall(klass, rb_intern("=="), 1, reciever) == Qtrue) {
     klass_path = rb_sprintf("#<Class:%s>", RSTRING_PTR(klass_path));
-   OBJ_FREEZE(klass_path);
+    OBJ_FREEZE(klass_path);
   }
     
   rb_ary_push(curr_meth, klass_path);
@@ -162,43 +155,36 @@ coverage_event_callsite_hook(rb_event_flag_t event, VALUE node,
     args.curr_meth = curr_meth;
     rb_protect(record_method_def_site, (VALUE)&args, NULL);
   }
+
   if(status)
     rb_gv_set("$!", Qnil);
 }
 
-
-static VALUE
-cov_install_callsite_hook(VALUE self)
-{
+static VALUE cov_install_callsite_hook(VALUE self) {
   if(!callsite_hook_set_p) {
-          if(TYPE(caller_info) != T_HASH)
-                  caller_info = rb_hash_new();
-          callsite_hook_set_p = 1;
-          VALUE something = 0;
-          rb_add_event_hook(coverage_event_callsite_hook, 
-                  RUBY_EVENT_CALL, something);
-          return Qtrue;
-  } else
-          return Qfalse;
+    if(TYPE(caller_info) != T_HASH)
+      caller_info = rb_hash_new();
+    callsite_hook_set_p = 1;
+    VALUE something = 0;
+    rb_add_event_hook(coverage_event_callsite_hook, 
+                      RUBY_EVENT_CALL, something);
+    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;
- }
+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;
+  }
 }
 
-
-static VALUE
-cov_generate_callsite_info(VALUE self)
-{
+static VALUE cov_generate_callsite_info(VALUE self) {
   VALUE ret;
 
   ret = rb_ary_new();
@@ -207,52 +193,42 @@ cov_generate_callsite_info(VALUE self)
   return ret;
 }
 
-
-static VALUE
-cov_reset_callsite(VALUE self)
-{
+static VALUE cov_reset_callsite(VALUE self) {
   if(callsite_hook_set_p) {
-	  rb_raise(rb_eRuntimeError, 
-		  "Cannot reset the callsite info in the middle of a traced run.");
-	  return Qnil;
+    rb_raise(rb_eRuntimeError, "Cannot reset the callsite info in the middle of a traced run.");
+    return Qnil;
   }
-
+  
   caller_info = rb_hash_new();
   method_def_site_info = rb_hash_new();
   return Qnil;
 }
 
-void
-Init_rcov_callsite()
-{
- VALUE mRcov;
- VALUE mRCOV__;
- ID id_rcov = rb_intern("Rcov");
- ID id_coverage__ = rb_intern("RCOV__");
- // ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
-
- if(rb_const_defined(rb_cObject, id_rcov)) 
-         mRcov = rb_const_get(rb_cObject, id_rcov);
- else
-         mRcov = rb_define_module("Rcov");
-
- if(rb_const_defined(mRcov, id_coverage__))
-         mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
- else
-         mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
+void Init_rcov_callsite() {
+  VALUE mRcov;
+  VALUE mRCOV__;
+  ID id_rcov = rb_intern("Rcov");
+  ID id_coverage__ = rb_intern("RCOV__");
+  // ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
+  
+  if(rb_const_defined(rb_cObject, id_rcov)) 
+    mRcov = rb_const_get(rb_cObject, id_rcov);
+  else
+    mRcov = rb_define_module("Rcov");
+  
+  if(rb_const_defined(mRcov, id_coverage__))
+    mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
+  else
+    mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
 
- callsite_hook_set_p = 0;
- caller_info = rb_hash_new();
- method_def_site_info = rb_hash_new();
- rb_gc_register_address(&caller_info);
- rb_gc_register_address(&method_def_site_info);
- 
- rb_define_singleton_method(mRCOV__, "install_callsite_hook", 
-                 cov_install_callsite_hook, 0);
- rb_define_singleton_method(mRCOV__, "remove_callsite_hook", 
-                 cov_remove_callsite_hook, 0);
- rb_define_singleton_method(mRCOV__, "generate_callsite_info", 
-		 cov_generate_callsite_info, 0);
- rb_define_singleton_method(mRCOV__, "reset_callsite", cov_reset_callsite, 0);
+  callsite_hook_set_p = 0;
+  caller_info = rb_hash_new();
+  method_def_site_info = rb_hash_new();
+  rb_gc_register_address(&caller_info);
+  rb_gc_register_address(&method_def_site_info);
+  
+  rb_define_singleton_method(mRCOV__, "install_callsite_hook", cov_install_callsite_hook, 0);
+  rb_define_singleton_method(mRCOV__, "remove_callsite_hook", cov_remove_callsite_hook, 0);
+  rb_define_singleton_method(mRCOV__, "generate_callsite_info", cov_generate_callsite_info, 0);
+  rb_define_singleton_method(mRCOV__, "reset_callsite", cov_reset_callsite, 0);
 }
-/* vim: set sw=8 expandtab: */

data/ext/rcovrt/1.9/rcovrt.c

@@ -17,236 +17,195 @@ static st_table* coverinfo = 0;
 static char coverage_hook_set_p;
 
 struct cov_array {
-        unsigned int len;
-        unsigned int *ptr;
+  unsigned int len;
+  unsigned int *ptr;
 };
 
 static struct cov_array *cached_array = 0;
 static char *cached_file = 0; 
 
-/* 
- *
- * coverage hook and associated functions 
- *
- * */
-static struct cov_array *
-coverage_increase_counter_uncached(char *sourcefile, unsigned int sourceline,
-                                   char mark_only)
-{
+static struct cov_array * coverage_increase_counter_uncached(char *sourcefile, unsigned int sourceline, char mark_only) {
   struct cov_array *carray = NULL;
  
   if(sourcefile == NULL) {
-          /* "can't happen", just ignore and avoid segfault */
-          return NULL;
-  } else if(!st_lookup(coverinfo, (st_data_t)sourcefile, (st_data_t*)&carray)) {
-          VALUE arr;
-
-          arr = rb_hash_aref(oSCRIPT_LINES__, rb_str_new2(sourcefile));
-          if(NIL_P(arr)) 
-                  return 0;
-          rb_check_type(arr, T_ARRAY);
-          carray = calloc(1, sizeof(struct cov_array));
-          carray->ptr = calloc(RARRAY_LEN(arr), sizeof(unsigned int));
-          carray->len = RARRAY_LEN(arr);
-          st_insert(coverinfo, (st_data_t)strdup(sourcefile), 
-                          (st_data_t) carray);
-  } else {
-          /* recovered carray, sanity check */
-          assert(carray && "failed to create valid carray");
+    /* "can't happen", just ignore and avoid segfault */
+    return NULL;
+  } 
+  else if(!st_lookup(coverinfo, (st_data_t)sourcefile, (st_data_t*)&carray)) {
+    VALUE arr;
+
+    arr = rb_hash_aref(oSCRIPT_LINES__, rb_str_new2(sourcefile));
+    if(NIL_P(arr)) 
+      return 0;
+    rb_check_type(arr, T_ARRAY);
+    carray = calloc(1, sizeof(struct cov_array));
+    carray->ptr = calloc(RARRAY_LEN(arr), sizeof(unsigned int));
+    carray->len = RARRAY_LEN(arr);
+    st_insert(coverinfo, (st_data_t)strdup(sourcefile), (st_data_t) carray);
+  } 
+  else {
+    /* recovered carray, sanity check */
+    assert(carray && "failed to create valid carray");
   }
 
   if(mark_only) {
-          if(!carray->ptr[sourceline])
-                  carray->ptr[sourceline] = 1;
-  } else {
-       if (carray && carray->len > sourceline) {
-          carray->ptr[sourceline]++;
-       }
+    if(!carray->ptr[sourceline])
+      carray->ptr[sourceline] = 1;
+  } 
+  else {
+    if (carray && carray->len > sourceline) {
+      carray->ptr[sourceline]++;
+    }
   }
 
   return carray;
 }
 
-
-static void
-coverage_mark_caller()
-{
-  // if @coverage_hook_activated
-  //   COVER[file] ||= Array.new(SCRIPT_LINES__[file].size, 0)
-  //   COVER[file][line - 1] ||= 0
-  //   COVER[file][line - 1] += 1
-  // end
-  
+static void coverage_mark_caller() {
   coverage_increase_counter_uncached(rb_sourcefile(), rb_sourceline(), 1);
 }
 
-
-static void
-coverage_increase_counter_cached(char *sourcefile, int sourceline)
-{
- if(cached_file == sourcefile && cached_array && cached_array->len > sourceline) {
-         cached_array->ptr[sourceline]++;
-         return;
- }
- cached_file = sourcefile;
- cached_array = coverage_increase_counter_uncached(sourcefile, sourceline, 0);
+static void coverage_increase_counter_cached(char *sourcefile, int sourceline) {
+  if(cached_file == sourcefile && cached_array && cached_array->len > sourceline) {
+    cached_array->ptr[sourceline]++;
+    return;
+  }
+  cached_file = sourcefile;
+  cached_array = coverage_increase_counter_uncached(sourcefile, sourceline, 0);
 }
 
-static void
-coverage_event_coverage_hook(rb_event_flag_t event, VALUE node, 
-                VALUE self, ID mid, VALUE klass)
-{
- char *sourcefile;
- unsigned int sourceline;
- static unsigned int in_hook = 0;
- 
- if(in_hook) {
-         return;
- }
-
- in_hook++;
-
-#if COVERAGE_DEBUG_EVENTS
- do {
-         int status;
-         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
-
- if(event & RUBY_EVENT_C_CALL) {
-         coverage_mark_caller();
- }
- if(event & (RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN | RUBY_EVENT_CLASS)) {
-         in_hook--;
-         return;
- }
-
- // printf("NODE? %s , %s\n", rb_id2name(rb_frame_this_func()), RSTRING_PTR(rb_inspect(node)));
- 
- sourcefile = rb_sourcefile();
- sourceline = rb_sourceline();
+static void coverage_event_coverage_hook(rb_event_flag_t event, VALUE node, VALUE self, ID mid, VALUE klass) {
+  char *sourcefile;
+  unsigned int sourceline;
+  static unsigned int in_hook = 0;
  
- if (0 == sourceline || 0 == sourcefile) {
-         in_hook--;
-         return;
- }
+  if(in_hook) {
+    return;
+  }
 
- coverage_increase_counter_cached(sourcefile, sourceline);
- if(event & RUBY_EVENT_CALL)
-         coverage_mark_caller();
- in_hook--;
+  in_hook++;
+
+  #if COVERAGE_DEBUG_EVENTS
+  do {
+    int status;
+    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
+
+  if(event & RUBY_EVENT_C_CALL) {
+    coverage_mark_caller();
+  }
+  if(event & (RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN | RUBY_EVENT_CLASS)) {
+    in_hook--;
+    return;
+  }
+  
+  sourcefile = rb_sourcefile();
+  sourceline = rb_sourceline();
+  
+  if (0 == sourceline || 0 == sourcefile) {
+    in_hook--;
+    return;
+  }
+  
+  coverage_increase_counter_cached(sourcefile, sourceline);
+  if(event & RUBY_EVENT_CALL)
+    coverage_mark_caller();
+  in_hook--;
 }
 
-
-static VALUE
-cov_install_coverage_hook(VALUE self)
-{
+static VALUE cov_install_coverage_hook(VALUE self) {
   if(!coverage_hook_set_p) {
-       if(!coverinfo)
-               coverinfo = st_init_strtable();
-          coverage_hook_set_p = 1;
-          /* TODO: allow C_CALL too, since it's supported already
-           * the overhead is around ~30%, tested on typo */
-           VALUE holder = 0;
-           rb_add_event_hook(coverage_event_coverage_hook, 
-                        RUBY_EVENT_ALL & ~RUBY_EVENT_C_CALL &
-                        ~RUBY_EVENT_C_RETURN & ~RUBY_EVENT_CLASS, holder);
-          return Qtrue;
+    if(!coverinfo)
+      coverinfo = st_init_strtable();
+    coverage_hook_set_p = 1;
+    /* TODO: allow C_CALL too, since it's supported already
+     * the overhead is around ~30%, tested on typo */
+    VALUE holder = 0;
+    rb_add_event_hook(coverage_event_coverage_hook, 
+                      RUBY_EVENT_ALL & ~RUBY_EVENT_C_CALL &
+                      ~RUBY_EVENT_C_RETURN & ~RUBY_EVENT_CLASS, holder);
+    return Qtrue;
   }
   else
-          return Qfalse;
+    return Qfalse;
 }
 
-
-static int
-populate_cover(st_data_t key, st_data_t value, st_data_t cover)
-{
- VALUE rcover;
- VALUE rkey;
- VALUE rval;
- struct cov_array *carray;
- unsigned int i;
- 
- rcover = (VALUE)cover;
- carray = (struct cov_array *) value;
- rkey = rb_str_new2((char*) key);
- rval = rb_ary_new2(carray->len);
- for(i = 0; i < carray->len; i++)
-         rb_ary_push(rval, UINT2NUM(carray->ptr[i]));
-
- rb_hash_aset(rcover, rkey, rval);
- 
- return ST_CONTINUE;
+static int populate_cover(st_data_t key, st_data_t value, st_data_t cover) {
+  VALUE rcover;
+  VALUE rkey;
+  VALUE rval;
+  struct cov_array *carray;
+  unsigned int i;
+  
+  rcover = (VALUE)cover;
+  carray = (struct cov_array *) value;
+  rkey = rb_str_new2((char*) key);
+  rval = rb_ary_new2(carray->len);
+  for(i = 0; i < carray->len; i++)
+    rb_ary_push(rval, UINT2NUM(carray->ptr[i]));
+  
+  rb_hash_aset(rcover, rkey, rval);
+  
+  return ST_CONTINUE;
 }
 
-
-static int
-free_table(st_data_t key, st_data_t value, st_data_t ignored)
-{
- struct cov_array *carray;
- 
- carray = (struct cov_array *) value;
- free((char *)key);
- free(carray->ptr);
- free(carray);
-
- return ST_CONTINUE;
+static int free_table(st_data_t key, st_data_t value, st_data_t ignored) {
+  struct cov_array *carray;
+  
+  carray = (struct cov_array *) value;
+  free((char *)key);
+  free(carray->ptr);
+  free(carray);
+  
+  return ST_CONTINUE;
 }
 
-
-static VALUE
-cov_remove_coverage_hook(VALUE self)
-{
- if(!coverage_hook_set_p) 
-         return Qfalse;
- else {
-         rb_remove_event_hook(coverage_event_coverage_hook);
-         coverage_hook_set_p = 0;
-         return Qtrue;
- }
+static VALUE cov_remove_coverage_hook(VALUE self) {
+  if(!coverage_hook_set_p) 
+    return Qfalse;
+  else {
+    rb_remove_event_hook(coverage_event_coverage_hook);
+    coverage_hook_set_p = 0;
+    return Qtrue;
+  }
 }
 
-
-static VALUE
-cov_generate_coverage_info(VALUE self)
-{
+static VALUE cov_generate_coverage_info(VALUE self) {
   VALUE cover;
 
   if(rb_const_defined_at(mRCOV__, id_cover)) {
-       rb_mod_remove_const(mRCOV__, ID2SYM(id_cover));
+    rb_mod_remove_const(mRCOV__, ID2SYM(id_cover));
   }
 
   cover = rb_hash_new();
   if(coverinfo)
-       st_foreach(coverinfo, populate_cover, cover);
+    st_foreach(coverinfo, populate_cover, cover);
   rb_define_const(mRCOV__, "COVER", cover);
 
   return cover;
 }
 
-
-static VALUE
-cov_reset_coverage(VALUE self)
-{
+static VALUE cov_reset_coverage(VALUE self) {
   if(coverage_hook_set_p) {
-       rb_raise(rb_eRuntimeError, 
-               "Cannot reset the coverage info in the middle of a traced run.");
-       return Qnil;
+    rb_raise(rb_eRuntimeError, "Cannot reset the coverage info in the middle of a traced run.");
+    return Qnil;
   }
 
   cached_array = 0;
@@ -258,10 +217,7 @@ cov_reset_coverage(VALUE self)
   return Qnil;
 }
 
-
-static VALUE
-cov_ABI(VALUE self)
-{
+static VALUE cov_ABI(VALUE self) {
   VALUE ret;
 
   ret = rb_ary_new();
@@ -272,44 +228,37 @@ cov_ABI(VALUE self)
   return ret;
 }
 
-
-void
-Init_rcovrt()
-{
- ID id_rcov = rb_intern("Rcov");
- ID id_coverage__ = rb_intern("RCOV__");
- ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
- 
- id_cover = rb_intern("COVER");
- 
- if(rb_const_defined(rb_cObject, id_rcov)) 
-         mRcov = rb_const_get(rb_cObject, id_rcov);
- else
-         mRcov = rb_define_module("Rcov");
- 
- if(rb_const_defined(mRcov, id_coverage__))
-         mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
- else
-         mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
- 
- if(rb_const_defined(rb_cObject, id_script_lines__))
-         oSCRIPT_LINES__ = rb_const_get(rb_cObject, rb_intern("SCRIPT_LINES__"));
- else {
-         oSCRIPT_LINES__ = rb_hash_new();
-         rb_const_set(rb_cObject, id_script_lines__, oSCRIPT_LINES__);
- }
- 
- coverage_hook_set_p = 0;
- 
- rb_define_singleton_method(mRCOV__, "install_coverage_hook", 
-                 cov_install_coverage_hook, 0);
- rb_define_singleton_method(mRCOV__, "remove_coverage_hook", 
-                 cov_remove_coverage_hook, 0);
- rb_define_singleton_method(mRCOV__, "generate_coverage_info", 
-              cov_generate_coverage_info, 0);
- rb_define_singleton_method(mRCOV__, "reset_coverage", cov_reset_coverage, 0);
- rb_define_singleton_method(mRCOV__, "ABI", cov_ABI, 0);
- 
- Init_rcov_callsite();
+void Init_rcovrt() {
+  ID id_rcov = rb_intern("Rcov");
+  ID id_coverage__ = rb_intern("RCOV__");
+  ID id_script_lines__ = rb_intern("SCRIPT_LINES__");
+  
+  id_cover = rb_intern("COVER");
+  
+  if(rb_const_defined(rb_cObject, id_rcov)) 
+    mRcov = rb_const_get(rb_cObject, id_rcov);
+  else
+    mRcov = rb_define_module("Rcov");
+  
+  if(rb_const_defined(mRcov, id_coverage__))
+    mRCOV__ = rb_const_get_at(mRcov, id_coverage__);
+  else
+    mRCOV__ = rb_define_module_under(mRcov, "RCOV__");
+  
+  if(rb_const_defined(rb_cObject, id_script_lines__))
+    oSCRIPT_LINES__ = rb_const_get(rb_cObject, rb_intern("SCRIPT_LINES__"));
+  else {
+    oSCRIPT_LINES__ = rb_hash_new();
+    rb_const_set(rb_cObject, id_script_lines__, oSCRIPT_LINES__);
+  }
+  
+  coverage_hook_set_p = 0;
+  
+  rb_define_singleton_method(mRCOV__, "install_coverage_hook", cov_install_coverage_hook, 0);
+  rb_define_singleton_method(mRCOV__, "remove_coverage_hook", cov_remove_coverage_hook, 0);
+  rb_define_singleton_method(mRCOV__, "generate_coverage_info", cov_generate_coverage_info, 0);
+  rb_define_singleton_method(mRCOV__, "reset_coverage", cov_reset_coverage, 0);
+  rb_define_singleton_method(mRCOV__, "ABI", cov_ABI, 0);
+  
+  Init_rcov_callsite();
 }
-/* vim: set sw=8 expandtab: */