ruby-internal 0.7.3 → 0.8.0

data/ext/internal/binding/block.h

@@ -7,6 +7,26 @@
 #include "env.h"
 #endif
 
+struct BLOCK {
+    NODE *var;
+    NODE *body;
+    VALUE self;
+    struct FRAME frame;
+    struct SCOPE *scope;
+    VALUE klass;
+    NODE *cref;
+    int iter;
+    int vmode;
+    int flags;
+    int uniq;
+    struct RVarmap *dyna_vars;
+    VALUE orig_thread;
+    VALUE wrapper;
+    VALUE block_obj;
+    struct BLOCK *outer;
+    struct BLOCK *prev;
+};
+
 
 #endif
 

data/ext/internal/method/internal_method.h

@@ -18,48 +18,15 @@
 #endif
 
 struct METHOD {
+    VALUE klass, rklass;
     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,
+    ID id, oid;
+    int safe_level;
+    NODE *body;
 };
 
 #define METHOD_OCLASS(m) m->klass
-#define METHOD_RCLASS(m) m->rclass
+#define METHOD_RCLASS(m) m->rklass
 
 #endif
 

data/ext/internal/method/internal_method.h.rpp

@@ -38,13 +38,6 @@
         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/

data/ext/internal/method/method.c

@@ -23,11 +23,33 @@ static VALUE rb_cUnboundMethod = Qnil;
 #endif
 
 #ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+
 #  define UNWRAP_METHOD(method, m) \
-   TypedData_Get_Struct(method, struct METHOD, &method_data_type, m);
+   TypedData_Get_Struct(method, struct METHOD, p_method_data_type, m);
+
+  static rb_data_type_t const * p_method_data_type;
+
+  static void init_method_data_type()
+  {
+    /* Create a METHOD object -- doesn't matter which method we use */
+    VALUE retval = rb_funcall(
+        rb_cObject, rb_intern("method"), 1, ID2SYM(rb_intern("__id__")));
+    p_method_data_type = RTYPEDDATA_TYPE(retval);
+  }
+
 #else
+
 #  define UNWRAP_METHOD(method, m) \
    Data_Get_Struct(method, struct METHOD, m)
+
+#endif
+
+#if RUBY_VERSION_CODE >= 193
+#  define METHOD_DEF(method) method->me->def
+#  define METHOD_KLASS(method) method->me->klass
+#elif RUBY_VERSION_CODE >= 192
+#  define METHOD_DEF(method) method->me.def
+#  define METHOD_KLASS(method) method->me.klass
 #endif
 
 static VALUE rb_mMarshal;
@@ -99,10 +121,8 @@ static VALUE method_oid(VALUE 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);
+#if RUBY_VERSION_CODE >= 192
+  return ID2SYM(METHOD_DEF(m)->original_id);
 #else
   return ID2SYM(m->oid);
 #endif
@@ -160,10 +180,8 @@ static VALUE method_body(VALUE method)
     rb_raise(rb_eSecurityError, "Insecure: can't get method body");
   }
   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? */
+#if RUBY_VERSION_CODE >= 192
+  return METHOD_DEF(m)->body.iseq->self; /* TODO: body is a union; is this right? */
 #else
   return wrap_node(m->body);
 #endif
@@ -193,32 +211,30 @@ static VALUE method_dump(VALUE self, VALUE limit)
   arr = rb_ary_new();
   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 */
+  rb_ary_push(arr, rb_mod_name(method->me->klass));           /* [0] */
+  rb_ary_push(arr, Qnil); /* TODO */                          /* [1] */
 #elif RUBY_VERSION_CODE >= 192
-  rb_ary_push(arr, rb_mod_name(method->me.klass));
-  rb_ary_push(arr, Qnil); /* TODO */
+  rb_ary_push(arr, rb_mod_name(method->me.klass));            /* [0] */
+  rb_ary_push(arr, Qnil); /* TODO */                          /* [1] */
 #else
-  rb_ary_push(arr, rb_mod_name(METHOD_OCLASS(method)));
-  rb_ary_push(arr, rb_mod_name(METHOD_RCLASS(method)));
+  rb_ary_push(arr, rb_mod_name(METHOD_OCLASS(method)));       /* [2] */
+  rb_ary_push(arr, rb_mod_name(METHOD_RCLASS(method)));       /* [3] */
 #endif
   if(rb_class_of(self) == rb_cUnboundMethod)
   {
-    rb_ary_push(arr, Qnil);
+    rb_ary_push(arr, Qnil);                                   /* [4] */
   }
   else
   {
-    rb_ary_push(arr, method->recv);
+    rb_ary_push(arr, method->recv);                           /* [4] */
   }
   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));
+#if RUBY_VERSION_CODE >= 192
+  rb_ary_push(arr, ID2SYM(METHOD_DEF(method)->original_id));  /* [5] */
 #else
-  rb_ary_push(arr, ID2SYM(method->oid));
+  rb_ary_push(arr, ID2SYM(method->oid));                      /* [5] */
 #endif
-  rb_ary_push(arr, method_body(self));
+  rb_ary_push(arr, method_body(self));                        /* [6] */
 
   return marshal_dump(arr, limit);
 }
@@ -232,6 +248,7 @@ static VALUE method_dump(VALUE self, VALUE limit)
 static VALUE method_load(VALUE klass, VALUE str)
 {
   struct METHOD * method;
+
   VALUE rarr = marshal_load(str);
   VALUE * arr;
   VALUE retval;
@@ -253,17 +270,16 @@ static VALUE method_load(VALUE klass, VALUE str)
   retval = rb_funcall(
       rb_cObject, rb_intern("method"), 1, ID2SYM(rb_intern("__id__")));
   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 =
+#if RUBY_VERSION_CODE >= 192
+  METHOD_KLASS(method) =
     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);
+  METHOD_DEF(method) = xmalloc(sizeof(*METHOD_DEF(method)));
+  METHOD_DEF(method)->type = VM_METHOD_TYPE_ISEQ;
+  METHOD_DEF(method)->original_id = SYM2ID(arr[4]);
+  METHOD_DEF(method)->alias_count = 0;
+  GetISeqPtr(arr[5], METHOD_DEF(method)->body.iseq);
 #else
   METHOD_OCLASS(method) =
     rb_funcall(lookup_module_proc, rb_intern("call"), 1, arr[0]);
@@ -321,5 +337,9 @@ void Init_method(void)
 
   lookup_module_proc = rb_eval_string(lookup_module_str);
   rb_global_variable(&lookup_module_proc);
+
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+  init_method_data_type();
+#endif
 }
 

data/ext/internal/module/classpath.c

@@ -1,38 +1,43 @@
 #include "classpath.h"
 
 VALUE
-class2path(VALUE klass)
+class2path(klass)
+    VALUE klass;
 {
     VALUE path = rb_class_path(klass);
-    const char *n;
+    char *n = RSTRING(path)->ptr;
 
-    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);
+    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);
     }
     return path;
 }
 
 VALUE
-path2class(VALUE path)
+path2class(path)
+    const char *path;
 {
-    VALUE v = rb_path_to_class(path);
+    VALUE v = rb_path2class(path);
 
     if (TYPE(v) != T_CLASS) {
-	rb_raise(rb_eArgError, "%.*s does not refer to class",
-		 (int)RSTRING_LEN(path), RSTRING_PTR(path));
+	rb_raise(rb_eArgError, "%s does not refer class", path);
     }
     return v;
 }
 
 VALUE
-path2module(VALUE path)
+path2module(path)
+    const char *path;
 {
-    VALUE v = rb_path_to_class(path);
+    VALUE v = rb_path2class(path);
 
     if (TYPE(v) != T_MODULE) {
-	rb_raise(rb_eArgError, "%.*s does not refer to module",
-		 (int)RSTRING_LEN(path), RSTRING_PTR(path));
+	rb_raise(rb_eArgError, "%s does not refer module", path);
     }
     return v;
 }

data/ext/internal/module/classpath.h

@@ -4,13 +4,13 @@
 #include "ruby.h"
 
 VALUE class2path(
-
+    VALUE klass
 );
 VALUE path2class(
-
+    const char *path
 );
 VALUE path2module(
-
+    const char *path
 );
 
 #endif

data/ext/internal/module/extconf.rb

@@ -1,10 +1,11 @@
 $: << '../..'
 require 'mkmf-ruby-internal'
 
-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_header('internal.h')
 have_struct_member('struct RClass', 'iv_index_tbl')
+have_type('struct RTypedData')
+have_func('rb_add_method')
 
 ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
 $CPPFLAGS << " -DRUBY_VERSION_CODE=#{ruby_version_code}"

data/ext/internal/module/getcfp.h

@@ -0,0 +1,13 @@
+#ifndef getcfp__h
+#define getcfp__h
+
+#include "ruby.h"
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+
+#endif
+
+#endif

data/ext/internal/module/getcfp.h.rpp

@@ -0,0 +1,44 @@
+#ifndef getcfp__h
+#define getcfp__h
+
+#include "ruby.h"
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+#ruby <<END
+$: << '../..'
+require 'ruby_source_dir'
+
+vm_c_location = "#{RUBY_SOURCE_DIR}/vm.c"
+if File.exists?(vm_c_location) then
+  File.open(vm_c_location) do |vm_c|
+    write = false
+    stopwrite = false
+    prev_line = nil
+    while (line = vm_c.gets) != nil do
+      case line
+      when /^(rb_vm_get_ruby_level_next_cfp|vm_get_ruby_level_cfp)/
+        puts "static #{prev_line}"
+        line.gsub!($1, 'getcfp')
+        write = true
+        stopwrite = false
+      when /^\}/
+        stopwrite = true if write
+      end
+      puts line if write
+      if stopwrite then
+        stopwrite = false
+        write = false
+        puts ''
+      end
+      prev_line = line
+    end
+  end
+end
+END
+
+#endif
+
+#endif

data/ext/internal/module/module.c

@@ -5,12 +5,16 @@
 #include <ruby/st.h>
 #include "vm_core.h"
 #include "eval_intern.h"
-#include "cfp.h"
+#include "getcfp.h"
 #else
 #include <rubysig.h>
 #include <st.h>
 #endif
 
+#ifdef HAVE_INTERNAL_H
+#include "internal.h"
+#endif
+
 #ifndef RCLASS_SUPER
 #define RCLASS_SUPER(c) RCLASS(c)->super
 #endif
@@ -35,6 +39,22 @@
 #define RARRAY_PTR(a) RARRAY(a)->ptr
 #endif
 
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+
+#  undef GetThreadPtr
+#  define GetThreadPtr(obj, ptr) \
+   TypedData_Get_Struct((obj), rb_thread_t, p_ruby_threadptr_data_type, (ptr))
+
+  static rb_data_type_t const * p_ruby_threadptr_data_type;
+
+  static void init_ruby_threadptr_data_type()
+  {
+    VALUE thread = rb_thread_current();
+    p_ruby_threadptr_data_type = RTYPEDDATA_TYPE(thread);
+  }
+
+#endif
+
 static VALUE rb_cNode;
 
 static VALUE rb_mMarshal;
@@ -145,7 +165,7 @@ static VALUE class_restorer_dump(VALUE ruby_class_restorer, VALUE limit)
 
 /*
  * call-seq:
- *   Nodewrap::ClassRestorer.load => ClassRestorer
+ *   Internal::ClassRestorer.load => ClassRestorer
  *
  * Do not call this function.
  */
@@ -170,7 +190,7 @@ static VALUE ruby180_marshal_dump(int argc, VALUE * argv, VALUE klass)
     set_class_restore_state(argv[0]);
   }
 
-  VALUE str = rb_funcall2(klass, rb_intern("_Nodewrap__orig_dump"), argc, argv);
+  VALUE str = rb_funcall2(klass, rb_intern("_Internal__orig_dump"), argc, argv);
 
   if(class_restorer != Qnil)
   {
@@ -342,14 +362,12 @@ static VALUE module_name_proc = Qnil;
 
 static void set_cref_stack(rb_iseq_t * iseqdat, VALUE klass, VALUE noex)
 {
-  rb_thread_t * th = GET_THREAD();
-#if defined(HAVE_RB_VM_GET_RUBY_LEVEL_NEXT_CFP)
-  rb_control_frame_t * cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
-#elif defined(HAVE_VM_GET_RUBY_LEVEL_CFP)
-  rb_control_frame_t * cfp = vm_get_ruby_level_cfp(th, th->cfp);
-#else
-#error No function to get cfp
-#endif
+  VALUE thread = rb_thread_current();
+  rb_thread_t * th;
+  rb_control_frame_t * cfp;
+
+  GetThreadPtr(thread, th);
+  cfp = getcfp(th, th->cfp);
   iseqdat->cref_stack = NEW_BLOCK(klass);
   iseqdat->cref_stack->nd_visi = noex;
   iseqdat->cref_stack->nd_next = cfp->iseq->cref_stack; /* TODO: use lfp? */
@@ -396,13 +414,27 @@ static VALUE module_add_method(VALUE klass, VALUE id, VALUE node, VALUE noex)
   }
 
 #if RUBY_VERSION_CODE >= 192
-  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+  if(rb_obj_is_kind_of(node, rb_cISeq))
+  {
+    rb_iseq_t *iseqdat = iseq_check(node);
+    set_cref_stack(iseqdat, klass, noex);
+    iseqdat->klass = klass;
+    iseqdat->defined_method_id = SYM2ID(id);
+
+#ifdef HAVE_RB_ADD_METHOD
+    rb_add_method(klass, SYM2ID(id), VM_METHOD_TYPE_ISEQ, iseqdat, NUM2INT(noex));
+#else
+    rb_funcall(rb_mRubyVMFrozenCore, rb_intern("core#define_method"), 3, klass, id, node); /* TODO: noex */
+#endif
+
+    return Qnil;
+  }
+
 #elif RUBY_VERSION_CODE >= 190
   if(rb_obj_is_kind_of(node, rb_cISeq))
   {
     rb_iseq_t *iseqdat = iseq_check(node);
-    /* TODO: any restrictions on what kinds of iseqs we can add here?
-     */
+    /* TODO: any restrictions on what kinds of iseqs we can add here? */
     set_cref_stack(iseqdat, klass, noex);
     iseqdat->klass = klass;
     iseqdat->defined_method_id = SYM2ID(id);
@@ -422,7 +454,7 @@ static VALUE module_add_method(VALUE klass, VALUE id, VALUE node, VALUE noex)
   Data_Get_Struct(node, NODE, n);
 
 #if RUBY_VERSION_CODE >= 192
-  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+  rb_raise(rb_eRuntimeError, "Unable to add node on this version of ruby");
 #elif RUBY_VERSION_CODE >= 190
   if(nd_type(n) != NODE_METHOD)
   {
@@ -441,10 +473,11 @@ static VALUE module_add_method(VALUE klass, VALUE id, VALUE node, VALUE noex)
   }
 
 add_node:
+
 #endif
 
 #if RUBY_VERSION_CODE >= 192
-  rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
+  rb_raise(rb_eRuntimeError, "Unable to add node on this version of ruby");
 #else
   /* TODO: if noex is NOEX_MODFUNC, add this method as a module function
    * (that is, both as an instance and singleton method)
@@ -477,7 +510,7 @@ static VALUE module_uninclude(int argc, VALUE * argv, VALUE module)
  * call-seq:
  *   remove_features(mod) => mod
  *
- * When this module is unincluded from another, Nodewrap calls
+ * When this module is unincluded from another, Ruby Internal calls
  * remove_features in this module.  The default behavior is to remove
  * the constants, methods, and module variables of this module from
  * _mod_.  If this module has not been included by _mod_, an exception
@@ -653,7 +686,7 @@ static int add_method_iter(VALUE name, VALUE value, VALUE module)
   Data_Get_Struct(value, NODE, n);
 #if RUBY_VERSION_CODE >= 192
   rb_raise(rb_eRuntimeError, "NOT SUPPORTED");
-#elif RUBY_VERSION_CODE >= 190
+#else
   rb_add_method(module, SYM2ID(name), n->nd_body, n->nd_noex);
 #endif
   return ST_CONTINUE;
@@ -795,19 +828,23 @@ void Init_module(void)
 
 #if RUBY_VERSION_CODE >= 180
   {
-    VALUE rb_mNodewrap = rb_define_module("Nodewrap");
-    rb_cClass_Restorer = rb_define_class_under(rb_mNodewrap, "ClassRestorer", rb_cObject);
+    VALUE rb_mInternal = rb_define_module("Internal");
+    rb_cClass_Restorer = rb_define_class_under(rb_mInternal, "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
-  rb_alias(CLASS_OF(rb_mMarshal), rb_intern("_Nodewrap__orig_dump"), rb_intern("dump"));
+  rb_alias(CLASS_OF(rb_mMarshal), rb_intern("_Internal__orig_dump"), rb_intern("dump"));
   rb_define_singleton_method(rb_mMarshal, "dump", ruby180_marshal_dump, -1);
 #endif
 
   rb_define_method(rb_cModule, "_dump", module_dump, 1);
   rb_define_singleton_method(rb_cModule, "_load", module_load, 1);
+
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+  init_ruby_threadptr_data_type();
+#endif
 }