ruby-internal 0.8.0 → 0.8.1

data/ext/internal/binding/block.h

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

data/ext/internal/module/classpath.c

@@ -1,43 +1,38 @@
 #include "classpath.h"
 
 VALUE
-class2path(klass)
-    VALUE klass;
+class2path(VALUE klass)
 {
     VALUE path = rb_class_path(klass);
-    char *n = RSTRING(path)->ptr;
+    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(path)
-    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(path)
-    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/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/getcfp.h

@@ -7,6 +7,18 @@
 
 #include "vm_core.h"
 
+static rb_control_frame_t *
+getcfp(rb_thread_t *th, rb_control_frame_t *cfp)
+{
+    while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
+	if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
+	    return cfp;
+	}
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+    }
+    return 0;
+}
+
 
 #endif
 

data/ext/internal/node/block.h

@@ -7,26 +7,6 @@
 #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/node/global_entry.h

@@ -3,39 +3,39 @@
 
 st_table * rb_global_tbl;
 
+#define global_variable rb_global_variable
+#define global_entry rb_global_entry
+#define gvar_getter_t rb_gvar_getter_t
+#define gvar_setter_t rb_gvar_setter_t
+#define gvar_marker_t rb_gvar_marker_t
 struct trace_var {
     int removed;
-    void (*func)();
+    void (*func)(VALUE arg, VALUE val);
     VALUE data;
     struct trace_var *next;
 };
 struct global_variable {
     int   counter;
     void *data;
-    VALUE (*getter)();
-    void  (*setter)();
-    void  (*marker)();
+    gvar_getter_t *getter;
+    gvar_setter_t *setter;
+    gvar_marker_t *marker;
     int block_trace;
     struct trace_var *trace;
 };
-struct global_entry {
-    struct global_variable *var;
-    ID id;
-};
-static VALUE undef_getter();
-static void  undef_setter();
-static void  undef_marker();
-static VALUE val_getter();
-static void  val_setter();
-static void  val_marker();
+#define undef_getter	rb_gvar_undef_getter
+#define undef_setter	rb_gvar_undef_setter
+#define undef_marker	rb_gvar_undef_marker
+#define val_getter	rb_gvar_val_getter
+#define val_setter	rb_gvar_val_setter
+#define val_marker	rb_gvar_val_marker
 struct global_entry*
-rb_global_entry(id)
-    ID id;
+rb_global_entry(ID id)
 {
     struct global_entry *entry;
     st_data_t data;
 
-    if (!st_lookup(rb_global_tbl, id, &data)) {
+    if (!st_lookup(rb_global_tbl, (st_data_t)id, &data)) {
 	struct global_variable *var;
 	entry = ALLOC(struct global_entry);
 	var = ALLOC(struct global_variable);
@@ -56,20 +56,15 @@ rb_global_entry(id)
     }
     return entry;
 }
-static VALUE
-undef_getter(id)
-    ID id;
+VALUE
+undef_getter(ID id, void *data, struct global_variable *var)
 {
     rb_warning("global variable `%s' not initialized", rb_id2name(id));
 
     return Qnil;
 }
-static void
-undef_setter(val, id, data, var)
-    VALUE val;
-    ID id;
-    void *data;
-    struct global_variable *var;
+void
+undef_setter(VALUE val, ID id, void *data, struct global_variable *var)
 {
     var->getter = val_getter;
     var->setter = val_setter;
@@ -77,30 +72,24 @@ undef_setter(val, id, data, var)
 
     var->data = (void*)val;
 }
-static void
-undef_marker()
+void
+undef_marker(VALUE *var)
 {
 }
-static VALUE
-val_getter(id, val)
-    ID id;
-    VALUE val;
+VALUE
+val_getter(ID id, void *data, struct global_variable *var)
 {
-    return val;
+    return (VALUE)data;
 }
-static void
-val_setter(val, id, data, var)
-    VALUE val;
-    ID id;
-    void *data;
-    struct global_variable *var;
+void
+val_setter(VALUE val, ID id, void *data, struct global_variable *var)
 {
     var->data = (void*)val;
 }
-static void
-val_marker(data)
-    VALUE data;
+void
+val_marker(VALUE *var)
 {
+    VALUE data = (VALUE)var;
     if (data) rb_gc_mark_maybe(data);
 }
 

data/ext/internal/node/global_entry.h.rpp

@@ -28,7 +28,7 @@ st_table * rb_global_tbl;
         puts prev_line
         write = true
         stopwrite = false
-      when /^#define (global_entry|gvar_getter_t|gvar_setter_t|gvar_marker_t|undef_getter|undef_setter|undef_marker)/
+      when /^#define (global_entry|global_variable|gvar_getter_t|gvar_setter_t|gvar_marker_t|undef_getter|undef_setter|undef_marker|val_getter|val_setter|val_marker)/
         puts line
       when /^\}/
         stopwrite = true

data/ext/internal/node/node_type_descrip.c

@@ -2,109 +2,100 @@
 #include "version.h"
 
 Node_Type_Descrip node_type_descrips_unsorted[] = {
-  { NODE_ALIAS, NEN_2ND, NEN_1ST, NEN_NONE, "ALIAS" },
+  { NODE_ALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "ALIAS" },
 #ifdef HAVE_NODE_ALLOCA
-  { NODE_ALLOCA, NEN_CNT, NEN_CFNC, NEN_VALUE, "ALLOCA" },
+  { NODE_ALLOCA, NEN_CFNC, NEN_VALUE, NEN_CNT, "ALLOCA" },
 #endif
   { NODE_AND, NEN_2ND, NEN_1ST, NEN_NONE, "AND" },
-  { NODE_ARGS, NEN_REST, NEN_CNT, NEN_OPT, "ARGS" },
+  { NODE_ARGS, NEN_REST, NEN_OPT, NEN_CNT, "ARGS" },
   { NODE_ARGSCAT, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSCAT" },
   { NODE_ARGSPUSH, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSPUSH" },
-  { NODE_ARRAY, NEN_NEXT, NEN_HEAD, NEN_ALEN, "ARRAY" },
-  { NODE_ATTRASGN, NEN_ARGS, NEN_RECV, NEN_MID, "ATTRASGN" },
-  { NODE_ATTRSET, NEN_VID, NEN_NONE, NEN_NONE, "ATTRSET" },
-  { NODE_BACK_REF, NEN_CNT, NEN_NTH, NEN_NONE, "BACK_REF" },
+  { NODE_ARRAY, NEN_ALEN, NEN_HEAD, NEN_NEXT, "ARRAY" },
+  { NODE_ATTRASGN, NEN_RECV, NEN_ARGS, NEN_MID, "ATTRASGN" },
+  { NODE_BACK_REF, NEN_NTH, NEN_CNT, NEN_NONE, "BACK_REF" },
   { NODE_BEGIN, NEN_BODY, NEN_NONE, NEN_NONE, "BEGIN" },
-  { NODE_BLOCK, NEN_NEXT, NEN_HEAD, NEN_NONE, "BLOCK" },
+  { NODE_BLOCK, NEN_HEAD, NEN_NEXT, NEN_NONE, "BLOCK" },
   { NODE_BLOCK_ARG, NEN_CNT, NEN_NONE, NEN_NONE, "BLOCK_ARG" },
-  { NODE_BLOCK_PASS, NEN_ITER, NEN_BODY, NEN_NONE, "BLOCK_PASS" },
+  { NODE_BLOCK_PASS, NEN_BODY, NEN_ITER, NEN_NONE, "BLOCK_PASS" },
   { NODE_BMETHOD, NEN_CVAL, NEN_NONE, NEN_NONE, "BMETHOD" },
   { NODE_BREAK, NEN_STTS, NEN_NONE, NEN_NONE, "BREAK" },
   { NODE_CALL, NEN_ARGS, NEN_MID, NEN_RECV, "CALL" },
-  { NODE_CASE, NEN_NEXT, NEN_HEAD, NEN_BODY, "CASE" },
+  { NODE_CASE, NEN_HEAD, NEN_BODY, NEN_NEXT, "CASE" },
   { NODE_CDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CDECL" },
-  { NODE_CFUNC, NEN_ARGC, NEN_CFNC, NEN_NONE, "CFUNC" },
   { NODE_CLASS, NEN_SUPER, NEN_CPATH, NEN_BODY, "CLASS" },
   { NODE_COLON2, NEN_HEAD, NEN_MID, NEN_NONE, "COLON2" },
   { NODE_COLON3, NEN_MID, NEN_NONE, NEN_NONE, "COLON3" },
   { NODE_CONST, NEN_VID, NEN_NONE, NEN_NONE, "CONST" },
-  { NODE_CREF, NEN_NEXT, NEN_BODY, NEN_CLSS, "CREF" },
   { NODE_CVAR, NEN_VID, NEN_NONE, NEN_NONE, "CVAR" },
   { NODE_CVASGN, NEN_VALUE, NEN_VID, NEN_NONE, "CVASGN" },
   { NODE_CVDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CVDECL" },
   { NODE_DASGN, NEN_VALUE, NEN_VID, NEN_NONE, "DASGN" },
   { NODE_DASGN_CURR, NEN_VALUE, NEN_VID, NEN_NONE, "DASGN_CURR" },
   { NODE_DEFINED, NEN_HEAD, NEN_NONE, NEN_NONE, "DEFINED" },
-  { NODE_DEFN, NEN_MID, NEN_NOEX, NEN_DEFN, "DEFN" },
-  { NODE_DEFS, NEN_RECV, NEN_MID, NEN_DEFN, "DEFS" },
-  { NODE_DMETHOD, NEN_CVAL, NEN_NONE, NEN_NONE, "DMETHOD" },
-  { NODE_DOT2, NEN_END, NEN_STATE, NEN_BEG, "DOT2" },
-  { NODE_DOT3, NEN_END, NEN_STATE, NEN_BEG, "DOT3" },
-  { NODE_DREGX, NEN_NEXT, NEN_LIT, NEN_CFLAG, "DREGX" },
-  { NODE_DREGX_ONCE, NEN_NEXT, NEN_LIT, NEN_CFLAG, "DREGX_ONCE" },
-  { NODE_DSTR, NEN_NEXT, NEN_LIT, NEN_NONE, "DSTR" },
-  { NODE_DSYM, NEN_NEXT, NEN_LIT, NEN_NONE, "DSYM" },
+  { NODE_DEFN, NEN_DEFN, NEN_MID, NEN_NOEX, "DEFN" },
+  { NODE_DEFS, NEN_DEFN, NEN_RECV, NEN_MID, "DEFS" },
+  { NODE_DOT2, NEN_BEG, NEN_END, NEN_STATE, "DOT2" },
+  { NODE_DOT3, NEN_BEG, NEN_END, NEN_STATE, "DOT3" },
+  { NODE_DREGX, NEN_LIT, NEN_NEXT, NEN_CFLAG, "DREGX" },
+  { NODE_DREGX_ONCE, NEN_LIT, NEN_NEXT, NEN_CFLAG, "DREGX_ONCE" },
+  { NODE_DSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DSTR" },
+  { NODE_DSYM, NEN_LIT, NEN_NEXT, NEN_NONE, "DSYM" },
   { NODE_DVAR, NEN_VID, NEN_NONE, NEN_NONE, "DVAR" },
-  { NODE_DXSTR, NEN_NEXT, NEN_LIT, NEN_NONE, "DXSTR" },
+  { NODE_DXSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DXSTR" },
   { NODE_ENSURE, NEN_HEAD, NEN_ENSR, NEN_NONE, "ENSURE" },
   { NODE_EVSTR, NEN_BODY, NEN_NONE, NEN_NONE, "EVSTR" },
   { NODE_FALSE, NEN_NONE, NEN_NONE, NEN_NONE, "FALSE" },
-  { NODE_FBODY, NEN_ORIG, NEN_HEAD, NEN_MID, "FBODY" },
   { NODE_FCALL, NEN_ARGS, NEN_MID, NEN_NONE, "FCALL" },
-  { NODE_FLIP2, NEN_CNT, NEN_END, NEN_BEG, "FLIP2" },
-  { NODE_FLIP3, NEN_CNT, NEN_END, NEN_BEG, "FLIP3" },
-  { NODE_FOR, NEN_ITER, NEN_BODY, NEN_VAR, "FOR" },
-  { NODE_GASGN, NEN_ENTRY, NEN_VALUE, NEN_VID, "GASGN" },
-  { NODE_GVAR, NEN_ENTRY, NEN_VID, NEN_NONE, "GVAR" },
+  { NODE_FLIP2, NEN_CNT, NEN_BEG, NEN_END, "FLIP2" },
+  { NODE_FLIP3, NEN_CNT, NEN_BEG, NEN_END, "FLIP3" },
+  { NODE_FOR, NEN_BODY, NEN_ITER, NEN_VAR, "FOR" },
+  { NODE_GASGN, NEN_VALUE, NEN_VID, NEN_ENTRY, "GASGN" },
+  { NODE_GVAR, NEN_VID, NEN_ENTRY, NEN_NONE, "GVAR" },
   { NODE_HASH, NEN_HEAD, NEN_NONE, NEN_NONE, "HASH" },
   { NODE_IASGN, NEN_VALUE, NEN_VID, NEN_NONE, "IASGN" },
-  { NODE_IF, NEN_ELSE, NEN_BODY, NEN_COND, "IF" },
-  { NODE_IFUNC, NEN_TVAL, NEN_CFNC, NEN_STATE, "IFUNC" },
-  { NODE_ITER, NEN_ITER, NEN_BODY, NEN_VAR, "ITER" },
+  { NODE_IF, NEN_COND, NEN_BODY, NEN_ELSE, "IF" },
+  { NODE_IFUNC, NEN_CFNC, NEN_TVAL, NEN_STATE, "IFUNC" },
+  { NODE_ITER, NEN_BODY, NEN_ITER, NEN_VAR, "ITER" },
   { NODE_IVAR, NEN_VID, NEN_NONE, NEN_NONE, "IVAR" },
-  { NODE_LASGN, NEN_CNT, NEN_VALUE, NEN_VID, "LASGN" },
+  { NODE_LASGN, NEN_VALUE, NEN_VID, NEN_CNT, "LASGN" },
   { NODE_LIT, NEN_LIT, NEN_NONE, NEN_NONE, "LIT" },
-  { NODE_LVAR, NEN_CNT, NEN_VID, NEN_NONE, "LVAR" },
+  { NODE_LVAR, NEN_VID, NEN_CNT, NEN_NONE, "LVAR" },
   { NODE_MASGN, NEN_ARGS, NEN_HEAD, NEN_VALUE, "MASGN" },
   { NODE_MATCH, NEN_LIT, NEN_VALUE, NEN_NONE, "MATCH" },
   { NODE_MATCH2, NEN_RECV, NEN_VALUE, NEN_NONE, "MATCH2" },
   { NODE_MATCH3, NEN_RECV, NEN_VALUE, NEN_NONE, "MATCH3" },
   { NODE_MEMO, NEN_NONE, NEN_NONE, NEN_NONE, "MEMO" },
-  { NODE_METHOD, NEN_BODY, NEN_NOEX, NEN_NONE, "METHOD" },
   { NODE_MODULE, NEN_CPATH, NEN_BODY, NEN_NONE, "MODULE" },
-  { NODE_NEWLINE, NEN_NEXT, NEN_NONE, NEN_NONE, "NEWLINE" },
   { NODE_NEXT, NEN_STTS, NEN_NONE, NEN_NONE, "NEXT" },
   { NODE_NIL, NEN_NONE, NEN_NONE, NEN_NONE, "NIL" },
-  { NODE_NOT, NEN_BODY, NEN_NONE, NEN_NONE, "NOT" },
-  { NODE_NTH_REF, NEN_CNT, NEN_NTH, NEN_NONE, "NTH_REF" },
+  { NODE_NTH_REF, NEN_NTH, NEN_CNT, NEN_NONE, "NTH_REF" },
   { NODE_OPT_N, NEN_BODY, NEN_NONE, NEN_NONE, "OPT_N" },
   { NODE_OP_ASGN1, NEN_ARGS, NEN_MID, NEN_RECV, "OP_ASGN1" },
-  { NODE_OP_ASGN2, NEN_NEXT, NEN_RECV, NEN_VALUE, "OP_ASGN2" },
-  { NODE_OP_ASGN2_ARG, NEN_AID, NEN_MID, NEN_VID, "OP_ASGN2_ARG" },
+  { NODE_OP_ASGN2, NEN_RECV, NEN_NEXT, NEN_VALUE, "OP_ASGN2" },
+  { NODE_OP_ASGN2_ARG, NEN_VID, NEN_AID, NEN_MID, "OP_ASGN2_ARG" },
   { NODE_OP_ASGN_AND, NEN_RECV, NEN_VALUE, NEN_NONE, "OP_ASGN_AND" },
   { NODE_OP_ASGN_OR, NEN_AID, NEN_VALUE, NEN_RECV, "OP_ASGN_OR" },
   { NODE_OR, NEN_2ND, NEN_1ST, NEN_NONE, "OR" },
   { NODE_POSTEXE, NEN_NONE, NEN_NONE, NEN_NONE, "POSTEXE" },
   { NODE_REDO, NEN_NONE, NEN_NONE, NEN_NONE, "REDO" },
-  { NODE_RESBODY, NEN_ARGS, NEN_HEAD, NEN_BODY, "RESBODY" },
-  { NODE_RESCUE, NEN_RESQ, NEN_HEAD, NEN_ELSE, "RESCUE" },
+  { NODE_RESBODY, NEN_HEAD, NEN_BODY, NEN_ARGS, "RESBODY" },
+  { NODE_RESCUE, NEN_HEAD, NEN_RESQ, NEN_ELSE, "RESCUE" },
   { NODE_RETRY, NEN_NONE, NEN_NONE, NEN_NONE, "RETRY" },
   { NODE_RETURN, NEN_STTS, NEN_NONE, NEN_NONE, "RETURN" },
   { NODE_SCLASS, NEN_BODY, NEN_RECV, NEN_NONE, "SCLASS" },
-  { NODE_SCOPE, NEN_NEXT, NEN_TBL, NEN_RVAL, "SCOPE" },
+  { NODE_SCOPE, NEN_TBL, NEN_RVAL, NEN_NEXT, "SCOPE" },
   { NODE_SELF, NEN_NONE, NEN_NONE, NEN_NONE, "SELF" },
   { NODE_SPLAT, NEN_HEAD, NEN_NONE, NEN_NONE, "SPLAT" },
   { NODE_STR, NEN_LIT, NEN_NONE, NEN_NONE, "STR" },
   { NODE_SUPER, NEN_ARGS, NEN_NONE, NEN_NONE, "SUPER" },
-  { NODE_SVALUE, NEN_HEAD, NEN_NONE, NEN_NONE, "SVALUE" },
   { NODE_TO_ARY, NEN_HEAD, NEN_NONE, NEN_NONE, "TO_ARY" },
   { NODE_TRUE, NEN_NONE, NEN_NONE, NEN_NONE, "TRUE" },
   { NODE_UNDEF, NEN_BODY, NEN_NONE, NEN_NONE, "UNDEF" },
-  { NODE_UNTIL, NEN_BODY, NEN_STATE, NEN_COND, "UNTIL" },
-  { NODE_VALIAS, NEN_2ND, NEN_1ST, NEN_NONE, "VALIAS" },
+  { NODE_UNTIL, NEN_BODY, NEN_COND, NEN_STATE, "UNTIL" },
+  { NODE_VALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "VALIAS" },
   { NODE_VCALL, NEN_MID, NEN_NONE, NEN_NONE, "VCALL" },
-  { NODE_WHEN, NEN_NEXT, NEN_HEAD, NEN_BODY, "WHEN" },
-  { NODE_WHILE, NEN_BODY, NEN_STATE, NEN_COND, "WHILE" },
+  { NODE_WHEN, NEN_HEAD, NEN_BODY, NEN_NEXT, "WHEN" },
+  { NODE_WHILE, NEN_BODY, NEN_COND, NEN_STATE, "WHILE" },
   { NODE_XSTR, NEN_LIT, NEN_NONE, NEN_NONE, "XSTR" },
   { NODE_YIELD, NEN_HEAD, NEN_STATE, NEN_NONE, "YIELD" },
   { NODE_ZARRAY, NEN_NONE, NEN_NONE, NEN_NONE, "ZARRAY" },