ruby-internal 0.7.3 → 0.8.0

data/ext/cached/ruby-1.9.1/internal/vm/instruction/insns_info.c

@@ -2,6 +2,9 @@
 
 #ifdef RUBY_VM
 
+#include "iseq.h"
+#include "vm_core.h"
+
 static rb_compile_option_t COMPILE_OPTION_DEFAULT = {
     OPT_INLINE_CONST_CACHE, /* int inline_const_cache; */
     OPT_PEEPHOLE_OPTIMIZATION, /* int peephole_optimization; */

data/ext/cached/ruby-1.9.1/internal/vm/iseq/iseq_load.inc

@@ -1,9 +1,28 @@
 #ifndef ruby_internal_iseq_load__inc_
 #define ruby_internal_iseq_load__inc_
 
-#include "internal/yarv-headers/gc.h"
-#include "internal/yarv-headers/iseq.h"
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
 
+  static rb_data_type_t const * p_iseq_data_type;
+
+  static void init_iseq_data_type()
+  {
+    rb_proc_t * p;
+    VALUE body;
+
+    VALUE binding = rb_binding_new();
+    VALUE new_proc = rb_funcall(
+        rb_cObject, rb_intern("eval"), 2, rb_str_new2("proc { }"), binding);
+    GetProcPtr(new_proc, p);
+    body = p->block.iseq->self;
+
+    p_iseq_data_type = RTYPEDDATA_TYPE(body);
+  }
+
+#else
+
+#endif
+#
 static void
 compile_data_free(struct iseq_compile_data *compile_data)
 {
@@ -124,7 +143,7 @@ set_relation(rb_iseq_t *iseq, const VALUE parent)
 }
 static VALUE
 prepare_iseq_build(rb_iseq_t *iseq,
-		   VALUE name, VALUE filename,
+		   VALUE name, VALUE filename, VALUE line_no,
 		   VALUE parent, VALUE type, VALUE block_opt,
 		   const rb_compile_option_t *option)
 {
@@ -133,6 +152,7 @@ prepare_iseq_build(rb_iseq_t *iseq,
 
     iseq->name = name;
     iseq->filename = filename;
+    iseq->line_no = line_no;
     iseq->defined_method_id = 0;
     iseq->mark_ary = rb_ary_new();
     RBASIC(iseq->mark_ary)->klass = 0;
@@ -166,6 +186,7 @@ prepare_iseq_build(rb_iseq_t *iseq,
     iseq->compile_data->storage_head->buff =
       (char *)(&iseq->compile_data->storage_head->buff + 1);
     iseq->compile_data->option = option;
+    iseq->compile_data->last_coverable_line = -1;
 
     set_relation(iseq, parent);
 
@@ -278,7 +299,7 @@ iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt)
     VALUE iseqval = iseq_alloc(self);
 
     VALUE magic, version1, version2, format_type, misc;
-    VALUE name, filename;
+    VALUE name, filename, line_no;
     VALUE type, body, locals, args, exception;
 
     VALUE iseq_type;
@@ -288,7 +309,7 @@ iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt)
     int i = 0;
 
     /* [magic, major_version, minor_version, format_type, misc,
-     *  name, filename,
+     *  name, filename, line_no,
      *  type, locals, args, exception_table, body]
      */
 
@@ -302,6 +323,7 @@ iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt)
 
     name        = CHECK_STRING(rb_ary_entry(data, i++));
     filename    = CHECK_STRING(rb_ary_entry(data, i++));
+    line_no     = CHECK_INTEGER(rb_ary_entry(data, i++));
 
     type        = CHECK_SYMBOL(rb_ary_entry(data, i++));
     locals      = CHECK_ARRAY(rb_ary_entry(data, i++));
@@ -343,7 +365,7 @@ iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt)
     }
 
     make_compile_option(&option, opt);
-    prepare_iseq_build(iseq, name, filename,
+    prepare_iseq_build(iseq, name, filename, line_no,
 		       parent, iseq_type, 0, &option);
 
     rb_iseq_build_from_ary(iseq, locals, args, exception, body);

data/ext/cached/ruby-1.9.1/internal/yarv-headers/iseq.h

@@ -82,6 +82,7 @@ struct iseq_compile_data {
     struct iseq_compile_data_storage *storage_head;
     struct iseq_compile_data_storage *storage_current;
     int last_line;
+    int last_coverable_line;
     int flip_cnt;
     int label_no;
     int node_level;

data/ext/cached/ruby-1.9.1/internal/yarv-headers/parse.h

@@ -1,10 +1,9 @@
-
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.4.3.  */
 
 /* Skeleton interface for Bison's Yacc-like parsers in C
    
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+   2009, 2010 Free Software Foundation, Inc.
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -167,16 +166,17 @@
 typedef union YYSTYPE
 {
 
-/* Line 1676 of yacc.c  */
+/* Line 1685 of yacc.c  */
 
     VALUE val;
     NODE *node;
     ID id;
     int num;
+    const struct vtable *vars;
 
 
 
-/* Line 1676 of yacc.c  */
+/* Line 1685 of yacc.c  */
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */

data/ext/cached/ruby-1.9.1/internal/yarv-headers/revision.h

@@ -1 +1 @@
-#define RUBY_REVISION 24175
+#define RUBY_REVISION 30908

data/ext/cached/ruby-1.9.1/internal/yarv-headers/version.h

@@ -1,12 +1,13 @@
 #define RUBY_VERSION "1.9.1"
-#define RUBY_RELEASE_DATE "2009-07-16"
-#define RUBY_PATCHLEVEL 243
+#define RUBY_PATCHLEVEL 431
 #define RUBY_VERSION_MAJOR 1
 #define RUBY_VERSION_MINOR 9
 #define RUBY_VERSION_TEENY 1
-#define RUBY_RELEASE_YEAR 2009
-#define RUBY_RELEASE_MONTH 7
-#define RUBY_RELEASE_DAY 12
+
+#define RUBY_RELEASE_YEAR 2011
+#define RUBY_RELEASE_MONTH 2
+#define RUBY_RELEASE_DAY 18
+#define RUBY_RELEASE_DATE "2011-02-18"
 
 #ifdef RUBY_EXTERN
 RUBY_EXTERN const char ruby_version[];

data/ext/cached/ruby-1.9.1/internal/yarv-headers/vm_core.h

@@ -132,6 +132,7 @@ struct rb_iseq_struct {
     unsigned long iseq_size;
     VALUE mark_ary;	/* Array: includes operands which should be GC marked */
     VALUE coverage;     /* coverage array */
+    unsigned short line_no;
 
     /* insn info, must be freed */
     struct iseq_insn_info_entry *insn_info_table;
@@ -433,8 +434,8 @@ typedef struct rb_thread_struct
 VALUE rb_iseq_new(NODE*, VALUE, VALUE, VALUE, VALUE);
 VALUE rb_iseq_new_top(NODE *node, VALUE name, VALUE filename, VALUE parent);
 VALUE rb_iseq_new_main(NODE *node, VALUE filename);
-VALUE rb_iseq_new_with_bopt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE);
-VALUE rb_iseq_new_with_opt(NODE*, VALUE, VALUE, VALUE, VALUE, const rb_compile_option_t*);
+VALUE rb_iseq_new_with_bopt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+VALUE rb_iseq_new_with_opt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, const rb_compile_option_t*);
 VALUE rb_iseq_compile(VALUE src, VALUE file, VALUE line);
 VALUE rb_iseq_disasm(VALUE self);
 VALUE rb_iseq_disasm_insn(VALUE str, VALUE *iseqval, int pos, rb_iseq_t *iseq, VALUE child);

data/ext/cached/ruby-1.9.1/internal/yarv-headers/vm_insnhelper.h

@@ -41,6 +41,7 @@ enum {
   BOP_DIV,
   BOP_MOD,
   BOP_EQ,
+  BOP_EQQ,
   BOP_LT,
   BOP_LE,
   BOP_LTLT,

data/ext/cached/{ruby-1.9.1/internal/method/method.h → ruby-1.9.2/internal/method/internal_method.h}

@@ -3,17 +3,28 @@
 
 #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 oclass;		/* class that holds the method */
-    VALUE rclass;		/* class of the receiver */
     VALUE recv;
-    ID id, oid;
-    NODE *body;
+    VALUE rclass;
+    ID id;
+    rb_method_entry_t me;
 };
 
-#define METHOD_OCLASS(m) m->oclass
+#define METHOD_OCLASS(m) m->klass
 #define METHOD_RCLASS(m) m->rclass
 
 #endif

data/ext/cached/ruby-1.9.2/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.9.2/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.2/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.9.0 → ruby-1.9.2}/internal/node/node_type_descrip.c

@@ -2,30 +2,28 @@
 #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_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_ATTRASGN, NEN_ARGS, NEN_MID, NEN_RECV, "ATTRASGN" },
-  { NODE_ATTRSET, NEN_VID, NEN_NONE, NEN_NONE, "ATTRSET" },
+  { NODE_AND, NEN_2ND, NEN_1ST, NEN_NONE, "AND" },
+  { NODE_ARGS, NEN_CNT, NEN_REST, NEN_OPT, "ARGS" },
+  { NODE_ARGSCAT, NEN_BODY, NEN_HEAD, NEN_NONE, "ARGSCAT" },
+  { NODE_ARGSPUSH, NEN_BODY, NEN_HEAD, NEN_NONE, "ARGSPUSH" },
+  { NODE_ARRAY, NEN_ALEN, NEN_NEXT, NEN_HEAD, "ARRAY" },
+  { NODE_ATTRASGN, NEN_RECV, NEN_MID, NEN_ARGS, "ATTRASGN" },
   { 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_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_CALL, NEN_RECV, NEN_MID, NEN_ARGS, "CALL" },
+  { NODE_CASE, NEN_BODY, NEN_NEXT, NEN_HEAD, "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_COLON2, NEN_HEAD, NEN_MID, NEN_NONE, "COLON2" },
+  { NODE_CLASS, NEN_BODY, NEN_SUPER, NEN_CPATH, "CLASS" },
+  { NODE_COLON2, NEN_MID, NEN_HEAD, NEN_NONE, "COLON2" },
   { NODE_COLON3, NEN_MID, NEN_NONE, NEN_NONE, "COLON3" },
   { NODE_CONST, NEN_VID, NEN_NONE, NEN_NONE, "CONST" },
   { NODE_CVAR, NEN_VID, NEN_NONE, NEN_NONE, "CVAR" },
@@ -34,56 +32,54 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { 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_DEFN, NEN_MID, NEN_NOEX, "DEFN" },
-  { NODE_DEFS, NEN_DEFN, NEN_MID, NEN_RECV, "DEFS" },
-  { 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_DEFN, NEN_DEFN, NEN_NOEX, NEN_MID, "DEFN" },
+  { NODE_DEFS, NEN_DEFN, NEN_RECV, NEN_MID, "DEFS" },
+  { NODE_DOT2, NEN_END, NEN_STATE, NEN_BEG, "DOT2" },
+  { NODE_DOT3, NEN_END, NEN_STATE, NEN_BEG, "DOT3" },
+  { NODE_DREGX, NEN_CFLAG, NEN_LIT, NEN_NEXT, "DREGX" },
+  { NODE_DREGX_ONCE, NEN_CFLAG, NEN_LIT, NEN_NEXT, "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_LIT, NEN_NEXT, NEN_NONE, "DXSTR" },
-  { NODE_ENSURE, NEN_HEAD, NEN_ENSR, NEN_NONE, "ENSURE" },
+  { NODE_ENSURE, NEN_ENSR, NEN_HEAD, NEN_NONE, "ENSURE" },
   { NODE_EVSTR, NEN_BODY, NEN_NONE, NEN_NONE, "EVSTR" },
   { NODE_FALSE, NEN_NONE, NEN_NONE, NEN_NONE, "FALSE" },
-  { NODE_FBODY, NEN_BODY, NEN_CNT, NEN_OID, "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_FCALL, NEN_MID, NEN_ARGS, NEN_NONE, "FCALL" },
+  { NODE_FLIP2, NEN_CNT, NEN_END, NEN_BEG, "FLIP2" },
+  { NODE_FLIP3, NEN_CNT, NEN_END, NEN_BEG, "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_GASGN, NEN_ENTRY, NEN_VALUE, NEN_VID, "GASGN" },
+  { NODE_GVAR, NEN_ENTRY, NEN_VID, 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_IF, NEN_BODY, NEN_COND, NEN_ELSE, "IF" },
+  { NODE_IFUNC, NEN_CFNC, NEN_STATE, NEN_TVAL, "IFUNC" },
   { NODE_ITER, NEN_BODY, NEN_ITER, NEN_VAR, "ITER" },
   { NODE_IVAR, NEN_VID, NEN_NONE, NEN_NONE, "IVAR" },
-  { NODE_LASGN, NEN_VALUE, NEN_VID, NEN_CNT, "LASGN" },
+  { NODE_LASGN, NEN_CNT, NEN_VALUE, NEN_VID, "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_LVAR, NEN_CNT, NEN_VID, NEN_NONE, "LVAR" },
+  { NODE_MASGN, NEN_VALUE, NEN_ARGS, NEN_HEAD, "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_CLSS, NEN_NOEX, "METHOD" },
-  { NODE_MODULE, NEN_CPATH, NEN_BODY, NEN_NONE, "MODULE" },
+  { NODE_MODULE, NEN_BODY, NEN_CPATH, NEN_NONE, "MODULE" },
   { NODE_NEXT, NEN_STTS, NEN_NONE, NEN_NONE, "NEXT" },
   { NODE_NIL, NEN_NONE, NEN_NONE, NEN_NONE, "NIL" },
   { 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_ASGN1, NEN_RECV, NEN_MID, NEN_ARGS, "OP_ASGN1" },
+  { NODE_OP_ASGN2, NEN_RECV, NEN_NEXT, 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_RECV, NEN_AID, 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_BODY, NEN_ARGS, NEN_HEAD, "RESBODY" },
+  { NODE_RESCUE, NEN_RESQ, NEN_ELSE, NEN_HEAD, "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" },
@@ -96,12 +92,12 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { NODE_TRUE, NEN_NONE, NEN_NONE, NEN_NONE, "TRUE" },
   { NODE_UNDEF, NEN_BODY, NEN_NONE, NEN_NONE, "UNDEF" },
   { NODE_UNTIL, NEN_BODY, NEN_COND, NEN_STATE, "UNTIL" },
-  { NODE_VALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "VALIAS" },
+  { 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_WHEN, NEN_BODY, NEN_NEXT, NEN_HEAD, "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_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" },