ruby-internal 0.7.3 → 0.8.0

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

@@ -2,6 +2,9 @@
 
 #ifdef RUBY_VM
 
+#include "iseq.h"
+#include "vm_core.h"
+
 
 VALUE instruction_class[VM_INSTRUCTION_SIZE];
 

data/ext/cached/ruby-1.8.7/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
+#
 
 #endif
 

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

@@ -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
+
 struct METHOD {
     VALUE oclass;		/* class that holds the method */
     VALUE rclass;		/* class of the receiver */

data/ext/cached/ruby-1.9.1/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/cached/ruby-1.9.1/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.1/internal/node/global_entry.h

@@ -1,10 +1,96 @@
 #ifndef global_entry__h_
 #define global_entry__h_
 
+st_table * rb_global_tbl;
+
+#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;
+};
 struct global_entry {
     struct global_variable *var;
     ID id;
 };
+#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, 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.1/internal/node/node_type_descrip.c

@@ -2,42 +2,42 @@
 #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_CNT, NEN_CFNC, 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_CNT, NEN_OPT, NEN_REST, "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_ATTRASGN, NEN_MID, NEN_RECV, NEN_ARGS, "ATTRASGN" },
   { NODE_ATTRSET, NEN_VID, NEN_NONE, NEN_NONE, "ATTRSET" },
-  { NODE_BACK_REF, NEN_NTH, NEN_CNT, NEN_NONE, "BACK_REF" },
+  { NODE_BACK_REF, NEN_CNT, NEN_NTH, NEN_NONE, "BACK_REF" },
   { NODE_BEGIN, NEN_BODY, NEN_NONE, NEN_NONE, "BEGIN" },
   { NODE_BLOCK, NEN_HEAD, NEN_NEXT, 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_CALL, NEN_MID, NEN_RECV, NEN_ARGS, "CALL" },
   { NODE_CASE, NEN_HEAD, NEN_BODY, NEN_NEXT, "CASE" },
-  { NODE_CDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CDECL" },
+  { NODE_CDECL, NEN_VID, NEN_VALUE, NEN_NONE, "CDECL" },
   { NODE_CFUNC, NEN_CFNC, NEN_ARGC, NEN_NONE, "CFUNC" },
-  { NODE_CLASS, NEN_CPATH, NEN_BODY, NEN_SUPER, "CLASS" },
+  { NODE_CLASS, NEN_BODY, NEN_SUPER, NEN_CPATH, "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_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_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_DEFN, NEN_MID, NEN_DEFN, NEN_NOEX, "DEFN" },
+  { NODE_DEFS, NEN_MID, NEN_DEFN, NEN_RECV, "DEFS" },
+  { NODE_DOT2, NEN_END, NEN_STATE, NEN_BEG, "DOT2" },
+  { NODE_DOT3, NEN_END, NEN_STATE, NEN_BEG, "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" },
@@ -47,47 +47,45 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { 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_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_FOR, NEN_BODY, NEN_ITER, NEN_VAR, "FOR" },
-  { NODE_GASGN, NEN_VALUE, NEN_VID, NEN_ENTRY, "GASGN" },
+  { 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_ITER, NEN_BODY, NEN_VAR, "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_BODY, NEN_COND, NEN_ELSE, "IF" },
+  { NODE_IFUNC, NEN_STATE, NEN_CFNC, NEN_TVAL, "IFUNC" },
+  { NODE_ITER, NEN_ITER, NEN_BODY, 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_VID, 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_LVAR, NEN_CNT, NEN_VID, NEN_NONE, "LVAR" },
+  { NODE_MASGN, NEN_HEAD, NEN_ARGS, 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_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_NTH_REF, NEN_CNT, NEN_NTH, 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_MID, NEN_RECV, NEN_ARGS, "OP_ASGN1" },
+  { NODE_OP_ASGN2, NEN_RECV, NEN_NEXT, NEN_VALUE, "OP_ASGN2" },
+  { NODE_OP_ASGN2_ARG, NEN_MID, NEN_VID, NEN_AID, "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_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_TBL, NEN_RVAL, NEN_NEXT, "SCOPE" },
+  { NODE_SCOPE, NEN_RVAL, NEN_TBL, 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" },
@@ -95,11 +93,11 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { 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_COND, NEN_STATE, "UNTIL" },
-  { NODE_VALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "VALIAS" },
+  { NODE_UNTIL, NEN_STATE, NEN_BODY, NEN_COND, "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_WHILE, NEN_STATE, NEN_BODY, NEN_COND, "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" },

data/ext/cached/ruby-1.9.1/internal/node/nodeinfo.c

@@ -228,7 +228,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
           else
           {
             path = rb_class_path(klass);
-            if(STR2CSTR(path)[0] == '#')
+            if(StringValuePtr(path)[0] == '#')
             {
               rb_raise(rb_eArgError, "cannot dump anonymous class");
             }
@@ -322,7 +322,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
           else
           {
             path = rb_class_path(klass);
-            if(STR2CSTR(path)[0] == '#')
+            if(StringValuePtr(path)[0] == '#')
             {
               rb_raise(rb_eArgError, "cannot dump anonymous class");
             }
@@ -521,7 +521,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
           else
           {
             path = rb_class_path(klass);
-            if(STR2CSTR(path)[0] == '#')
+            if(StringValuePtr(path)[0] == '#')
             {
               rb_raise(rb_eArgError, "cannot dump anonymous class");
             }
@@ -658,7 +658,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
           else
           {
             path = rb_class_path(klass);
-            if(STR2CSTR(path)[0] == '#')
+            if(StringValuePtr(path)[0] == '#')
             {
               rb_raise(rb_eArgError, "cannot dump anonymous class");
             }
@@ -872,7 +872,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
           else
           {
             path = rb_class_path(klass);
-            if(STR2CSTR(path)[0] == '#')
+            if(StringValuePtr(path)[0] == '#')
             {
               rb_raise(rb_eArgError, "cannot dump anonymous class");
             }
@@ -1131,20 +1131,23 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_CLSS:
     {
+      int flags;
       Check_Type(v, T_ARRAY);
       if(RARRAY_LEN(v) != 2)
       {
         rb_raise(rb_eArgError, "wrong size for array");
       }
-      int flags = NUM2INT(RARRAY_PTR(v)[0]);
+      flags = NUM2INT(RARRAY_PTR(v)[0]);
       switch(flags & T_MASK)
       {
         case T_CLASS:
         case T_MODULE:
         {
-          VALUE str = RARRAY_PTR(v)[1];
+          VALUE str, klass;
+
+          str = RARRAY_PTR(v)[1];
           Check_Type(str, T_STRING);
-          VALUE klass = rb_path2class(STR2CSTR(str));
+          klass = rb_path2class(StringValuePtr(str));
           if(flags & FL_SINGLETON)
           {
             *(VALUE *)(&n->nd_clss) =
@@ -1220,20 +1223,23 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_CVAL:
     {
+      int flags;
       Check_Type(v, T_ARRAY);
       if(RARRAY_LEN(v) != 2)
       {
         rb_raise(rb_eArgError, "wrong size for array");
       }
-      int flags = NUM2INT(RARRAY_PTR(v)[0]);
+      flags = NUM2INT(RARRAY_PTR(v)[0]);
       switch(flags & T_MASK)
       {
         case T_CLASS:
         case T_MODULE:
         {
-          VALUE str = RARRAY_PTR(v)[1];
+          VALUE str, klass;
+
+          str = RARRAY_PTR(v)[1];
           Check_Type(str, T_STRING);
-          VALUE klass = rb_path2class(STR2CSTR(str));
+          klass = rb_path2class(StringValuePtr(str));
           if(flags & FL_SINGLETON)
           {
             *(VALUE *)(&n->nd_cval) =
@@ -1414,20 +1420,23 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_LIT:
     {
+      int flags;
       Check_Type(v, T_ARRAY);
       if(RARRAY_LEN(v) != 2)
       {
         rb_raise(rb_eArgError, "wrong size for array");
       }
-      int flags = NUM2INT(RARRAY_PTR(v)[0]);
+      flags = NUM2INT(RARRAY_PTR(v)[0]);
       switch(flags & T_MASK)
       {
         case T_CLASS:
         case T_MODULE:
         {
-          VALUE str = RARRAY_PTR(v)[1];
+          VALUE str, klass;
+
+          str = RARRAY_PTR(v)[1];
           Check_Type(str, T_STRING);
-          VALUE klass = rb_path2class(STR2CSTR(str));
+          klass = rb_path2class(StringValuePtr(str));
           if(flags & FL_SINGLETON)
           {
             *(VALUE *)(&n->nd_lit) =
@@ -1556,20 +1565,23 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_ORIG:
     {
+      int flags;
       Check_Type(v, T_ARRAY);
       if(RARRAY_LEN(v) != 2)
       {
         rb_raise(rb_eArgError, "wrong size for array");
       }
-      int flags = NUM2INT(RARRAY_PTR(v)[0]);
+      flags = NUM2INT(RARRAY_PTR(v)[0]);
       switch(flags & T_MASK)
       {
         case T_CLASS:
         case T_MODULE:
         {
-          VALUE str = RARRAY_PTR(v)[1];
+          VALUE str, klass;
+
+          str = RARRAY_PTR(v)[1];
           Check_Type(str, T_STRING);
-          VALUE klass = rb_path2class(STR2CSTR(str));
+          klass = rb_path2class(StringValuePtr(str));
           if(flags & FL_SINGLETON)
           {
             *(VALUE *)(&n->nd_orig) =
@@ -1808,20 +1820,23 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_TVAL:
     {
+      int flags;
       Check_Type(v, T_ARRAY);
       if(RARRAY_LEN(v) != 2)
       {
         rb_raise(rb_eArgError, "wrong size for array");
       }
-      int flags = NUM2INT(RARRAY_PTR(v)[0]);
+      flags = NUM2INT(RARRAY_PTR(v)[0]);
       switch(flags & T_MASK)
       {
         case T_CLASS:
         case T_MODULE:
         {
-          VALUE str = RARRAY_PTR(v)[1];
+          VALUE str, klass;
+
+          str = RARRAY_PTR(v)[1];
           Check_Type(str, T_STRING);
-          VALUE klass = rb_path2class(STR2CSTR(str));
+          klass = rb_path2class(StringValuePtr(str));
           if(flags & FL_SINGLETON)
           {
             *(VALUE *)(&n->nd_tval) =
@@ -2107,33 +2122,6 @@ static VALUE node_cfnc(VALUE self)
   Data_Get_Struct(self, NODE, n);
   return LONG2NUM((long)(n->nd_cfnc));
 }
-/*
- * Return the Node's _clss_ member.  The return type is
- * either a Node or an Object.
- */
-static VALUE node_clss(VALUE self)
-{
-  NODE * n;
-  Data_Get_Struct(self, NODE, n);
-
-  if(TYPE(n->nd_clss) == T_NODE)
-  {
-    if(0 && nd_type(n) == NODE_OP_ASGN2)
-    {
-      return wrap_node_as(
-        (NODE *)n->nd_clss,
-        rb_cNodeSubclass[NODE_OP_ASGN2_ARG]);
-    }
-    else
-    {
-      return wrap_node((NODE *)n->nd_clss);
-    }
-  }
-  else
-  {
-    return (VALUE)n->nd_clss;
-  }
-}
 /*
  * Return the Node's _cnt_ member.  The return type is an
  * Integer.
@@ -2499,27 +2487,6 @@ static VALUE node_nth(VALUE self)
   Data_Get_Struct(self, NODE, n);
   return LONG2NUM(n->nd_nth);
 }
-/*
- * Return the Node's _oid_ member.  The return type is a
- * Symbol.
- */
-static VALUE node_oid(VALUE self)
-{
-  NODE * n;
-  Data_Get_Struct(self, NODE, n);
-  if(n->nd_oid == 0)
-  {
-    return Qfalse;
-  }
-  else if(n->nd_oid == 1)
-  {
-    return Qtrue;
-  }
-  else
-  {
-    return ID2SYM(n->nd_oid);
-  }
-}
 /*
  * Return the Node's _opt_ member.  The return type is
  * either a Node or an Object.
@@ -2865,10 +2832,10 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cALIAS, "__member__", members);
     rb_iv_set(rb_cALIAS, "__type__", INT2NUM(NODE_ALIAS));
     rb_define_singleton_method(rb_cALIAS, "members", node_s_members, 0);
-    rb_define_method(rb_cALIAS, "first", node_1st, 0);
-    rb_ary_push(members, rb_str_new2("first"));
     rb_define_method(rb_cALIAS, "second", node_2nd, 0);
     rb_ary_push(members, rb_str_new2("second"));
+    rb_define_method(rb_cALIAS, "first", node_1st, 0);
+    rb_ary_push(members, rb_str_new2("first"));
   }
 
   /* Document-class: Node::ALLOCA
@@ -2886,6 +2853,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cALLOCA, "__type__", INT2NUM(NODE_ALLOCA));
     rb_define_singleton_method(rb_cALLOCA, "members", node_s_members, 0);
 
+    /* Document-method: cnt
+     * the number of bytes allocated
+     */
+    rb_define_method(rb_cALLOCA, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
+
     /* Document-method: cfnc
      * a pointer to the allocated memory
      */
@@ -2897,12 +2870,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cALLOCA, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
-
-    /* Document-method: cnt
-     * the number of bytes allocated
-     */
-    rb_define_method(rb_cALLOCA, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
   }
 #endif
 
@@ -2921,17 +2888,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cAND, "__type__", INT2NUM(NODE_AND));
     rb_define_singleton_method(rb_cAND, "members", node_s_members, 0);
 
-    /* Document-method: first
-     * the expression on the left hand side
-     */
-    rb_define_method(rb_cAND, "first", node_1st, 0);
-    rb_ary_push(members, rb_str_new2("first"));
-
     /* Document-method: second
      * the expression on the right hand side
      */
     rb_define_method(rb_cAND, "second", node_2nd, 0);
     rb_ary_push(members, rb_str_new2("second"));
+
+    /* Document-method: first
+     * the expression on the left hand side
+     */
+    rb_define_method(rb_cAND, "first", node_1st, 0);
+    rb_ary_push(members, rb_str_new2("first"));
   }
 
   /* Document-class: Node::ARGS
@@ -2945,11 +2912,11 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cARGS, "__type__", INT2NUM(NODE_ARGS));
     rb_define_singleton_method(rb_cARGS, "members", node_s_members, 0);
 
-    /* Document-method: rest
-     * an assignment node to assign the rest arg, if it is present
+    /* Document-method: cnt
+     * the number of required arguments
      */
-    rb_define_method(rb_cARGS, "rest", node_rest, 0);
-    rb_ary_push(members, rb_str_new2("rest"));
+    rb_define_method(rb_cARGS, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: opt
      * a list of assignment nodes to assign default values to the
@@ -2958,11 +2925,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cARGS, "opt", node_opt, 0);
     rb_ary_push(members, rb_str_new2("opt"));
 
-    /* Document-method: cnt
-     * the number of required arguments
+    /* Document-method: rest
+     * an assignment node to assign the rest arg, if it is present
      */
-    rb_define_method(rb_cARGS, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
+    rb_define_method(rb_cARGS, "rest", node_rest, 0);
+    rb_ary_push(members, rb_str_new2("rest"));
   }
 
   /* Document-class: Node::ARGSCAT
@@ -3058,12 +3025,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cATTRASGN, "__type__", INT2NUM(NODE_ATTRASGN));
     rb_define_singleton_method(rb_cATTRASGN, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the method
-     */
-    rb_define_method(rb_cATTRASGN, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * the id of the attribute, with a trailing '=' sign
      */
@@ -3075,6 +3036,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cATTRASGN, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* Document-method: args
+     * the arguments to the method
+     */
+    rb_define_method(rb_cATTRASGN, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::ATTRSET
@@ -3113,19 +3080,19 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cBACK_REF, "__type__", INT2NUM(NODE_BACK_REF));
     rb_define_singleton_method(rb_cBACK_REF, "members", node_s_members, 0);
 
-    /* Document-method: nth
-     * the integer representation of the character of the variable to
-     * reference, one of '&', '`', '\'', or '+'
-     */
-    rb_define_method(rb_cBACK_REF, "nth", node_nth, 0);
-    rb_ary_push(members, rb_str_new2("nth"));
-
     /* Document-method: cnt
      * the index into the local variable table where the match data is
      * stored
      */
     rb_define_method(rb_cBACK_REF, "cnt", node_cnt, 0);
     rb_ary_push(members, rb_str_new2("cnt"));
+
+    /* Document-method: nth
+     * the integer representation of the character of the variable to
+     * reference, one of '&', '`', '\'', or '+'
+     */
+    rb_define_method(rb_cBACK_REF, "nth", node_nth, 0);
+    rb_ary_push(members, rb_str_new2("nth"));
   }
 
   /* Document-class: Node::BEGIN
@@ -3213,17 +3180,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cBLOCK_PASS, "__type__", INT2NUM(NODE_BLOCK_PASS));
     rb_define_singleton_method(rb_cBLOCK_PASS, "members", node_s_members, 0);
 
-    /* Document-method: body
-     * the object to pass as a block
-     */
-    rb_define_method(rb_cBLOCK_PASS, "body", node_body, 0);
-    rb_ary_push(members, rb_str_new2("body"));
-
     /* Document-method: iter
      * an expression which calls a method
      */
     rb_define_method(rb_cBLOCK_PASS, "iter", node_iter, 0);
     rb_ary_push(members, rb_str_new2("iter"));
+
+    /* Document-method: body
+     * the object to pass as a block
+     */
+    rb_define_method(rb_cBLOCK_PASS, "body", node_body, 0);
+    rb_ary_push(members, rb_str_new2("body"));
   }
 
   /* Document-class: Node::BMETHOD
@@ -3280,12 +3247,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCALL, "__type__", INT2NUM(NODE_CALL));
     rb_define_singleton_method(rb_cCALL, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the method
-     */
-    rb_define_method(rb_cCALL, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * the method id
      */
@@ -3297,6 +3258,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cCALL, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* Document-method: args
+     * the arguments to the method
+     */
+    rb_define_method(rb_cCALL, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::CASE
@@ -3342,17 +3309,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCDECL, "__type__", INT2NUM(NODE_CDECL));
     rb_define_singleton_method(rb_cCDECL, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * the value to be assigned to the constant
-     */
-    rb_define_method(rb_cCDECL, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
-
     /* Document-method: vid
      * the name of the constant to be assigned, all uppercase
      */
     rb_define_method(rb_cCDECL, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
+
+    /* Document-method: value
+     * the value to be assigned to the constant
+     */
+    rb_define_method(rb_cCDECL, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::CFUNC
@@ -3395,12 +3362,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCLASS, "__type__", INT2NUM(NODE_CLASS));
     rb_define_singleton_method(rb_cCLASS, "members", node_s_members, 0);
 
-    /* Document-method: cpath
-     * the name of the class to define
-     */
-    rb_define_method(rb_cCLASS, "cpath", node_cpath, 0);
-    rb_ary_push(members, rb_str_new2("cpath"));
-
     /* Document-method: body
      * the body of the class definition
      */
@@ -3413,6 +3374,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cCLASS, "super", node_super, 0);
     rb_ary_push(members, rb_str_new2("super"));
+
+    /* Document-method: cpath
+     * the name of the class to define
+     */
+    rb_define_method(rb_cCLASS, "cpath", node_cpath, 0);
+    rb_ary_push(members, rb_str_new2("cpath"));
   }
 
   /* Document-class: Node::COLON2
@@ -3514,18 +3481,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCVASGN, "__type__", INT2NUM(NODE_CVASGN));
     rb_define_singleton_method(rb_cCVASGN, "members", node_s_members, 0);
 
+    /* Document-method: vid
+     * the name of the class variable to assign
+     */
+    rb_define_method(rb_cCVASGN, "vid", node_vid, 0);
+    rb_ary_push(members, rb_str_new2("vid"));
+
     /* Document-method: value
      * an expression whose result is the new value of the class
      * variable
      */
     rb_define_method(rb_cCVASGN, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
-
-    /* Document-method: vid
-     * the name of the class variable to assign
-     */
-    rb_define_method(rb_cCVASGN, "vid", node_vid, 0);
-    rb_ary_push(members, rb_str_new2("vid"));
   }
 
   /* Document-class: Node::CVDECL
@@ -3541,18 +3508,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCVDECL, "__type__", INT2NUM(NODE_CVDECL));
     rb_define_singleton_method(rb_cCVDECL, "members", node_s_members, 0);
 
+    /* Document-method: vid
+     * the name of the class variable to assign
+     */
+    rb_define_method(rb_cCVDECL, "vid", node_vid, 0);
+    rb_ary_push(members, rb_str_new2("vid"));
+
     /* Document-method: value
      * an expression whose result is the new value of the class
      * variable
      */
     rb_define_method(rb_cCVDECL, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
-
-    /* Document-method: vid
-     * the name of the class variable to assign
-     */
-    rb_define_method(rb_cCVDECL, "vid", node_vid, 0);
-    rb_ary_push(members, rb_str_new2("vid"));
   }
 
   /* Document-class: Node::DASGN
@@ -3575,17 +3542,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDASGN, "__type__", INT2NUM(NODE_DASGN));
     rb_define_singleton_method(rb_cDASGN, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * the value to assign to the local variable
-     */
-    rb_define_method(rb_cDASGN, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
-
     /* Document-method: vid
      * the name of the local variable
      */
     rb_define_method(rb_cDASGN, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
+
+    /* Document-method: value
+     * the value to assign to the local variable
+     */
+    rb_define_method(rb_cDASGN, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::DASGN_CURR
@@ -3600,17 +3567,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDASGN_CURR, "__type__", INT2NUM(NODE_DASGN_CURR));
     rb_define_singleton_method(rb_cDASGN_CURR, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * the value to assign to the local variable
-     */
-    rb_define_method(rb_cDASGN_CURR, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
-
     /* Document-method: vid
      * the name of the local variable
      */
     rb_define_method(rb_cDASGN_CURR, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
+
+    /* Document-method: value
+     * the value to assign to the local variable
+     */
+    rb_define_method(rb_cDASGN_CURR, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::DEFINED
@@ -3646,18 +3613,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDEFN, "__type__", INT2NUM(NODE_DEFN));
     rb_define_singleton_method(rb_cDEFN, "members", node_s_members, 0);
 
-    /* Document-method: defn
-     * the body of the method definition
-     */
-    rb_define_method(rb_cDEFN, "defn", node_defn, 0);
-    rb_ary_push(members, rb_str_new2("defn"));
-
     /* Document-method: mid
      * the name of the method* defn the body of the method
      */
     rb_define_method(rb_cDEFN, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
 
+    /* Document-method: defn
+     * the body of the method definition
+     */
+    rb_define_method(rb_cDEFN, "defn", node_defn, 0);
+    rb_ary_push(members, rb_str_new2("defn"));
+
     /* Document-method: noex
      * the flags which should be used to define the method
      */
@@ -3678,14 +3645,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDEFS, "__member__", members);
     rb_iv_set(rb_cDEFS, "__type__", INT2NUM(NODE_DEFS));
     rb_define_singleton_method(rb_cDEFS, "members", node_s_members, 0);
-    rb_define_method(rb_cDEFS, "defn", node_defn, 0);
-    rb_ary_push(members, rb_str_new2("defn"));
 
     /* Document-method: mid
      * the name of the method* defn the body of the method
      */
     rb_define_method(rb_cDEFS, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
+    rb_define_method(rb_cDEFS, "defn", node_defn, 0);
+    rb_ary_push(members, rb_str_new2("defn"));
 
     /* Document-method: recv
      * the object to whose singleton class the new method is to be  added
@@ -3707,12 +3674,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDOT2, "__type__", INT2NUM(NODE_DOT2));
     rb_define_singleton_method(rb_cDOT2, "members", node_s_members, 0);
 
-    /* Document-method: beg
-     * the beginning of the range
-     */
-    rb_define_method(rb_cDOT2, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
-
     /* Document-method: end
      * the end of the range
      */
@@ -3720,6 +3681,12 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("end"));
     rb_define_method(rb_cDOT2, "state", node_state, 0);
     rb_ary_push(members, rb_str_new2("state"));
+
+    /* Document-method: beg
+     * the beginning of the range
+     */
+    rb_define_method(rb_cDOT2, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::DOT3
@@ -3735,12 +3702,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDOT3, "__type__", INT2NUM(NODE_DOT3));
     rb_define_singleton_method(rb_cDOT3, "members", node_s_members, 0);
 
-    /* Document-method: beg
-     * the beginning of the range
-     */
-    rb_define_method(rb_cDOT3, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
-
     /* Document-method: end
      * the end of the range
      */
@@ -3748,6 +3709,12 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("end"));
     rb_define_method(rb_cDOT3, "state", node_state, 0);
     rb_ary_push(members, rb_str_new2("state"));
+
+    /* Document-method: beg
+     * the beginning of the range
+     */
+    rb_define_method(rb_cDOT3, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::DREGX
@@ -4003,64 +3970,32 @@ void define_node_subclass_methods()
     rb_define_singleton_method(rb_cFALSE, "members", node_s_members, 0);
   }
 
-  /* Document-class: Node::FBODY
-   * A placeholder for a method alias, which can be added to a class by
-   * using alias or alias_method:
-   *   alias old new
+  /* Document-class: Node::FCALL
+   * Represents a method call in the form:
+   *   mid(args).
+   * 
+   * This makes a method call on an object using self as the implicit
+   * receiver.
    */
   {
-    VALUE rb_cFBODY = rb_define_class_under(rb_cNode, "FBODY", rb_cNode);
-    members = rb_ary_new();
-    rb_cNodeSubclass[NODE_FBODY] = rb_cFBODY;
-    rb_iv_set(rb_cFBODY, "__member__", members);
-    rb_iv_set(rb_cFBODY, "__type__", INT2NUM(NODE_FBODY));
-    rb_define_singleton_method(rb_cFBODY, "members", node_s_members, 0);
-
-    /* Document-method: body
-     * the method body
-     */
-    rb_define_method(rb_cFBODY, "body", node_body, 0);
-    rb_ary_push(members, rb_str_new2("body"));
-
-    /* Document-method: cnt
-     * the method's flags
-     */
-    rb_define_method(rb_cFBODY, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
-
-    /* Document-method: oid
-     * the original name of the method
-     */
-    rb_define_method(rb_cFBODY, "oid", node_oid, 0);
-    rb_ary_push(members, rb_str_new2("oid"));
-  }
-
-  /* Document-class: Node::FCALL
-   * Represents a method call in the form:
-   *   mid(args).
-   * 
-   * This makes a method call on an object using self as the implicit
-   * receiver.
-   */
-  {
-    VALUE rb_cFCALL = rb_define_class_under(rb_cNode, "FCALL", rb_cNode);
+    VALUE rb_cFCALL = rb_define_class_under(rb_cNode, "FCALL", rb_cNode);
     members = rb_ary_new();
     rb_cNodeSubclass[NODE_FCALL] = rb_cFCALL;
     rb_iv_set(rb_cFCALL, "__member__", members);
     rb_iv_set(rb_cFCALL, "__type__", INT2NUM(NODE_FCALL));
     rb_define_singleton_method(rb_cFCALL, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the method
-     */
-    rb_define_method(rb_cFCALL, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * the method id
      */
     rb_define_method(rb_cFCALL, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
+
+    /* Document-method: args
+     * the arguments to the method
+     */
+    rb_define_method(rb_cFCALL, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::FLIP2
@@ -4077,11 +4012,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cFLIP2, "__type__", INT2NUM(NODE_FLIP2));
     rb_define_singleton_method(rb_cFLIP2, "members", node_s_members, 0);
 
-    /* Document-method: beg
-     * the beginning of the range
+    /* Document-method: cnt
+     * the index into the local variable table of the special variable
+     * to use in the flip-flop expression (usually 2 for $_)
      */
-    rb_define_method(rb_cFLIP2, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
+    rb_define_method(rb_cFLIP2, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: end
      * the end of the range
@@ -4089,12 +4025,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cFLIP2, "end", node_end, 0);
     rb_ary_push(members, rb_str_new2("end"));
 
-    /* Document-method: cnt
-     * the index into the local variable table of the special variable
-     * to use in the flip-flop expression (usually 2 for $_)
+    /* Document-method: beg
+     * the beginning of the range
      */
-    rb_define_method(rb_cFLIP2, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
+    rb_define_method(rb_cFLIP2, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::FLIP3
@@ -4111,11 +4046,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cFLIP3, "__type__", INT2NUM(NODE_FLIP3));
     rb_define_singleton_method(rb_cFLIP3, "members", node_s_members, 0);
 
-    /* Document-method: beg
-     * the beginning of the range
+    /* Document-method: cnt
+     * the index into the local variable table of the special variable
+     * to use in the flip-flop expression (usually 2 for $_)
      */
-    rb_define_method(rb_cFLIP3, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
+    rb_define_method(rb_cFLIP3, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: end
      * the end of the range
@@ -4123,12 +4059,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cFLIP3, "end", node_end, 0);
     rb_ary_push(members, rb_str_new2("end"));
 
-    /* Document-method: cnt
-     * the index into the local variable table of the special variable
-     * to use in the flip-flop expression (usually 2 for $_)
+    /* Document-method: beg
+     * the beginning of the range
      */
-    rb_define_method(rb_cFLIP3, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
+    rb_define_method(rb_cFLIP3, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::FOR
@@ -4153,18 +4088,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cFOR, "__type__", INT2NUM(NODE_FOR));
     rb_define_singleton_method(rb_cFOR, "members", node_s_members, 0);
 
-    /* Document-method: body
-     * the body of the loop
-     */
-    rb_define_method(rb_cFOR, "body", node_body, 0);
-    rb_ary_push(members, rb_str_new2("body"));
-
     /* Document-method: iter
      * the sequence over which to iterate
      */
     rb_define_method(rb_cFOR, "iter", node_iter, 0);
     rb_ary_push(members, rb_str_new2("iter"));
 
+    /* Document-method: body
+     * the body of the loop
+     */
+    rb_define_method(rb_cFOR, "body", node_body, 0);
+    rb_ary_push(members, rb_str_new2("body"));
+
     /* Document-method: var
      * an assignment node which assigns the next value in the sequence
      * to a variable, which may or may not be local.  May also be a
@@ -4185,12 +4120,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cGASGN, "__type__", INT2NUM(NODE_GASGN));
     rb_define_singleton_method(rb_cGASGN, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * an expression whose result is the new value of the global variable
-     */
-    rb_define_method(rb_cGASGN, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
-
     /* Document-method: vid
      * the name of the global variable, with a leading '$' character.
      */
@@ -4198,6 +4127,12 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("vid"));
     rb_define_method(rb_cGASGN, "entry", node_entry, 0);
     rb_ary_push(members, rb_str_new2("entry"));
+
+    /* Document-method: value
+     * an expression whose result is the new value of the global variable
+     */
+    rb_define_method(rb_cGASGN, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::GVAR
@@ -4250,17 +4185,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cIASGN, "__type__", INT2NUM(NODE_IASGN));
     rb_define_singleton_method(rb_cIASGN, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * the value to assign to the instance variable
-     */
-    rb_define_method(rb_cIASGN, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
-
     /* Document-method: vid
      * the name of the instance variable, with a leading '@' sign
      */
     rb_define_method(rb_cIASGN, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
+
+    /* Document-method: value
+     * the value to assign to the instance variable
+     */
+    rb_define_method(rb_cIASGN, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::IF
@@ -4292,12 +4227,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cIF, "__type__", INT2NUM(NODE_IF));
     rb_define_singleton_method(rb_cIF, "members", node_s_members, 0);
 
-    /* Document-method: cond
-     * the condition to evaluate
-     */
-    rb_define_method(rb_cIF, "cond", node_cond, 0);
-    rb_ary_push(members, rb_str_new2("cond"));
-
     /* Document-method: body
      * the expression to evaluate if the expression is true, or false
      * if the expression is empty
@@ -4305,6 +4234,12 @@ void define_node_subclass_methods()
     rb_define_method(rb_cIF, "body", node_body, 0);
     rb_ary_push(members, rb_str_new2("body"));
 
+    /* Document-method: cond
+     * the condition to evaluate
+     */
+    rb_define_method(rb_cIF, "cond", node_cond, 0);
+    rb_ary_push(members, rb_str_new2("cond"));
+
     /* Document-method: else
      * the expression to evaluate if the expression is false, or false
      * if the expression is empty
@@ -4324,6 +4259,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cIFUNC, "__type__", INT2NUM(NODE_IFUNC));
     rb_define_singleton_method(rb_cIFUNC, "members", node_s_members, 0);
 
+    /* Document-method: state
+     * always 0
+     */
+    rb_define_method(rb_cIFUNC, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
+
     /* Document-method: cfnc
      * a pointer to the C function to which to yield
      */
@@ -4336,12 +4277,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cIFUNC, "tval", node_tval, 0);
     rb_ary_push(members, rb_str_new2("tval"));
-
-    /* Document-method: state
-     * always 0
-     */
-    rb_define_method(rb_cIFUNC, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
   }
 
   /* Document-class: Node::ITER
@@ -4365,12 +4300,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cITER, "__type__", INT2NUM(NODE_ITER));
     rb_define_singleton_method(rb_cITER, "members", node_s_members, 0);
 
-    /* Document-method: body
-     * the body of the loop
-     */
-    rb_define_method(rb_cITER, "body", node_body, 0);
-    rb_ary_push(members, rb_str_new2("body"));
-
     /* Document-method: iter
      * an expression which calls the desired iteration method, usually
      * recv.each
@@ -4378,6 +4307,12 @@ void define_node_subclass_methods()
     rb_define_method(rb_cITER, "iter", node_iter, 0);
     rb_ary_push(members, rb_str_new2("iter"));
 
+    /* Document-method: body
+     * the body of the loop
+     */
+    rb_define_method(rb_cITER, "body", node_body, 0);
+    rb_ary_push(members, rb_str_new2("body"));
+
     /* Document-method: var
      * an assignment node which assigns the next value in the sequence
      * to a variable, which may or may not be local.  May also be a
@@ -4418,20 +4353,20 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cLASGN, "__member__", members);
     rb_iv_set(rb_cLASGN, "__type__", INT2NUM(NODE_LASGN));
     rb_define_singleton_method(rb_cLASGN, "members", node_s_members, 0);
-
-    /* Document-method: value
-     * the value to assign to the local variable
-     */
-    rb_define_method(rb_cLASGN, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
+    rb_define_method(rb_cLASGN, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: vid
      * the name of the local variable
      */
     rb_define_method(rb_cLASGN, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
-    rb_define_method(rb_cLASGN, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
+
+    /* Document-method: value
+     * the value to assign to the local variable
+     */
+    rb_define_method(rb_cLASGN, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::LIT
@@ -4463,14 +4398,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cLVAR, "__member__", members);
     rb_iv_set(rb_cLVAR, "__type__", INT2NUM(NODE_LVAR));
     rb_define_singleton_method(rb_cLVAR, "members", node_s_members, 0);
+    rb_define_method(rb_cLVAR, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: vid
      * the name of the local variable to retrieve.
      */
     rb_define_method(rb_cLVAR, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
-    rb_define_method(rb_cLVAR, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
   }
 
   /* Document-class: Node::MASGN
@@ -4484,18 +4419,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMASGN, "__type__", INT2NUM(NODE_MASGN));
     rb_define_singleton_method(rb_cMASGN, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * TODO
-     */
-    rb_define_method(rb_cMASGN, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: head
      * TODO
      */
     rb_define_method(rb_cMASGN, "head", node_head, 0);
     rb_ary_push(members, rb_str_new2("head"));
 
+    /* Document-method: args
+     * TODO
+     */
+    rb_define_method(rb_cMASGN, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
+
     /* Document-method: value
      * TODO
      */
@@ -4563,6 +4498,13 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMATCH2, "__type__", INT2NUM(NODE_MATCH2));
     rb_define_singleton_method(rb_cMATCH2, "members", node_s_members, 0);
 
+    /* Document-method: recv
+     * the regular expression on the left hand side of the match
+     * operator
+     */
+    rb_define_method(rb_cMATCH2, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
+
     /* Document-method: value
      * the expression on the right hand side of the match operator, or
      * an expression returning $_ if there is nothing on the right hand
@@ -4570,13 +4512,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cMATCH2, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
-
-    /* Document-method: recv
-     * the regular expression on the left hand side of the match
-     * operator
-     */
-    rb_define_method(rb_cMATCH2, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::MATCH3
@@ -4594,17 +4529,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMATCH3, "__type__", INT2NUM(NODE_MATCH3));
     rb_define_singleton_method(rb_cMATCH3, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * the right hand side of the match
-     */
-    rb_define_method(rb_cMATCH3, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
-
     /* Document-method: recv
      * the left hand side of the match
      */
     rb_define_method(rb_cMATCH3, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* Document-method: value
+     * the right hand side of the match
+     */
+    rb_define_method(rb_cMATCH3, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::MEMO
@@ -4630,42 +4565,6 @@ void define_node_subclass_methods()
     rb_define_singleton_method(rb_cMEMO, "members", node_s_members, 0);
   }
 
-  /* Document-class: Node::METHOD
-   * A placeholder for a method entry in a class's method table.
-   * 
-   * On ruby 1.9 this node type is also known as RUBY_VM_METHOD_NODE.
-   * Its use differs from that of NODE_METHOD in that it is used as the
-   * body of another METHOD node and is used to store the method's
-   * instruction sequence.
-   */
-  {
-    VALUE rb_cMETHOD = rb_define_class_under(rb_cNode, "METHOD", rb_cNode);
-    members = rb_ary_new();
-    rb_cNodeSubclass[NODE_METHOD] = rb_cMETHOD;
-    rb_iv_set(rb_cMETHOD, "__member__", members);
-    rb_iv_set(rb_cMETHOD, "__type__", INT2NUM(NODE_METHOD));
-    rb_define_singleton_method(rb_cMETHOD, "members", node_s_members, 0);
-
-    /* Document-method: body
-     * the body of the method
-     */
-    rb_define_method(rb_cMETHOD, "body", node_body, 0);
-    rb_ary_push(members, rb_str_new2("body"));
-
-    /* Document-method: clss
-     * the class to which the method was added or the instruction
-     * sequence used to implement this method
-     */
-    rb_define_method(rb_cMETHOD, "clss", node_clss, 0);
-    rb_ary_push(members, rb_str_new2("clss"));
-
-    /* Document-method: noex
-     * the method's flags
-     */
-    rb_define_method(rb_cMETHOD, "noex", node_noex, 0);
-    rb_ary_push(members, rb_str_new2("noex"));
-  }
-
   /* Document-class: Node::MODULE
    * Represents a module definition, e.g.:
    *   module cpath
@@ -4685,17 +4584,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMODULE, "__type__", INT2NUM(NODE_MODULE));
     rb_define_singleton_method(rb_cMODULE, "members", node_s_members, 0);
 
-    /* Document-method: cpath
-     * the name of the module to define
-     */
-    rb_define_method(rb_cMODULE, "cpath", node_cpath, 0);
-    rb_ary_push(members, rb_str_new2("cpath"));
-
     /* Document-method: body
      * the body of the module definition
      */
     rb_define_method(rb_cMODULE, "body", node_body, 0);
     rb_ary_push(members, rb_str_new2("body"));
+
+    /* Document-method: cpath
+     * the name of the module to define
+     */
+    rb_define_method(rb_cMODULE, "cpath", node_cpath, 0);
+    rb_ary_push(members, rb_str_new2("cpath"));
   }
 
   /* Document-class: Node::NEXT
@@ -4737,17 +4636,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cNTH_REF, "__type__", INT2NUM(NODE_NTH_REF));
     rb_define_singleton_method(rb_cNTH_REF, "members", node_s_members, 0);
 
-    /* Document-method: nth
-     * the index of the match data item to retrieve
-     */
-    rb_define_method(rb_cNTH_REF, "nth", node_nth, 0);
-    rb_ary_push(members, rb_str_new2("nth"));
-
     /* Document-method: cnt
      * the index into the local variable table where the match data is stored
      */
     rb_define_method(rb_cNTH_REF, "cnt", node_cnt, 0);
     rb_ary_push(members, rb_str_new2("cnt"));
+
+    /* Document-method: nth
+     * the index of the match data item to retrieve
+     */
+    rb_define_method(rb_cNTH_REF, "nth", node_nth, 0);
+    rb_ary_push(members, rb_str_new2("nth"));
   }
 
   /* Document-class: Node::OPT_N
@@ -4800,12 +4699,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN1, "__type__", INT2NUM(NODE_OP_ASGN1));
     rb_define_singleton_method(rb_cOP_ASGN1, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the assigment
-     */
-    rb_define_method(rb_cOP_ASGN1, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * 0, 1, or the name a method to call to calculate the value of the
      * rhs
@@ -4818,6 +4711,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cOP_ASGN1, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* Document-method: args
+     * the arguments to the assigment
+     */
+    rb_define_method(rb_cOP_ASGN1, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::OP_ASGN2
@@ -4840,11 +4739,11 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN2, "__type__", INT2NUM(NODE_OP_ASGN2));
     rb_define_singleton_method(rb_cOP_ASGN2, "members", node_s_members, 0);
 
-    /* Document-method: value
-     * the value to assign to the attribute
+    /* Document-method: recv
+     * the receiver of the attribute
      */
-    rb_define_method(rb_cOP_ASGN2, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
+    rb_define_method(rb_cOP_ASGN2, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
 
     /* Document-method: next
      * another node of type OP_ASGN2 which contains more information
@@ -4853,11 +4752,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cOP_ASGN2, "next", node_next, 0);
     rb_ary_push(members, rb_str_new2("next"));
 
-    /* Document-method: recv
-     * the receiver of the attribute
+    /* Document-method: value
+     * the value to assign to the attribute
      */
-    rb_define_method(rb_cOP_ASGN2, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
+    rb_define_method(rb_cOP_ASGN2, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
   }
 
   /* Document-class: Node::OP_ASGN2_ARG
@@ -4873,6 +4772,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN2_ARG, "__type__", INT2NUM(NODE_OP_ASGN2_ARG));
     rb_define_singleton_method(rb_cOP_ASGN2_ARG, "members", node_s_members, 0);
 
+    /* Document-method: mid
+     * The operation to apply to the attribute before setting it.  May
+     * be 0 (false) to indicate "logical or" or 1 (nil) to indicate
+     * "logical and".
+     */
+    rb_define_method(rb_cOP_ASGN2_ARG, "mid", node_mid, 0);
+    rb_ary_push(members, rb_str_new2("mid"));
+
     /* Document-method: vid
      * The method to call on the receiver to retrieve the attribute
      */
@@ -4884,14 +4791,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cOP_ASGN2_ARG, "aid", node_aid, 0);
     rb_ary_push(members, rb_str_new2("aid"));
-
-    /* Document-method: mid
-     * The operation to apply to the attribute before setting it.  May
-     * be 0 (false) to indicate "logical or" or 1 (nil) to indicate
-     * "logical and".
-     */
-    rb_define_method(rb_cOP_ASGN2_ARG, "mid", node_mid, 0);
-    rb_ary_push(members, rb_str_new2("mid"));
   }
 
   /* Document-class: Node::OP_ASGN_AND
@@ -4910,18 +4809,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN_AND, "__type__", INT2NUM(NODE_OP_ASGN_AND));
     rb_define_singleton_method(rb_cOP_ASGN_AND, "members", node_s_members, 0);
 
+    /* Document-method: recv
+     * an expression representing the left hand side of the assignment
+     */
+    rb_define_method(rb_cOP_ASGN_AND, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
+
     /* Document-method: value
      * an expression representing the assignment that should be
      * performed if the left hand side is true
      */
     rb_define_method(rb_cOP_ASGN_AND, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
-
-    /* Document-method: recv
-     * an expression representing the left hand side of the assignment
-     */
-    rb_define_method(rb_cOP_ASGN_AND, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::OP_ASGN_OR
@@ -4940,6 +4839,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN_OR, "__type__", INT2NUM(NODE_OP_ASGN_OR));
     rb_define_singleton_method(rb_cOP_ASGN_OR, "members", node_s_members, 0);
 
+    /* Document-method: recv
+     * the receiver of the assignment
+     */
+    rb_define_method(rb_cOP_ASGN_OR, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
+
     /* Document-method: aid
      * if this indicator is nonzero, ruby will check to see if the
      * provided expression is defined, otherwise it will assume that
@@ -4953,12 +4858,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cOP_ASGN_OR, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
-
-    /* Document-method: recv
-     * the receiver of the assignment
-     */
-    rb_define_method(rb_cOP_ASGN_OR, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::OR
@@ -4976,17 +4875,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOR, "__type__", INT2NUM(NODE_OR));
     rb_define_singleton_method(rb_cOR, "members", node_s_members, 0);
 
-    /* Document-method: first
-     * the expression on the left hand side
-     */
-    rb_define_method(rb_cOR, "first", node_1st, 0);
-    rb_ary_push(members, rb_str_new2("first"));
-
     /* Document-method: second
      * the expression on the right hand side
      */
     rb_define_method(rb_cOR, "second", node_2nd, 0);
     rb_ary_push(members, rb_str_new2("second"));
+
+    /* Document-method: first
+     * the expression on the left hand side
+     */
+    rb_define_method(rb_cOR, "first", node_1st, 0);
+    rb_ary_push(members, rb_str_new2("first"));
   }
 
   /* Document-class: Node::POSTEXE
@@ -5044,17 +4943,17 @@ void define_node_subclass_methods()
     rb_define_method(rb_cRESBODY, "head", node_head, 0);
     rb_ary_push(members, rb_str_new2("head"));
 
-    /* Document-method: args
-     * the expression type to match against
-     */
-    rb_define_method(rb_cRESBODY, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: body
      * the expresion to evaluate if the exception type matches
      */
     rb_define_method(rb_cRESBODY, "body", node_body, 0);
     rb_ary_push(members, rb_str_new2("body"));
+
+    /* Document-method: args
+     * the expression type to match against
+     */
+    rb_define_method(rb_cRESBODY, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::RESCUE
@@ -5100,17 +4999,17 @@ void define_node_subclass_methods()
     rb_define_method(rb_cRESCUE, "head", node_head, 0);
     rb_ary_push(members, rb_str_new2("head"));
 
-    /* Document-method: else
-     * the expression to be evaluated if no exception is raised
-     */
-    rb_define_method(rb_cRESCUE, "else", node_else, 0);
-    rb_ary_push(members, rb_str_new2("else"));
-
     /* Document-method: resq
      * the expression to be evaluated if an exception is raised
      */
     rb_define_method(rb_cRESCUE, "resq", node_resq, 0);
     rb_ary_push(members, rb_str_new2("resq"));
+
+    /* Document-method: else
+     * the expression to be evaluated if no exception is raised
+     */
+    rb_define_method(rb_cRESCUE, "else", node_else, 0);
+    rb_ary_push(members, rb_str_new2("else"));
   }
 
   /* Document-class: Node::RETRY
@@ -5200,13 +5099,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cSCOPE, "__type__", INT2NUM(NODE_SCOPE));
     rb_define_singleton_method(rb_cSCOPE, "members", node_s_members, 0);
 
-    /* Document-method: tbl
-     * the names of the local variables* next the first expression in
-     * the scope
-     */
-    rb_define_method(rb_cSCOPE, "tbl", node_tbl, 0);
-    rb_ary_push(members, rb_str_new2("tbl"));
-
     /* Document-method: rval
      * holds information about which class(es) to search for  constants
      * in this scope
@@ -5214,6 +5106,13 @@ void define_node_subclass_methods()
     rb_define_method(rb_cSCOPE, "rval", node_rval, 0);
     rb_ary_push(members, rb_str_new2("rval"));
 
+    /* Document-method: tbl
+     * the names of the local variables* next the first expression in
+     * the scope
+     */
+    rb_define_method(rb_cSCOPE, "tbl", node_tbl, 0);
+    rb_ary_push(members, rb_str_new2("tbl"));
+
     /* Document-method: next
      * the body of the lexical scope
      */
@@ -5360,6 +5259,8 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cUNTIL, "__member__", members);
     rb_iv_set(rb_cUNTIL, "__type__", INT2NUM(NODE_UNTIL));
     rb_define_singleton_method(rb_cUNTIL, "members", node_s_members, 0);
+    rb_define_method(rb_cUNTIL, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: body
      * the body of the loop
@@ -5372,8 +5273,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cUNTIL, "cond", node_cond, 0);
     rb_ary_push(members, rb_str_new2("cond"));
-    rb_define_method(rb_cUNTIL, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
   }
 
   /* Document-class: Node::VALIAS
@@ -5389,10 +5288,10 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cVALIAS, "__member__", members);
     rb_iv_set(rb_cVALIAS, "__type__", INT2NUM(NODE_VALIAS));
     rb_define_singleton_method(rb_cVALIAS, "members", node_s_members, 0);
-    rb_define_method(rb_cVALIAS, "first", node_1st, 0);
-    rb_ary_push(members, rb_str_new2("first"));
     rb_define_method(rb_cVALIAS, "second", node_2nd, 0);
     rb_ary_push(members, rb_str_new2("second"));
+    rb_define_method(rb_cVALIAS, "first", node_1st, 0);
+    rb_ary_push(members, rb_str_new2("first"));
   }
 
   /* Document-class: Node::VCALL
@@ -5484,6 +5383,8 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cWHILE, "__member__", members);
     rb_iv_set(rb_cWHILE, "__type__", INT2NUM(NODE_WHILE));
     rb_define_singleton_method(rb_cWHILE, "members", node_s_members, 0);
+    rb_define_method(rb_cWHILE, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: body
      * the body of the loop
@@ -5496,8 +5397,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cWHILE, "cond", node_cond, 0);
     rb_ary_push(members, rb_str_new2("cond"));
-    rb_define_method(rb_cWHILE, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
   }
 
   /* Document-class: Node::XSTR