ruby-internal 0.7.3 → 0.8.0

data/ext/cached/{ruby-1.9.0 → ruby-1.9.2}/internal/yarv-headers/vm_exec.h

@@ -2,15 +2,15 @@
 
   vm.h -
 
-  $Author: ko1 $
+  $Author: yugui $
   created at: 04/01/01 16:56:59 JST
 
   Copyright (C) 2004-2007 Koichi Sasada
 
 **********************************************************************/
 
-#ifndef RUBY_VM_H
-#define RUBY_VM_H
+#ifndef RUBY_VM_EXEC_H
+#define RUBY_VM_EXEC_H
 
 typedef long OFFSET;
 typedef unsigned long lindex_t;
@@ -59,9 +59,6 @@ typedef rb_iseq_t *ISEQ;
 #define throwdebug if(0)printf
 /* #define throwdebug printf */
 
-#define SDR2(cfp) vm_stack_dump_raw(GET_THREAD(), (cfp))
-
-
 /************************************************/
 #if   DISPATCH_XXX
 error !
@@ -184,4 +181,4 @@ default:                        \
 
 #define SCREG(r) (reg_##r)
 
-#endif /* RUBY_VM_H */
+#endif /* RUBY_VM_EXEC_H */

data/ext/cached/{ruby-1.9.0 → ruby-1.9.2}/internal/yarv-headers/vm_insnhelper.h

@@ -2,7 +2,7 @@
 
   insnhelper.h - helper macros to implement each instructions
 
-  $Author: ko1 $
+  $Author: wanabe $
   created at: 04/01/01 15:50:34 JST
 
   Copyright (C) 2004-2007 Koichi Sasada
@@ -34,32 +34,33 @@
 #define VMDEBUG 3
 #endif
 
-/* VM state version */
-
-extern VALUE ruby_vm_global_state_version;
-extern VALUE ruby_vm_redefined_flag;
-
-#define GET_VM_STATE_VERSION() (ruby_vm_global_state_version)
-#define INC_VM_STATE_VERSION() \
-  (ruby_vm_global_state_version = (ruby_vm_global_state_version+1) & 0x8fffffff)
-
-#define BOP_PLUS     0x01
-#define BOP_MINUS    0x02
-#define BOP_MULT     0x04
-#define BOP_DIV      0x08
-#define BOP_MOD      0x10
-#define BOP_EQ       0x20
-#define BOP_LT       0x40
-#define BOP_LE       0x80
-#define BOP_LTLT    0x100
-#define BOP_AREF    0x200
-#define BOP_ASET    0x400
-#define BOP_LENGTH  0x800
-#define BOP_SUCC   0x1000
-#define BOP_GT     0x2000
-#define BOP_GE     0x4000
-#define BOP_NOT    0x8000
-#define BOP_NEQ   0x10000
+enum {
+  BOP_PLUS,
+  BOP_MINUS,
+  BOP_MULT,
+  BOP_DIV,
+  BOP_MOD,
+  BOP_EQ,
+  BOP_EQQ,
+  BOP_LT,
+  BOP_LE,
+  BOP_LTLT,
+  BOP_AREF,
+  BOP_ASET,
+  BOP_LENGTH,
+  BOP_SIZE,
+  BOP_SUCC,
+  BOP_GT,
+  BOP_GE,
+  BOP_NOT,
+  BOP_NEQ,
+
+  BOP_LAST_
+};
+
+extern char ruby_vm_redefined_flag[BOP_LAST_];
+extern VALUE ruby_vm_const_missing_count;
+
 
 /**********************************************************/
 /* deal with stack                                        */
@@ -133,10 +134,10 @@ extern VALUE ruby_vm_redefined_flag;
 
 #define GET_PREV_DFP(dfp)                ((VALUE *)((dfp)[0] & ~0x03))
 
-#define GET_GLOBAL(entry)       rb_gvar_get((struct global_entry*)entry)
-#define SET_GLOBAL(entry, val)  rb_gvar_set((struct global_entry*)entry, val)
+#define GET_GLOBAL(entry)       rb_gvar_get((struct rb_global_entry*)entry)
+#define SET_GLOBAL(entry, val)  rb_gvar_set((struct rb_global_entry*)entry, val)
 
-#define GET_CONST_INLINE_CACHE(dst) ((IC) * (GET_PC() + (dst) + 1))
+#define GET_CONST_INLINE_CACHE(dst) ((IC) * (GET_PC() + (dst) + 2))
 
 /**********************************************************/
 /* deal with values                                       */
@@ -151,12 +152,12 @@ extern VALUE ruby_vm_redefined_flag;
 #define COPY_CREF(c1, c2) do {  \
   NODE *__tmp_c2 = (c2); \
   c1->nd_clss = __tmp_c2->nd_clss; \
-  c1->nd_visi = __tmp_c2->nd_visi; \
+  c1->nd_visi = __tmp_c2->nd_visi;\
   c1->nd_next = __tmp_c2->nd_next; \
 } while (0)
 
-#define CALL_METHOD(num, blockptr, flag, id, mn, recv, klass) do { \
-    VALUE v = vm_call_method(th, GET_CFP(), num, blockptr, flag, id, mn, recv, klass); \
+#define CALL_METHOD(num, blockptr, flag, id, me, recv) do { \
+    VALUE v = vm_call_method(th, GET_CFP(), num, blockptr, flag, id, me, recv); \
     if (v == Qundef) { \
 	RESTORE_REGS(); \
 	NEXT_INSN(); \
@@ -167,7 +168,8 @@ extern VALUE ruby_vm_redefined_flag;
 } while (0)
 
 #define GET_BLOCK_PTR() \
-  ((rb_block_t *)(GC_GUARDED_PTR_REF(GET_LFP()[0])))
+  ((rb_block_t *)(GC_GUARDED_PTR_REF(GET_LFP()[0] & \
+				     ((GET_LFP()[0] & 0x02) - 0x02))))
 
 /**********************************************************/
 /* deal with control flow 3: exception                    */
@@ -180,12 +182,27 @@ extern VALUE ruby_vm_redefined_flag;
 
 /* optimize insn */
 #define FIXNUM_2_P(a, b) ((a) & (b) & 1)
-#define BASIC_OP_UNREDEFINED_P(op) (LIKELY((ruby_vm_redefined_flag & (op)) == 0))
+#define BASIC_OP_UNREDEFINED_P(op) (LIKELY(ruby_vm_redefined_flag[op] == 0))
 #define HEAP_CLASS_OF(obj) RBASIC(obj)->klass
 
+#ifndef USE_IC_FOR_SPECIALIZED_METHOD
+#define USE_IC_FOR_SPECIALIZED_METHOD 1
+#endif
+
+#if USE_IC_FOR_SPECIALIZED_METHOD
+
+#define CALL_SIMPLE_METHOD(num, id, recv) do { \
+    VALUE klass = CLASS_OF(recv); \
+    CALL_METHOD(num, 0, 0, id, vm_method_search(id, klass, ic), recv); \
+} while (0)
+
+#else
+
 #define CALL_SIMPLE_METHOD(num, id, recv) do { \
     VALUE klass = CLASS_OF(recv); \
-    CALL_METHOD(num, 0, 0, id, rb_method_node(klass, id), recv, CLASS_OF(recv)); \
+    CALL_METHOD(num, 0, 0, id, rb_method_entry(klass, id), recv); \
 } while (0)
 
+#endif
+
 #endif /* RUBY_INSNHELPER_H */

data/ext/cached/{ruby-1.9.0 → ruby-1.9.2}/internal/yarv-headers/vm_opts.h

@@ -3,7 +3,7 @@
 
   vm_opts.h - VM optimize option
 
-  $Author: ko1 $
+  $Author: akr $
 
   Copyright (C) 2004-2007 Koichi Sasada
 

data/ext/cached/ruby-1.9.3/internal/binding/block.h

@@ -0,0 +1,12 @@
+#ifndef ruby_internal_block__h_
+#define ruby_internal_block__h_
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include "env.h"
+#endif
+
+
+#endif
+

data/ext/cached/ruby-1.9.3/internal/method/internal_method.h

@@ -0,0 +1,32 @@
+#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;
+    struct unlinked_method_entry_list_entry *ume;
+};
+
+#define METHOD_OCLASS(m) m->klass
+#define METHOD_RCLASS(m) m->rclass
+
+#endif
+

data/ext/cached/ruby-1.9.3/internal/module/classpath.c

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

data/ext/cached/{ruby-1.8.0 → ruby-1.9.3}/internal/module/classpath.h

@@ -3,11 +3,14 @@
 
 #include "ruby.h"
 
+VALUE class2path(
+
+);
 VALUE path2class(
-    char *path
+
 );
 VALUE path2module(
-    char *path
+
 );
 
 #endif

data/ext/cached/ruby-1.9.3/internal/module/getcfp.h

@@ -0,0 +1,25 @@
+#ifndef getcfp__h
+#define getcfp__h
+
+#include "ruby.h"
+
+#ifdef RUBY_VM
+
+#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
+
+#endif

data/ext/cached/ruby-1.9.3/internal/node/block.h

@@ -0,0 +1,12 @@
+#ifndef ruby_internal_block__h_
+#define ruby_internal_block__h_
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include "env.h"
+#endif
+
+
+#endif
+

data/ext/cached/ruby-1.9.3/internal/node/global_entry.h

@@ -0,0 +1,93 @@
+#ifndef global_entry__h_
+#define global_entry__h_
+
+st_table * rb_global_tbl;
+
+#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)(VALUE arg, VALUE val);
+    VALUE data;
+    struct trace_var *next;
+};
+struct global_variable {
+    int   counter;
+    void *data;
+    gvar_getter_t *getter;
+    gvar_setter_t *setter;
+    gvar_marker_t *marker;
+    int block_trace;
+    struct trace_var *trace;
+};
+#define undef_getter	rb_gvar_undef_getter
+#define undef_setter	rb_gvar_undef_setter
+#define undef_marker	rb_gvar_undef_marker
+struct global_entry*
+rb_global_entry(ID id)
+{
+    struct global_entry *entry;
+    st_data_t 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);
+	entry->id = id;
+	entry->var = var;
+	var->counter = 1;
+	var->data = 0;
+	var->getter = undef_getter;
+	var->setter = undef_setter;
+	var->marker = undef_marker;
+
+	var->block_trace = 0;
+	var->trace = 0;
+	st_add_direct(rb_global_tbl, id, (st_data_t)entry);
+    }
+    else {
+	entry = (struct global_entry *)data;
+    }
+    return entry;
+}
+VALUE
+undef_getter(ID id, void *data, struct global_variable *var)
+{
+    rb_warning("global variable `%s' not initialized", rb_id2name(id));
+
+    return Qnil;
+}
+void
+undef_setter(VALUE val, ID id, void *data, struct global_variable *var)
+{
+    var->getter = val_getter;
+    var->setter = val_setter;
+    var->marker = val_marker;
+
+    var->data = (void*)val;
+}
+void
+undef_marker(VALUE *var)
+{
+}
+VALUE
+val_getter(ID id, void *data, struct global_variable *var)
+{
+    return (VALUE)data;
+}
+void
+val_setter(VALUE val, ID id, void *data, struct global_variable *var)
+{
+    var->data = (void*)val;
+}
+void
+val_marker(VALUE *var)
+{
+    VALUE data = (VALUE)var;
+    if (data) rb_gc_mark_maybe(data);
+}
+
+#endif
+

data/ext/cached/{ruby-1.8.3 → ruby-1.9.3}/internal/node/node_type_descrip.c

@@ -2,111 +2,102 @@
 #include "version.h"
 
 Node_Type_Descrip node_type_descrips_unsorted[] = {
-  { NODE_ALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "ALIAS" },
+  { NODE_ALIAS, NEN_2ND, NEN_1ST, NEN_NONE, "ALIAS" },
 #ifdef HAVE_NODE_ALLOCA
-  { NODE_ALLOCA, NEN_CFNC, NEN_VALUE, NEN_CNT, "ALLOCA" },
+  { NODE_ALLOCA, NEN_CFNC, NEN_CNT, NEN_VALUE, "ALLOCA" },
 #endif
-  { NODE_AND, NEN_1ST, NEN_2ND, NEN_NONE, "AND" },
-  { NODE_ARGS, NEN_REST, NEN_OPT, NEN_CNT, "ARGS" },
+  { NODE_AND, NEN_2ND, NEN_1ST, NEN_NONE, "AND" },
+  { NODE_ARGS, NEN_OPT, NEN_REST, NEN_CNT, "ARGS" },
   { NODE_ARGSCAT, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSCAT" },
   { NODE_ARGSPUSH, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSPUSH" },
-  { NODE_ARRAY, NEN_HEAD, NEN_ALEN, NEN_NEXT, "ARRAY" },
+  { NODE_ARRAY, NEN_NEXT, NEN_HEAD, NEN_ALEN, "ARRAY" },
   { NODE_ATTRASGN, NEN_ARGS, NEN_MID, NEN_RECV, "ATTRASGN" },
-  { NODE_ATTRSET, NEN_VID, NEN_NONE, NEN_NONE, "ATTRSET" },
   { NODE_BACK_REF, NEN_NTH, NEN_CNT, NEN_NONE, "BACK_REF" },
   { NODE_BEGIN, NEN_BODY, NEN_NONE, NEN_NONE, "BEGIN" },
-  { NODE_BLOCK, NEN_HEAD, NEN_NEXT, NEN_NONE, "BLOCK" },
+  { NODE_BLOCK, NEN_NEXT, NEN_HEAD, NEN_NONE, "BLOCK" },
   { NODE_BLOCK_ARG, NEN_CNT, NEN_NONE, NEN_NONE, "BLOCK_ARG" },
-  { NODE_BLOCK_PASS, NEN_BODY, NEN_ITER, NEN_NONE, "BLOCK_PASS" },
+  { NODE_BLOCK_PASS, NEN_ITER, NEN_BODY, 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_HEAD, NEN_BODY, NEN_NEXT, "CASE" },
-  { NODE_CDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CDECL" },
-  { NODE_CFUNC, NEN_CFNC, NEN_ARGC, NEN_NONE, "CFUNC" },
-  { NODE_CLASS, NEN_CPATH, NEN_BODY, NEN_SUPER, "CLASS" },
+  { NODE_CASE, NEN_NEXT, NEN_HEAD, NEN_BODY, "CASE" },
+  { NODE_CDECL, NEN_VID, NEN_VALUE, NEN_NONE, "CDECL" },
+  { 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_BODY, NEN_NEXT, 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_CVASGN, NEN_VID, NEN_VALUE, NEN_NONE, "CVASGN" },
+  { NODE_CVDECL, NEN_VID, NEN_VALUE, NEN_NONE, "CVDECL" },
+  { NODE_DASGN, NEN_VID, NEN_VALUE, NEN_NONE, "DASGN" },
+  { NODE_DASGN_CURR, NEN_VID, NEN_VALUE, NEN_NONE, "DASGN_CURR" },
   { NODE_DEFINED, NEN_HEAD, NEN_NONE, NEN_NONE, "DEFINED" },
-  { NODE_DEFN, NEN_DEFN, NEN_MID, NEN_NOEX, "DEFN" },
+  { NODE_DEFN, NEN_NOEX, NEN_DEFN, NEN_MID, "DEFN" },
   { NODE_DEFS, NEN_DEFN, NEN_MID, NEN_RECV, "DEFS" },
-  { NODE_DMETHOD, NEN_CVAL, NEN_NONE, NEN_NONE, "DMETHOD" },
-  { NODE_DOT2, NEN_BEG, NEN_END, NEN_STATE, "DOT2" },
-  { NODE_DOT3, NEN_BEG, NEN_END, NEN_STATE, "DOT3" },
-  { NODE_DREGX, NEN_LIT, NEN_CFLAG, NEN_NEXT, "DREGX" },
-  { NODE_DREGX_ONCE, NEN_LIT, NEN_CFLAG, NEN_NEXT, "DREGX_ONCE" },
-  { NODE_DSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DSTR" },
-  { NODE_DSYM, NEN_LIT, NEN_NEXT, NEN_NONE, "DSYM" },
+  { NODE_DOT2, NEN_STATE, NEN_BEG, NEN_END, "DOT2" },
+  { NODE_DOT3, NEN_STATE, NEN_BEG, NEN_END, "DOT3" },
+  { NODE_DREGX, NEN_NEXT, NEN_CFLAG, NEN_LIT, "DREGX" },
+  { NODE_DREGX_ONCE, NEN_NEXT, NEN_CFLAG, NEN_LIT, "DREGX_ONCE" },
+  { NODE_DSTR, NEN_NEXT, NEN_LIT, NEN_NONE, "DSTR" },
+  { NODE_DSYM, NEN_NEXT, NEN_LIT, NEN_NONE, "DSYM" },
   { NODE_DVAR, NEN_VID, NEN_NONE, NEN_NONE, "DVAR" },
-  { NODE_DXSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DXSTR" },
+  { NODE_DXSTR, NEN_NEXT, NEN_LIT, 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_HEAD, NEN_ORIG, NEN_MID, "FBODY" },
   { NODE_FCALL, NEN_ARGS, NEN_MID, NEN_NONE, "FCALL" },
-  { NODE_FLIP2, NEN_BEG, NEN_END, NEN_CNT, "FLIP2" },
-  { NODE_FLIP3, NEN_BEG, NEN_END, NEN_CNT, "FLIP3" },
-  { NODE_FOR, NEN_BODY, NEN_ITER, NEN_VAR, "FOR" },
-  { NODE_GASGN, NEN_VALUE, NEN_VID, NEN_ENTRY, "GASGN" },
+  { NODE_FLIP2, NEN_CNT, NEN_BEG, NEN_END, "FLIP2" },
+  { NODE_FLIP3, NEN_CNT, NEN_BEG, NEN_END, "FLIP3" },
+  { NODE_FOR, NEN_ITER, NEN_VAR, NEN_BODY, "FOR" },
+  { NODE_GASGN, NEN_VID, NEN_ENTRY, NEN_VALUE, "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_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_IASGN, NEN_VID, NEN_VALUE, NEN_NONE, "IASGN" },
+  { NODE_IF, NEN_ELSE, NEN_COND, NEN_BODY, "IF" },
+  { NODE_IFUNC, NEN_TVAL, NEN_STATE, NEN_CFNC, "IFUNC" },
+  { NODE_ITER, NEN_ITER, NEN_VAR, NEN_BODY, "ITER" },
   { NODE_IVAR, NEN_VID, NEN_NONE, NEN_NONE, "IVAR" },
-  { NODE_LASGN, NEN_VALUE, NEN_VID, NEN_CNT, "LASGN" },
+  { NODE_LASGN, NEN_VID, NEN_CNT, NEN_VALUE, "LASGN" },
   { NODE_LIT, NEN_LIT, NEN_NONE, NEN_NONE, "LIT" },
   { 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_VALUE, NEN_RECV, NEN_NONE, "MATCH2" },
-  { NODE_MATCH3, NEN_VALUE, NEN_RECV, NEN_NONE, "MATCH3" },
+  { 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_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_VALUE, NEN_NEXT, NEN_RECV, "OP_ASGN2" },
-  { NODE_OP_ASGN2_ARG, NEN_VID, NEN_AID, NEN_MID, "OP_ASGN2_ARG" },
-  { NODE_OP_ASGN_AND, NEN_VALUE, NEN_RECV, NEN_NONE, "OP_ASGN_AND" },
-  { NODE_OP_ASGN_OR, NEN_AID, NEN_VALUE, NEN_RECV, "OP_ASGN_OR" },
-  { NODE_OR, NEN_1ST, NEN_2ND, NEN_NONE, "OR" },
+  { 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_ASGN_AND, NEN_RECV, NEN_VALUE, NEN_NONE, "OP_ASGN_AND" },
+  { NODE_OP_ASGN_OR, NEN_AID, NEN_RECV, NEN_VALUE, "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_HEAD, NEN_ARGS, NEN_BODY, "RESBODY" },
-  { NODE_RESCUE, NEN_HEAD, NEN_ELSE, NEN_RESQ, "RESCUE" },
+  { NODE_RESBODY, NEN_ARGS, NEN_HEAD, NEN_BODY, "RESBODY" },
+  { NODE_RESCUE, NEN_ELSE, NEN_HEAD, NEN_RESQ, "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_TBL, NEN_RVAL, NEN_NEXT, "SCOPE" },
+  { NODE_SCLASS, NEN_RECV, NEN_BODY, NEN_NONE, "SCLASS" },
+  { NODE_SCOPE, NEN_NEXT, NEN_TBL, NEN_RVAL, "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_MID, NEN_NONE, NEN_NONE, "UNDEF" },
-  { NODE_UNTIL, NEN_BODY, NEN_COND, NEN_STATE, "UNTIL" },
-  { NODE_VALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "VALIAS" },
+  { NODE_UNDEF, NEN_BODY, NEN_NONE, NEN_NONE, "UNDEF" },
+  { NODE_UNTIL, NEN_STATE, NEN_COND, NEN_BODY, "UNTIL" },
+  { NODE_VALIAS, NEN_2ND, NEN_1ST, NEN_NONE, "VALIAS" },
   { NODE_VCALL, NEN_MID, NEN_NONE, NEN_NONE, "VCALL" },
-  { NODE_WHEN, NEN_HEAD, NEN_BODY, NEN_NEXT, "WHEN" },
-  { NODE_WHILE, NEN_BODY, NEN_COND, NEN_STATE, "WHILE" },
+  { NODE_WHEN, NEN_NEXT, NEN_HEAD, NEN_BODY, "WHEN" },
+  { NODE_WHILE, NEN_STATE, NEN_COND, NEN_BODY, "WHILE" },
   { NODE_XSTR, NEN_LIT, NEN_NONE, NEN_NONE, "XSTR" },
-  { NODE_YIELD, NEN_HEAD, NEN_STATE, NEN_NONE, "YIELD" },
+  { NODE_YIELD, NEN_STATE, NEN_HEAD, NEN_NONE, "YIELD" },
   { NODE_ZARRAY, NEN_NONE, NEN_NONE, NEN_NONE, "ZARRAY" },
   { NODE_ZSUPER, NEN_NONE, NEN_NONE, NEN_NONE, "ZSUPER" },
   { NODE_LAST, NEN_NONE, NEN_NONE, NEN_NONE, "LAST" },