ruby-internal 0.7.2 → 0.7.3

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

@@ -9,6 +9,7 @@
 
 #ruby <<END
   $: << '../..'
+  $: << '.' # TODO: hack
   require 'ruby_source_dir'
   vm_c_location = "#{RUBY_SOURCE_DIR}/vm.c"
   eval_c_location = "#{RUBY_SOURCE_DIR}/eval.c"

data/ext/internal/node/extconf.rb

@@ -1,28 +1,6 @@
 $: << '../..'
 require 'mkmf-ruby-internal'
 
-module Kernel
-  if not method_defined?(:try_const)
-    alias_method :try_const, :try_constant
-  end
-
-  if not method_defined?(:checking_message)
-    def checking_message(checking_for, headers = nil, opt = "")
-      return checking_for
-    end
-  end
-
-  if not method_defined?(:have_const)
-    def have_const(const, headers = nil, opt = "", &b)
-      checking_for checking_message([*const].compact.join(' '), headers, opt) do
-        try_const(const, headers, opt, &b)
-      end
-    end
-  end
-end
-
-ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
-
 have_type('st_data_t', [ 'ruby.h', 'st.h' ]) or
 have_type('st_data_t', [ 'ruby.h', 'ruby/st.h'])
 

data/ext/internal/node/global_entry.h

@@ -1,10 +1,52 @@
 #ifndef global_entry__h_
 #define global_entry__h_
 
-struct global_entry {
-    struct global_variable *var;
-    ID id;
+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 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;
+}
 
 #endif
 

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

@@ -1,23 +1,32 @@
 #ifndef global_entry__h_
 #define global_entry__h_
 
+st_table * rb_global_tbl;
+
 #ruby <<END
   $: << '../..'
+  $: << '.' # TODO: hack
   require 'ruby_source_dir'
   variable_c_location = "#{RUBY_SOURCE_DIR}/variable.c"
   File.open(variable_c_location) do |variable_c|
     write = false
     stopwrite = false
+    prev_line = ''
     while (line = variable_c.gets) != nil do
       case line
-      when /^struct global_entry/
+      when /^rb_global_entry\(.*\)/,
+           /^struct global_variable {/
+        puts prev_line
         write = true
         stopwrite = false
+      when /^#define (global_entry|gvar_getter_t|gvar_setter_t|gvar_marker_t|undef_getter|undef_setter|undef_marker)/
+        puts line
       when /^\}/
-        stopwrite = true if write
+        stopwrite = true
       end
       puts line if write
-      break if stopwrite
+      write = false if stopwrite
+      prev_line = line
     end
   end
 END

data/ext/internal/node/node.c

@@ -224,9 +224,9 @@ static VALUE node_flags(VALUE self)
  */
 static VALUE node_nd_file(VALUE self)
 {
+#ifdef HAVE_RB_SOURCE_FILENAME
   NODE * n;
   Data_Get_Struct(self, NODE, n);
-#ifdef HAVE_RB_SOURCE_FILENAME
   if(n->nd_file)
   {
     return rb_str_new2(n->nd_file);
@@ -306,19 +306,25 @@ static VALUE node_bracket(VALUE node, VALUE member)
 {
   ID id = SYMBOL_P(member)
     ? SYM2ID(member)
-    : rb_intern(STR2CSTR(member));
+    : rb_intern(StringValuePtr(member));
   return rb_funcall(node, id, 0);
 }
 
+static VALUE node_classname(VALUE node)
+{
+  VALUE str = rb_str_new2("#<");
+  rb_str_cat2(str, rb_class2name(CLASS_OF(node)));
+  rb_str_cat2(str, " ");
+  return str;
+}
+
 #ifdef HAVE_RB_PROTECT_INSPECT
 static VALUE node_inspect_protect(VALUE node)
 #else
 static VALUE node_inspect_protect(VALUE node, VALUE dummy, int recur)
 #endif
 {
-  VALUE str = rb_str_new2("#<");
-  rb_str_cat2(str, rb_class2name(CLASS_OF(node)));
-  rb_str_cat2(str, " ");
+  VALUE str = node_classname(node);
   VALUE members = node_members(node);
   int j;
 
@@ -501,10 +507,19 @@ VALUE eval_ruby_node(NODE * node, VALUE self, VALUE cref)
   }
   else
   {
+#ifdef HAVE_RB_SOURCE_FILENAME
     VALUE filename = node->nd_file
       ? rb_str_new2(node->nd_file)
       : rb_str_new2("<unknown>");
+#else
+    VALUE filename = Qnil;
+#endif
+
+    VALUE filepath = Qnil; /* TODO */
+
     VALUE iseq;
+    rb_proc_t * p;
+    VALUE proc;
 
     if(nd_type(node) != NODE_SCOPE)
     {
@@ -519,6 +534,9 @@ VALUE eval_ruby_node(NODE * node, VALUE self, VALUE cref)
         node,
         rb_str_new2("<compiled>"),
         filename,
+#if RUBY_VERSION_CODE >= 192
+        filepath,
+#endif
         self,
         ISEQ_TYPE_TOP);
 
@@ -528,9 +546,6 @@ VALUE eval_ruby_node(NODE * node, VALUE self, VALUE cref)
     /* VALUE result = rb_iseq_eval(iseq);
     return result; */
 
-    rb_proc_t * p;
-    VALUE proc;
-
     proc = create_proc(rb_cProc, Qnil, iseq_check(iseq));
     GetProcPtr(proc, p);
     p->block.self = self;
@@ -646,17 +661,20 @@ NODE * load_node_from_hash(VALUE arr, VALUE orig_node_id, VALUE node_hash, VALUE
   NODE * n = NEW_NIL();
   VALUE s3, s2, s1, rb_nd_file, rb_flags;
   unsigned long flags;
-  char *nd_file = 0;
   Node_Type_Descrip const *descrip;
   NODE tmp_node;
 
+#ifdef HAVE_RB_SOURCE_FILENAME
+  char *nd_file = 0;
+#endif
+
   nd_set_type(&tmp_node, NODE_NIL);
 
   Check_Type(arr, T_ARRAY);
   s3 = rb_ary_pop(arr);
   s2 = rb_ary_pop(arr);
   s1 = rb_ary_pop(arr);
-  rb_nd_file = rb_ary_pop(arr);
+  rb_nd_file = rb_ary_pop(arr); /* TODO: warning: set but not used */
   rb_flags = rb_ary_pop(arr);
   flags = NUM2INT(rb_flags);
   tmp_node.flags = flags;
@@ -686,7 +704,10 @@ NODE * load_node_from_hash(VALUE arr, VALUE orig_node_id, VALUE node_hash, VALUE
    */
   memcpy(n, &tmp_node, sizeof(NODE));
   n->flags = flags;
+
+#ifdef HAVE_RB_SOURCE_FILENAME
   n->nd_file = nd_file;
+#endif
 
   return n;
 }
@@ -758,7 +779,7 @@ static VALUE node_compile_string(int argc, VALUE * argv, VALUE self)
   file = NIL_P(file) ? rb_str_new2("(compiled)") : file;
   line = NIL_P(line) ? INT2NUM(1) : line;
 
-  node = rb_compile_string(STR2CSTR(file), str, NUM2INT(line));
+  node = rb_compile_string(StringValuePtr(file), str, NUM2INT(line));
 
 #ifdef RUBY_VM
   if(!node)
@@ -788,8 +809,11 @@ static VALUE node_compile_string(int argc, VALUE * argv, VALUE self)
  */
 static VALUE node_bytecode_compile(int argc, VALUE * argv, VALUE self)
 {
+  NODE * node;
   VALUE name = Qnil;
   VALUE filename = Qnil;
+  VALUE filepath = Qnil; /* TODO */
+
   rb_scan_args(argc, argv, "02", &name, &filename);
 
   if(name == Qnil)
@@ -802,12 +826,15 @@ static VALUE node_bytecode_compile(int argc, VALUE * argv, VALUE self)
     filename = name;
   }
 
-  NODE * node = unwrap_node(self);
+  node = unwrap_node(self);
 
   return rb_iseq_new(
       node,
       name,
       filename,
+#if RUBY_VERSION_CODE >= 192
+      filepath,
+#endif
       Qfalse,
       ISEQ_TYPE_TOP);
 }
@@ -823,7 +850,7 @@ static VALUE node_bytecode_compile(int argc, VALUE * argv, VALUE self)
 static VALUE node_dump(VALUE self, VALUE limit)
 {
   NODE * n;
-  VALUE node_hash, arr;
+  VALUE node_hash, arr, s;
 
   if(rb_safe_level() >= 4)
   {
@@ -836,7 +863,7 @@ static VALUE node_dump(VALUE self, VALUE limit)
   arr = rb_ary_new();
   rb_ary_push(arr, node_id(n));
   rb_ary_push(arr, node_hash);
-  VALUE s =  marshal_dump(arr, limit);
+  s =  marshal_dump(arr, limit);
   return s;
 }
 
@@ -1051,7 +1078,7 @@ void Init_node(void)
   {
     int actual_ruby_version_code = 0;
     VALUE ruby_version_str = rb_const_get(rb_cObject, rb_intern("RUBY_VERSION"));
-    char const * s = STR2CSTR(ruby_version_str);
+    char const * s = StringValuePtr(ruby_version_str);
 
     for(; *s != '\0'; ++s)
     {

data/ext/internal/node/node_type_descrip.c

@@ -6,13 +6,12 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
 #ifdef HAVE_NODE_ALLOCA
   { NODE_ALLOCA, NEN_CFNC, NEN_VALUE, NEN_CNT, "ALLOCA" },
 #endif
-  { NODE_AND, NEN_1ST, NEN_2ND, NEN_NONE, "AND" },
+  { NODE_AND, NEN_2ND, NEN_1ST, 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_ARRAY, NEN_ALEN, NEN_HEAD, NEN_NEXT, "ARRAY" },
+  { NODE_ATTRASGN, NEN_RECV, NEN_ARGS, NEN_MID, "ATTRASGN" },
   { NODE_BACK_REF, NEN_NTH, NEN_CNT, NEN_NONE, "BACK_REF" },
   { NODE_BEGIN, NEN_BODY, NEN_NONE, NEN_NONE, "BEGIN" },
   { NODE_BLOCK, NEN_HEAD, NEN_NEXT, NEN_NONE, "BLOCK" },
@@ -23,8 +22,7 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { 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_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" },
@@ -35,11 +33,11 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { 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_DEFS, NEN_DEFN, NEN_RECV, NEN_MID, "DEFS" },
   { NODE_DOT2, NEN_BEG, NEN_END, NEN_STATE, "DOT2" },
   { NODE_DOT3, NEN_BEG, NEN_END, NEN_STATE, "DOT3" },
-  { NODE_DREGX, NEN_LIT, NEN_CFLAG, NEN_NEXT, "DREGX" },
-  { NODE_DREGX_ONCE, NEN_LIT, NEN_CFLAG, NEN_NEXT, "DREGX_ONCE" },
+  { NODE_DREGX, NEN_LIT, NEN_NEXT, NEN_CFLAG, "DREGX" },
+  { NODE_DREGX_ONCE, NEN_LIT, NEN_NEXT, NEN_CFLAG, "DREGX_ONCE" },
   { NODE_DSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DSTR" },
   { NODE_DSYM, NEN_LIT, NEN_NEXT, NEN_NONE, "DSYM" },
   { NODE_DVAR, NEN_VID, NEN_NONE, NEN_NONE, "DVAR" },
@@ -47,10 +45,9 @@ 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_FLIP2, NEN_CNT, NEN_BEG, NEN_END, "FLIP2" },
+  { NODE_FLIP3, NEN_CNT, NEN_BEG, NEN_END, "FLIP3" },
   { NODE_FOR, NEN_BODY, NEN_ITER, NEN_VAR, "FOR" },
   { NODE_GASGN, NEN_VALUE, NEN_VID, NEN_ENTRY, "GASGN" },
   { NODE_GVAR, NEN_VID, NEN_ENTRY, NEN_NONE, "GVAR" },
@@ -65,25 +62,24 @@ Node_Type_Descrip node_type_descrips_unsorted[] = {
   { 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_CLSS, NEN_NOEX, "METHOD" },
   { NODE_MODULE, NEN_CPATH, NEN_BODY, 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, NEN_RECV, NEN_NEXT, NEN_VALUE, "OP_ASGN2" },
   { NODE_OP_ASGN2_ARG, NEN_VID, NEN_AID, NEN_MID, "OP_ASGN2_ARG" },
-  { NODE_OP_ASGN_AND, NEN_VALUE, NEN_RECV, NEN_NONE, "OP_ASGN_AND" },
+  { NODE_OP_ASGN_AND, NEN_RECV, NEN_VALUE, NEN_NONE, "OP_ASGN_AND" },
   { NODE_OP_ASGN_OR, NEN_AID, NEN_VALUE, NEN_RECV, "OP_ASGN_OR" },
-  { NODE_OR, NEN_1ST, NEN_2ND, NEN_NONE, "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" },

data/ext/internal/node/node_type_descrip.c.rpp

@@ -3,6 +3,7 @@
 
 Node_Type_Descrip node_type_descrips_unsorted[] = {
 #ruby <<END
+$: << '.' # TODO: hack
 require 'node_type_descrip'
 NODE_TYPE_DESCRIPS.each do |descrip|
   name = descrip.name

data/ext/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) =
@@ -2000,16 +2015,6 @@ static VALUE node_alen(VALUE self)
   Data_Get_Struct(self, NODE, n);
   return LONG2NUM(n->nd_alen);
 }
-/*
- * Return the Node's _argc_ member.  The return type is an
- * Integer.
- */
-static VALUE node_argc(VALUE self)
-{
-  NODE * n;
-  Data_Get_Struct(self, NODE, n);
-  return LONG2NUM(n->nd_argc);
-}
 /*
  * Return the Node's _args_ member.  The return type is
  * either a Node or an Object.
@@ -2107,33 +2112,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 +2477,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.
@@ -2921,17 +2878,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
@@ -3028,14 +2985,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cARRAY, "__member__", members);
     rb_iv_set(rb_cARRAY, "__type__", INT2NUM(NODE_ARRAY));
     rb_define_singleton_method(rb_cARRAY, "members", node_s_members, 0);
+    rb_define_method(rb_cARRAY, "alen", node_alen, 0);
+    rb_ary_push(members, rb_str_new2("alen"));
 
     /* Document-method: head
      * the first element of the array
      */
     rb_define_method(rb_cARRAY, "head", node_head, 0);
     rb_ary_push(members, rb_str_new2("head"));
-    rb_define_method(rb_cARRAY, "alen", node_alen, 0);
-    rb_ary_push(members, rb_str_new2("alen"));
 
     /* Document-method: next
      * the tail of the array
@@ -3058,6 +3015,12 @@ 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: recv
+     * the receiver of the method
+     */
+    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
      */
@@ -3069,33 +3032,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cATTRASGN, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
-
-    /* Document-method: recv
-     * the receiver of the method
-     */
-    rb_define_method(rb_cATTRASGN, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
-  }
-
-  /* Document-class: Node::ATTRSET
-   * A placeholder for an attribute writer method, which can added to a
-   * class by using attr_writer:
-   *   attr_writer :attribute
-   * Its reader counterpart is IVAR.
-   */
-  {
-    VALUE rb_cATTRSET = rb_define_class_under(rb_cNode, "ATTRSET", rb_cNode);
-    members = rb_ary_new();
-    rb_cNodeSubclass[NODE_ATTRSET] = rb_cATTRSET;
-    rb_iv_set(rb_cATTRSET, "__member__", members);
-    rb_iv_set(rb_cATTRSET, "__type__", INT2NUM(NODE_ATTRSET));
-    rb_define_singleton_method(rb_cATTRSET, "members", node_s_members, 0);
-
-    /* Document-method: vid
-     * the name of the attribute, with a leading '@' sign
-     */
-    rb_define_method(rb_cATTRSET, "vid", node_vid, 0);
-    rb_ary_push(members, rb_str_new2("vid"));
   }
 
   /* Document-class: Node::BACK_REF
@@ -3355,22 +3291,6 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("vid"));
   }
 
-  /* Document-class: Node::CFUNC
-   * A placeholder for a function implemented in C.
-   */
-  {
-    VALUE rb_cCFUNC = rb_define_class_under(rb_cNode, "CFUNC", rb_cNode);
-    members = rb_ary_new();
-    rb_cNodeSubclass[NODE_CFUNC] = rb_cCFUNC;
-    rb_iv_set(rb_cCFUNC, "__member__", members);
-    rb_iv_set(rb_cCFUNC, "__type__", INT2NUM(NODE_CFUNC));
-    rb_define_singleton_method(rb_cCFUNC, "members", node_s_members, 0);
-    rb_define_method(rb_cCFUNC, "cfnc", node_cfnc, 0);
-    rb_ary_push(members, rb_str_new2("cfnc"));
-    rb_define_method(rb_cCFUNC, "argc", node_argc, 0);
-    rb_ary_push(members, rb_str_new2("argc"));
-  }
-
   /* Document-class: Node::CLASS
    * Represents a class definition, e.g.:
    *   class cpath
@@ -3395,6 +3315,13 @@ 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: super
+     * an expression returning the base class, or false if there is no
+     * base class specified
+     */
+    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
      */
@@ -3406,13 +3333,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cCLASS, "body", node_body, 0);
     rb_ary_push(members, rb_str_new2("body"));
-
-    /* Document-method: super
-     * an expression returning the base class, or false if there is no
-     * base class specified
-     */
-    rb_define_method(rb_cCLASS, "super", node_super, 0);
-    rb_ary_push(members, rb_str_new2("super"));
   }
 
   /* Document-class: Node::COLON2
@@ -3681,17 +3601,17 @@ void define_node_subclass_methods()
     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"));
-
     /* Document-method: recv
      * the object to whose singleton class the new method is to be  added
      */
     rb_define_method(rb_cDEFS, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* 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"));
   }
 
   /* Document-class: Node::DOT2
@@ -3772,6 +3692,12 @@ void define_node_subclass_methods()
     rb_define_method(rb_cDREGX, "lit", node_lit, 0);
     rb_ary_push(members, rb_str_new2("lit"));
 
+    /* Document-method: next
+     * a list of expressions to be appended onto the string
+     */
+    rb_define_method(rb_cDREGX, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
+
     /* Document-method: cflag
      * a bitfield containing the options used in the regular
      * expression.  Valid values include:
@@ -3788,12 +3714,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cDREGX, "cflag", node_cflag, 0);
     rb_ary_push(members, rb_str_new2("cflag"));
-
-    /* Document-method: next
-     * a list of expressions to be appended onto the string
-     */
-    rb_define_method(rb_cDREGX, "next", node_next, 0);
-    rb_ary_push(members, rb_str_new2("next"));
   }
 
   /* Document-class: Node::DREGX_ONCE
@@ -3815,18 +3735,18 @@ void define_node_subclass_methods()
     rb_define_method(rb_cDREGX_ONCE, "lit", node_lit, 0);
     rb_ary_push(members, rb_str_new2("lit"));
 
+    /* Document-method: next
+     * a list of expressions to be appended onto the string
+     */
+    rb_define_method(rb_cDREGX_ONCE, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
+
     /* Document-method: cflag
      * a bitfield containing the options used in the regular
      * expression.  See DREGX for a list of valid values.
      */
     rb_define_method(rb_cDREGX_ONCE, "cflag", node_cflag, 0);
     rb_ary_push(members, rb_str_new2("cflag"));
-
-    /* Document-method: next
-     * a list of expressions to be appended onto the string
-     */
-    rb_define_method(rb_cDREGX_ONCE, "next", node_next, 0);
-    rb_ary_push(members, rb_str_new2("next"));
   }
 
   /* Document-class: Node::DSTR
@@ -4003,38 +3923,6 @@ 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
-   */
-  {
-    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).
@@ -4077,6 +3965,13 @@ 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: 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, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
+
     /* Document-method: beg
      * the beginning of the range
      */
@@ -4088,13 +3983,6 @@ 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 $_)
-     */
-    rb_define_method(rb_cFLIP2, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
   }
 
   /* Document-class: Node::FLIP3
@@ -4111,6 +3999,13 @@ 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: 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, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
+
     /* Document-method: beg
      * the beginning of the range
      */
@@ -4122,13 +4017,6 @@ 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 $_)
-     */
-    rb_define_method(rb_cFLIP3, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
   }
 
   /* Document-class: Node::FOR
@@ -4563,6 +4451,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 +4465,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 +4482,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 +4518,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
@@ -4840,11 +4692,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 +4705,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
@@ -4910,18 +4762,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
@@ -4976,17 +4828,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 +4896,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 +4952,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