ruby-internal 0.7.2 → 0.7.3

data/bin/ruby-internal-node-dump

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby
+#! /home/cout/.rvm/rubies/ruby-1.9.2-p318/bin/ruby
 
 require 'pp'
 require 'internal/node/pp'

data/bin/ruby-internal-obfuscate

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby
+#! /home/cout/.rvm/rubies/ruby-1.9.2-p318/bin/ruby
 
 require 'internal/node/obfusc'
 

data/ext/internal/method/extconf.rb

@@ -1,8 +1,12 @@
 $: << '../..'
 require 'mkmf-ruby-internal'
 
+ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
+$CPPFLAGS << " -DRUBY_VERSION_CODE=#{ruby_version_code}"
+
 have_var('rb_cMethod', 'ruby.h')
 have_var('rb_cUnboundMethod', 'ruby.h')
 have_header('ruby/node.h') or have_header('node.h')
+have_type('struct RTypedData')
 
 create_ruby_internal_makefile 'internal/method/method'

data/ext/internal/method/internal_method.h

@@ -0,0 +1,65 @@
+#ifndef ruby_internal_method__h_
+#define ruby_internal_method__h_
+
+#include <ruby.h>
+
+#ifdef RUBY_VM
+#include "method.h"
+#endif
+
+#include "internal/node/ruby_internal_node.h"
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+
+struct METHOD {
+    VALUE recv;
+    VALUE rclass;
+    ID id;
+    rb_method_entry_t me;
+};
+
+static void
+bm_mark(void *ptr)
+{
+    struct METHOD *data = ptr;
+    rb_gc_mark(data->rclass);
+    rb_gc_mark(data->recv);
+    rb_mark_method_entry(&data->me);
+}
+
+static void
+bm_free(void *ptr)
+{
+    struct METHOD *data = ptr;
+    rb_method_definition_t *def = data->me.def;
+    if (def->alias_count == 0)
+	xfree(def);
+    else if (def->alias_count > 0)
+	def->alias_count--;
+    xfree(ptr);
+}
+
+static size_t
+bm_memsize(const void *ptr)
+{
+    return ptr ? sizeof(struct METHOD) : 0;
+}
+
+static const rb_data_type_t method_data_type = {
+    "method",
+    bm_mark,
+    bm_free,
+    bm_memsize,
+};
+
+#define METHOD_OCLASS(m) m->klass
+#define METHOD_RCLASS(m) m->rclass
+
+#endif
+

data/ext/internal/method/{method.h.rpp → internal_method.h.rpp}

@@ -3,8 +3,20 @@
 
 #include <ruby.h>
 
+#ifdef RUBY_VM
+#include "method.h"
+#endif
+
 #include "internal/node/ruby_internal_node.h"
 
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+
 #ruby <<END
   $: << '../..'
   require 'ruby_source_dir'
@@ -20,11 +32,19 @@
     File.open(file) do |eval_c|
       write = false
       stopwrite = false
+      prev_line = nil
       while (line = eval_c.gets) != nil do
         case line
         when /^struct (METHOD)/
           write = true
           stopwrite = false
+        when /rb_data_type_t method_data_type = {/
+          write = true
+          stopwrite = false
+        when /^(bm_mark|bm_free|bm_memsize)/
+          puts prev_line
+          write = true
+          stopwrite = false
         when /^\}/
           stopwrite = true
         when /VALUE oclass/
@@ -42,6 +62,7 @@
           write = false
           puts ''
         end
+        prev_line = line
       end
     end
   end

data/ext/internal/method/method.c

@@ -1,6 +1,6 @@
 #include <ruby.h>
 #include "internal/node/ruby_internal_node.h"
-#include "method.h"
+#include "internal_method.h"
 
 #ifdef RUBY_VM
 #include "vm_core.h"
@@ -22,6 +22,14 @@ static VALUE rb_cUnboundMethod = Qnil;
 #define RARRAY_PTR(a) RARRAY(a)->ptr
 #endif
 
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+#  define UNWRAP_METHOD(method, m) \
+   TypedData_Get_Struct(method, struct METHOD, &method_data_type, m);
+#else
+#  define UNWRAP_METHOD(method, m) \
+   Data_Get_Struct(method, struct METHOD, m)
+#endif
+
 static VALUE rb_mMarshal;
 
 static VALUE marshal_dump(VALUE obj, VALUE limit)
@@ -58,7 +66,7 @@ static VALUE lookup_module_proc = Qnil;
 static VALUE method_receiver(VALUE method)
 {
   struct METHOD * m;
-  Data_Get_Struct(method, struct METHOD, m);
+  UNWRAP_METHOD(method, m);
   return m->recv;
 }
 
@@ -74,7 +82,7 @@ static VALUE method_receiver(VALUE method)
 static VALUE method_id(VALUE method)
 {
   struct METHOD * m;
-  Data_Get_Struct(method, struct METHOD, m);
+  UNWRAP_METHOD(method, m);
   return ID2SYM(m->id);
 }
 
@@ -90,8 +98,14 @@ static VALUE method_id(VALUE method)
 static VALUE method_oid(VALUE method)
 {
   struct METHOD * m;
-  Data_Get_Struct(method, struct METHOD, m);
+  UNWRAP_METHOD(method, m);
+#if RUBY_VERSION_CODE >= 193
+  return ID2SYM(m->me->def->original_id);
+#elif RUBY_VERSION_CODE >= 192
+  return ID2SYM(m->me.def->original_id);
+#else
   return ID2SYM(m->oid);
+#endif
 }
 
 /*
@@ -106,8 +120,14 @@ static VALUE method_oid(VALUE method)
 static VALUE method_origin_class(VALUE method)
 {
   struct METHOD * m;
-  Data_Get_Struct(method, struct METHOD, m);
+  UNWRAP_METHOD(method, m);
+#if RUBY_VERSION_CODE >= 193
+  return m->me->klass;
+#elif RUBY_VERSION_CODE >= 192
+  return m->me.klass;
+#else
   return METHOD_OCLASS(m);
+#endif
 }
 
 /*
@@ -119,7 +139,7 @@ static VALUE method_origin_class(VALUE method)
 static VALUE method_attached_class(VALUE method)
 {
   struct METHOD * m;
-  Data_Get_Struct(method, struct METHOD, m);
+  UNWRAP_METHOD(method, m);
   return CLASS_OF(m->recv);
 }
 
@@ -139,8 +159,14 @@ static VALUE method_body(VALUE method)
     /* no access to potentially sensitive data from the sandbox */
     rb_raise(rb_eSecurityError, "Insecure: can't get method body");
   }
-  Data_Get_Struct(method, struct METHOD, m);
+  UNWRAP_METHOD(method, m);
+#if RUBY_VERSION_CODE >= 193
+  return m->me->def->body.iseq->self; /* TODO: body is a union; is this right? */
+#elif RUBY_VERSION_CODE >= 192
+  return m->me.def->body.iseq->self; /* TODO: body is a union; is this right? */
+#else
   return wrap_node(m->body);
+#endif
 }
 
 /*
@@ -165,9 +191,17 @@ static VALUE method_dump(VALUE self, VALUE limit)
   }
 
   arr = rb_ary_new();
-  Data_Get_Struct(self, struct METHOD, method);
+  UNWRAP_METHOD(self, method);
+#if RUBY_VERSION_CODE >= 193
+  rb_ary_push(arr, rb_mod_name(method->me->klass));
+  rb_ary_push(arr, Qnil); /* TODO */
+#elif RUBY_VERSION_CODE >= 192
+  rb_ary_push(arr, rb_mod_name(method->me.klass));
+  rb_ary_push(arr, Qnil); /* TODO */
+#else
   rb_ary_push(arr, rb_mod_name(METHOD_OCLASS(method)));
   rb_ary_push(arr, rb_mod_name(METHOD_RCLASS(method)));
+#endif
   if(rb_class_of(self) == rb_cUnboundMethod)
   {
     rb_ary_push(arr, Qnil);
@@ -177,7 +211,13 @@ static VALUE method_dump(VALUE self, VALUE limit)
     rb_ary_push(arr, method->recv);
   }
   rb_ary_push(arr, ID2SYM(method->id));
+#if RUBY_VERSION_CODE >= 193
+  rb_ary_push(arr, ID2SYM(method->me->def->original_id));
+#elif RUBY_VERSION_CODE >= 192
+  rb_ary_push(arr, ID2SYM(method->me.def->original_id));
+#else
   rb_ary_push(arr, ID2SYM(method->oid));
+#endif
   rb_ary_push(arr, method_body(self));
 
   return marshal_dump(arr, limit);
@@ -194,7 +234,6 @@ static VALUE method_load(VALUE klass, VALUE str)
   struct METHOD * method;
   VALUE rarr = marshal_load(str);
   VALUE * arr;
-  NODE * n;
   VALUE retval;
 
   if(   rb_safe_level() >= 4
@@ -213,17 +252,32 @@ static VALUE method_load(VALUE klass, VALUE str)
   /* Create a METHOD object -- doesn't matter which method we use */
   retval = rb_funcall(
       rb_cObject, rb_intern("method"), 1, ID2SYM(rb_intern("__id__")));
-  Data_Get_Struct(retval, struct METHOD, method);
+  UNWRAP_METHOD(retval, method);
   arr = RARRAY_PTR(rarr);
+#if RUBY_VERSION_CODE >= 193
+  method->me->klass =
+    rb_funcall(lookup_module_proc, rb_intern("call"), 1, arr[0]);
+  method->me->def->original_id = SYM2ID(arr[4]);
+  GetISeqPtr(arr[5], method->me->def->body.iseq);
+#elif RUBY_VERSION_CODE >= 192
+  method->me.klass =
+    rb_funcall(lookup_module_proc, rb_intern("call"), 1, arr[0]);
+  method->me.def->original_id = SYM2ID(arr[4]);
+  GetISeqPtr(arr[5], method->me.def->body.iseq);
+#else
   METHOD_OCLASS(method) =
     rb_funcall(lookup_module_proc, rb_intern("call"), 1, arr[0]);
   METHOD_RCLASS(method) =
     rb_funcall(lookup_module_proc, rb_intern("call"), 1, arr[1]);
+  method->oid = SYM2ID(arr[4]);
+  {
+    NODE * n;
+    Data_Get_Struct(arr[5], NODE, n);
+    method->body = n;
+  }
+#endif
   method->recv = arr[2];
   method->id = SYM2ID(arr[3]);
-  method->oid = SYM2ID(arr[4]);
-  Data_Get_Struct(arr[5], NODE, n);
-  method->body = n;
 
   if(klass == rb_cUnboundMethod)
   {
@@ -243,6 +297,8 @@ void Init_method(void)
 #ifndef HAVE_RB_CMETHOD
   rb_cMethod = rb_const_get(rb_cObject, rb_intern("Method"));
 #endif
+
+  /* TODO: ruby 1.9 has this function but not 1.8 */
   rb_define_method(rb_cMethod, "receiver", method_receiver, 0);
 
   /* For rdoc: rb_cUnboundMethod = rb_define_class("UnboundMethod", rb_cObject) */

data/ext/internal/module/classpath.c

@@ -4,37 +4,35 @@ VALUE
 class2path(VALUE klass)
 {
     VALUE path = rb_class_path(klass);
-    char *n = RSTRING_PTR(path);
+    const char *n;
 
-    if (n[0] == '#') {
-	rb_raise(rb_eTypeError, "can't dump anonymous %s %s",
-		 (TYPE(klass) == T_CLASS ? "class" : "module"),
-		 n);
-    }
-    if (rb_path2class(n) != rb_class_real(klass)) {
-	rb_raise(rb_eTypeError, "%s can't be referred", n);
+    n = must_not_be_anonymous((TYPE(klass) == T_CLASS ? "class" : "module"), path);
+    if (rb_path_to_class(path) != rb_class_real(klass)) {
+	rb_raise(rb_eTypeError, "%s can't be referred to", n);
     }
     return path;
 }
 
 VALUE
-path2class(const char *path)
+path2class(VALUE path)
 {
-    VALUE v = rb_path2class(path);
+    VALUE v = rb_path_to_class(path);
 
     if (TYPE(v) != T_CLASS) {
-	rb_raise(rb_eArgError, "%s does not refer class", path);
+	rb_raise(rb_eArgError, "%.*s does not refer to class",
+		 (int)RSTRING_LEN(path), RSTRING_PTR(path));
     }
     return v;
 }
 
 VALUE
-path2module(const char *path)
+path2module(VALUE path)
 {
-    VALUE v = rb_path2class(path);
+    VALUE v = rb_path_to_class(path);
 
     if (TYPE(v) != T_MODULE) {
-	rb_raise(rb_eArgError, "%s does not refer module", path);
+	rb_raise(rb_eArgError, "%.*s does not refer to module",
+		 (int)RSTRING_LEN(path), RSTRING_PTR(path));
     }
     return v;
 }

data/ext/internal/module/extconf.rb

@@ -1,9 +1,10 @@
 $: << '../..'
 require 'mkmf-ruby-internal'
 
-have_func('vm_get_ruby_level_cfp', 'cfp.h')
-have_func('rb_vm_get_ruby_level_next_cfp', 'cfp.h')
+have_func('vm_get_ruby_level_cfp', [ 'cfp.h', 'vm_core.h' ])
+have_func('rb_vm_get_ruby_level_next_cfp', [ 'cfp.h', 'vm_core.h' ])
 have_header('ruby/node.h') or have_header('node.h')
+have_struct_member('struct RClass', 'iv_index_tbl')
 
 ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
 $CPPFLAGS << " -DRUBY_VERSION_CODE=#{ruby_version_code}"

data/ext/internal/module/module.c

@@ -16,7 +16,11 @@
 #endif
 
 #ifndef RCLASS_IV_TBL
-#define RCLASS_IV_TBL(c) RCLASS(c)->iv_tbl
+#  ifdef HAVE_STRUCT_RCLASS_IV_INDEX_TBL
+#    define RCLASS_IV_TBL(c) RCLASS(c)->iv_index_tbl
+#  else
+#    define RCLASS_IV_TBL(c) RCLASS(c)->iv_tbl
+#  endif
 #endif
 
 #ifndef RCLASS_M_TBL
@@ -214,7 +218,7 @@ static VALUE included_modules_list(VALUE module)
 {
   VALUE included_modules = rb_mod_included_modules(module);
   VALUE included_module_list = rb_ary_new();
-  size_t j;
+  long j;
 
   for(j = 0; j < RARRAY_LEN(included_modules); ++j)
   {
@@ -391,7 +395,9 @@ static VALUE module_add_method(VALUE klass, VALUE id, VALUE node, VALUE noex)
     rb_raise(rb_eSecurityError, "Insecure: can't add method");
   }
 
-#ifdef RUBY_VM
+#if RUBY_VERSION_CODE >= 192
+  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+#elif RUBY_VERSION_CODE >= 190
   if(rb_obj_is_kind_of(node, rb_cISeq))
   {
     rb_iseq_t *iseqdat = iseq_check(node);
@@ -415,7 +421,9 @@ static VALUE module_add_method(VALUE klass, VALUE id, VALUE node, VALUE noex)
 
   Data_Get_Struct(node, NODE, n);
 
-#ifdef RUBY_VM
+#if RUBY_VERSION_CODE >= 192
+  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+#elif RUBY_VERSION_CODE >= 190
   if(nd_type(n) != NODE_METHOD)
   {
     rb_raise(
@@ -424,19 +432,26 @@ static VALUE module_add_method(VALUE klass, VALUE id, VALUE node, VALUE noex)
         rb_class2name(CLASS_OF(n)));
   }
 
-  rb_iseq_t *iseqdat = iseq_check((VALUE)n->nd_body);
-  set_cref_stack(iseqdat, klass, noex);
-  iseqdat->klass = klass;
-  iseqdat->defined_method_id = SYM2ID(id);
-  n = NEW_METHOD(iseqdat->self, klass, NUM2INT(noex));
+  {
+    rb_iseq_t *iseqdat = iseq_check((VALUE)n->nd_body);
+    set_cref_stack(iseqdat, klass, noex);
+    iseqdat->klass = klass;
+    iseqdat->defined_method_id = SYM2ID(id);
+    n = NEW_METHOD(iseqdat->self, klass, NUM2INT(noex));
+  }
 
 add_node:
 #endif
+
+#if RUBY_VERSION_CODE >= 192
+  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+#else
   /* TODO: if noex is NOEX_MODFUNC, add this method as a module function
    * (that is, both as an instance and singleton method)
    */
   rb_add_method(klass, SYM2ID(id), n, NUM2INT(noex));
   return Qnil;
+#endif
 }
 
 /* 
@@ -609,9 +624,9 @@ static VALUE module_dump(VALUE self, VALUE limit)
   return str;
 }
 
-static void include_modules(module, included_modules)
+static void include_modules(VALUE module, VALUE included_modules)
 {
-  size_t j;
+  long j;
   VALUE v;
   VALUE name;
 
@@ -636,7 +651,11 @@ static int add_method_iter(VALUE name, VALUE value, VALUE module)
         rb_class2name(CLASS_OF(value)));
   }
   Data_Get_Struct(value, NODE, n);
+#if RUBY_VERSION_CODE >= 192
+  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+#elif RUBY_VERSION_CODE >= 190
   rb_add_method(module, SYM2ID(name), n->nd_body, n->nd_noex);
+#endif
   return ST_CONTINUE;
 }
 
@@ -775,10 +794,12 @@ void Init_module(void)
   rb_global_variable(&module_name_proc);
 
 #if RUBY_VERSION_CODE >= 180
-  VALUE rb_mNodewrap = rb_define_module("Nodewrap");
-  rb_cClass_Restorer = rb_define_class_under(rb_mNodewrap, "ClassRestorer", rb_cObject);
-  rb_define_method(rb_cClass_Restorer, "_dump", class_restorer_dump, 1);
-  rb_define_singleton_method(rb_cClass_Restorer, "_load", class_restorer_load, 1);
+  {
+    VALUE rb_mNodewrap = rb_define_module("Nodewrap");
+    rb_cClass_Restorer = rb_define_class_under(rb_mNodewrap, "ClassRestorer", rb_cObject);
+    rb_define_method(rb_cClass_Restorer, "_dump", class_restorer_dump, 1);
+    rb_define_singleton_method(rb_cClass_Restorer, "_load", class_restorer_load, 1);
+  }
 #endif
 
 #if RUBY_VERSION_CODE == 180