nodewrap 0.5.0

data/ext/insns_info.h.rpp

@@ -0,0 +1,50 @@
+#ifndef insns_info__h_
+#define insns_info__h_
+
+#include "ruby_version.h"
+
+#ifdef RUBY_HAS_YARV
+
+#include "vm.h"
+#include "ruby.h"
+#include "yarvcore.h"
+
+#ruby <<END
+  require 'ruby_source_dir'
+  insns_location = "#{RUBY_SOURCE_DIR}/insns.inc"
+  insns_info_location = "#{RUBY_SOURCE_DIR}/insns_info.inc"
+  iseq_c_location = "#{RUBY_SOURCE_DIR}/iseq.c"
+
+  [ insns_location, insns_info_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        puts line
+      end
+    end
+  end
+
+  [ iseq_c_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        if line =~ /^make_compile_option/ then
+          puts 'void'
+          puts "#{line};"
+        end
+      end
+    end
+  end
+  nil
+END
+
+extern VALUE instruction_class[YARV_MAX_INSTRUCTION_SIZE];
+void define_instruction_subclasses(VALUE rb_cInstruction);
+
+#endif
+
+#endif
+

data/ext/node_type_descrip.c

@@ -0,0 +1,148 @@
+#include "node_type_descrip.h"
+#include "version.h"
+
+Node_Type_Descrip node_type_descrips_unsorted[] = {
+  { NODE_BLOCK, NEN_HEAD, NEN_NEXT, NEN_NONE, "BLOCK" },
+  { NODE_POSTEXE, NEN_NONE, NEN_NONE, NEN_NONE, "POSTEXE" },
+  { NODE_BEGIN, NEN_BODY, NEN_NONE, NEN_NONE, "BEGIN" },
+  { NODE_MATCH, NEN_HEAD, NEN_NONE, NEN_NONE, "MATCH" },
+  { NODE_MATCH2, NEN_RECV, NEN_VALUE, NEN_NONE, "MATCH2" },
+  { NODE_MATCH3, NEN_RECV, NEN_VALUE, NEN_NONE, "MATCH3" },
+  { NODE_OPT_N, NEN_BODY, NEN_NONE, NEN_NONE, "OPT_N" },
+  { NODE_SELF, NEN_NONE, NEN_NONE, NEN_NONE, "SELF" },
+  { NODE_NIL, NEN_NONE, NEN_NONE, NEN_NONE, "NIL" },
+  { NODE_TRUE, NEN_NONE, NEN_NONE, NEN_NONE, "TRUE" },
+  { NODE_FALSE, NEN_NONE, NEN_NONE, NEN_NONE, "FALSE" },
+  { NODE_IF, NEN_BODY, NEN_ELSE, NEN_COND, "IF" },
+  { NODE_WHEN, NEN_HEAD, NEN_BODY, NEN_NEXT, "WHEN" },
+  { NODE_CASE, NEN_HEAD, NEN_BODY, NEN_NEXT, "CASE" },
+  { NODE_WHILE, NEN_COND, NEN_BODY, NEN_STATE, "WHILE" },
+  { NODE_UNTIL, NEN_COND, NEN_BODY, NEN_STATE, "UNTIL" },
+  { NODE_BLOCK_PASS, NEN_BODY, NEN_ITER, NEN_NONE, "BLOCK_PASS" },
+  { NODE_ITER, NEN_VAR, NEN_BODY, NEN_ITER, "ITER" },
+  { NODE_FOR, NEN_VAR, NEN_BODY, NEN_ITER, "FOR" },
+  { NODE_BREAK, NEN_STTS, NEN_NONE, NEN_NONE, "BREAK" },
+  { NODE_NEXT, NEN_STTS, NEN_NONE, NEN_NONE, "NEXT" },
+  { NODE_REDO, NEN_NONE, NEN_NONE, NEN_NONE, "REDO" },
+  { NODE_RETRY, NEN_NONE, NEN_NONE, NEN_NONE, "RETRY" },
+  { NODE_YIELD, NEN_STTS, NEN_NONE, NEN_NONE, "YIELD" },
+  { NODE_RESCUE, NEN_HEAD, NEN_RESQ, NEN_ELSE, "RESCUE" },
+  { NODE_RESBODY, NEN_HEAD, NEN_RESQ, NEN_ENSR, "RESBODY" },
+  { NODE_ENSURE, NEN_HEAD, NEN_ENSR, NEN_NONE, "ENSURE" },
+  { NODE_AND, NEN_1ST, NEN_2ND, NEN_NONE, "AND" },
+  { NODE_OR, NEN_1ST, NEN_2ND, NEN_NONE, "OR" },
+  { NODE_NOT, NEN_BODY, NEN_NONE, NEN_NONE, "NOT" },
+  { NODE_DOT2, NEN_BEG, NEN_END, NEN_STATE, "DOT2" },
+  { NODE_DOT3, NEN_BEG, NEN_END, NEN_STATE, "DOT3" },
+  { NODE_FLIP2, NEN_CNT, NEN_BEG, NEN_END, "FLIP2" },
+  { NODE_FLIP3, NEN_CNT, NEN_BEG, NEN_END, "FLIP3" },
+  { NODE_RETURN, NEN_STTS, NEN_NONE, NEN_NONE, "RETURN" },
+  { NODE_ARGS, NEN_CNT, NEN_REST, NEN_OPT, "ARGS" },
+  { NODE_ARGSCAT, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSCAT" },
+  { NODE_ARGSPUSH, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSPUSH" },
+  { NODE_CALL, NEN_RECV, NEN_ARGS, NEN_MID, "CALL" },
+  { NODE_FCALL, NEN_ARGS, NEN_MID, NEN_NONE, "FCALL" },
+  { NODE_VCALL, NEN_MID, NEN_NONE, NEN_NONE, "VCALL" },
+  { NODE_SUPER, NEN_ARGS, NEN_NONE, NEN_NONE, "SUPER" },
+  { NODE_ZSUPER, NEN_ARGS, NEN_NONE, NEN_NONE, "ZSUPER" },
+  { NODE_SCOPE, NEN_RVAL, NEN_TBL, NEN_NEXT, "SCOPE" },
+  { NODE_OP_ASGN1, NEN_RECV, NEN_ARGS, NEN_MID, "OP_ASGN1" },
+  { NODE_OP_ASGN2, NEN_VID, NEN_RECV, NEN_VALUE, "OP_ASGN2" },
+  { NODE_OP_ASGN_AND, NEN_HEAD, NEN_VALUE, NEN_NONE, "OP_ASGN_AND" },
+  { NODE_OP_ASGN_OR, NEN_HEAD, NEN_VALUE, NEN_NONE, "OP_ASGN_OR" },
+  { NODE_MASGN, NEN_VALUE, NEN_HEAD, NEN_ARGS, "MASGN" },
+  { NODE_LASGN, NEN_VID, NEN_VALUE, NEN_CNT, "LASGN" },
+  { NODE_DASGN, NEN_VALUE, NEN_VID, NEN_NONE, "DASGN" },
+  { NODE_DASGN_CURR, NEN_VALUE, NEN_VID, NEN_NONE, "DASGN_CURR" },
+  { NODE_GASGN, NEN_VID, NEN_VALUE, NEN_ENTRY, "GASGN" },
+  { NODE_IASGN, NEN_VID, NEN_VALUE, NEN_NONE, "IASGN" },
+  { NODE_CDECL, NEN_VID, NEN_VALUE, NEN_NONE, "CDECL" },
+  { NODE_CVDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CVDECL" },
+  { NODE_CVASGN, NEN_VALUE, NEN_VID, NEN_NONE, "CVASGN" },
+  { NODE_LVAR, NEN_CNT, NEN_VID, NEN_NONE, "LVAR" },
+  { NODE_DVAR, NEN_VID, NEN_NONE, NEN_NONE, "DVAR" },
+  { NODE_GVAR, NEN_VID, NEN_ENTRY, NEN_NONE, "GVAR" },
+  { NODE_IVAR, NEN_VID, NEN_NONE, NEN_NONE, "IVAR" },
+  { NODE_CONST, NEN_VID, NEN_NONE, NEN_NONE, "CONST" },
+  { NODE_CVAR, NEN_VID, NEN_NONE, NEN_NONE, "CVAR" },
+  { NODE_BLOCK_ARG, NEN_CNT, NEN_NONE, NEN_NONE, "BLOCK_ARG" },
+  { NODE_COLON2, NEN_HEAD, NEN_MID, NEN_NONE, "COLON2" },
+  { NODE_COLON3, NEN_MID, NEN_NONE, NEN_NONE, "COLON3" },
+  { NODE_NTH_REF, NEN_NTH, NEN_CNT, NEN_NONE, "NTH_REF" },
+  { NODE_BACK_REF, NEN_NTH, NEN_CNT, NEN_NONE, "BACK_REF" },
+  { NODE_HASH, NEN_HEAD, NEN_NONE, NEN_NONE, "HASH" },
+  { NODE_ZARRAY, NEN_NONE, NEN_NONE, NEN_NONE, "ZARRAY" },
+  { NODE_ARRAY, NEN_ALEN, NEN_HEAD, NEN_NEXT, "ARRAY" },
+  { NODE_STR, NEN_LIT, NEN_NONE, NEN_NONE, "STR" },
+  { 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_DXSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DXSTR" },
+  { NODE_XSTR, NEN_LIT, NEN_NONE, NEN_NONE, "XSTR" },
+#if defined(C_ALLOCA) || RUBY_VERSION_CODE >= 190
+  { NODE_ALLOCA, NEN_LIT, NEN_VALUE, NEN_CNT, "ALLOCA" },
+#endif
+  { NODE_LIT, NEN_LIT, NEN_NONE, NEN_NONE, "LIT" },
+  { NODE_ATTRSET, NEN_VID, NEN_NONE, NEN_NONE, "ATTRSET" },
+  { NODE_DEFN, NEN_DEFN, NEN_MID, NEN_NOEX, "DEFN" },
+  { NODE_DEFS, NEN_DEFN, NEN_RECV, NEN_MID, "DEFS" },
+  { NODE_UNDEF, NEN_MID, NEN_NONE, NEN_NONE, "UNDEF" },
+  { NODE_ALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "ALIAS" },
+  { NODE_VALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "VALIAS" },
+  { NODE_SCLASS, NEN_RECV, NEN_BODY, NEN_NONE, "SCLASS" },
+  { NODE_DEFINED, NEN_HEAD, NEN_NONE, NEN_NONE, "DEFINED" },
+  { NODE_IFUNC, NEN_CFNC, NEN_TVAL, NEN_ARGC, "IFUNC" },
+  { NODE_CFUNC, NEN_CFNC, NEN_TVAL, NEN_ARGC, "CFUNC" },
+  { NODE_CREF, NEN_CLSS, NEN_NEXT, NEN_BODY, "CREF" },
+  { NODE_BMETHOD, NEN_CVAL, NEN_NONE, NEN_NONE, "BMETHOD" },
+  { NODE_MEMO, NEN_LIT, NEN_TVAL, NEN_NONE, "MEMO" },
+  { NODE_EVSTR, NEN_BODY, NEN_NONE, NEN_NONE, "EVSTR" },
+  { NODE_METHOD, NEN_BODY, NEN_CLSS, NEN_NOEX, "METHOD" },
+  { NODE_FBODY, NEN_BODY, NEN_OID, NEN_CNT, "FBODY" },
+  { NODE_CLASS, NEN_SUPER, NEN_CPATH, NEN_BODY, "CLASS" },
+  { NODE_MODULE, NEN_CPATH, NEN_BODY, NEN_NONE, "MODULE" },
+  { NODE_DSYM, NEN_LIT, NEN_NEXT, NEN_NONE, "DSYM" },
+  { NODE_ATTRASGN, NEN_MID, NEN_RECV, NEN_ARGS, "ATTRASGN" },
+  { NODE_LAST, NEN_NONE, NEN_NONE, NEN_NONE, "LAST" },
+};
+
+static Node_Type_Descrip * node_type_descrips[NODE_LAST];
+static int node_type_descrips_initialized = 0;
+
+static void init_node_type_descrips()
+{
+  if(!node_type_descrips_initialized)
+  {
+    Node_Type_Descrip * descrip;
+    memset(node_type_descrips, 0, sizeof(node_type_descrips));
+    for(descrip = node_type_descrips_unsorted;
+        descrip->nt != NODE_LAST;
+        ++descrip)
+    {
+      if(node_type_descrips[descrip->nt])
+      {
+        rb_raise(rb_eRuntimeError, "duplicate entry for %d\n", descrip->nt);
+      }
+      else
+      {
+        node_type_descrips[descrip->nt] = descrip;
+      }
+    }
+    node_type_descrips_initialized = 1;
+  }
+}
+
+/* Given a node, find out the types of the three elements it contains */
+Node_Type_Descrip const * node_type_descrip(enum node_type nt)
+{
+  init_node_type_descrips();
+  if(node_type_descrips[nt])
+  {
+    return node_type_descrips[nt];
+  }
+  else
+  {
+    rb_raise(rb_eArgError, "Unknown node type %d", nt);
+  }
+}
+

data/ext/node_type_descrip.c.rpp

@@ -0,0 +1,72 @@
+#include "node_type_descrip.h"
+#include "version.h"
+
+Node_Type_Descrip node_type_descrips_unsorted[] = {
+#ruby <<END
+require 'node_type_descrip'
+NODE_TYPE_DESCRIPS.each do |descrip|
+  name = descrip.name
+  node1 = descrip.node1
+  node2 = descrip.node2
+  node3 = descrip.node3
+
+  if name == 'ALLOCA' then
+    puts <<-END
+#if defined(C_ALLOCA) || RUBY_VERSION_CODE >= 190
+    END
+  end
+
+  puts <<-END
+  { NODE_#{name}, NEN_#{node1}, NEN_#{node2}, NEN_#{node3}, "#{name}" },
+  END
+
+  if name == 'ALLOCA' then
+    puts <<-END
+#endif
+    END
+  end
+end
+nil
+END
+};
+
+static Node_Type_Descrip * node_type_descrips[NODE_LAST];
+static int node_type_descrips_initialized = 0;
+
+static void init_node_type_descrips()
+{
+  if(!node_type_descrips_initialized)
+  {
+    Node_Type_Descrip * descrip;
+    memset(node_type_descrips, 0, sizeof(node_type_descrips));
+    for(descrip = node_type_descrips_unsorted;
+        descrip->nt != NODE_LAST;
+        ++descrip)
+    {
+      if(node_type_descrips[descrip->nt])
+      {
+        rb_raise(rb_eRuntimeError, "duplicate entry for %d\n", descrip->nt);
+      }
+      else
+      {
+        node_type_descrips[descrip->nt] = descrip;
+      }
+    }
+    node_type_descrips_initialized = 1;
+  }
+}
+
+/* Given a node, find out the types of the three elements it contains */
+Node_Type_Descrip const * node_type_descrip(enum node_type nt)
+{
+  init_node_type_descrips();
+  if(node_type_descrips[nt])
+  {
+    return node_type_descrips[nt];
+  }
+  else
+  {
+    rb_raise(rb_eArgError, "Unknown node type %d", nt);
+  }
+}
+

data/ext/node_type_descrip.h

@@ -0,0 +1,17 @@
+#ifndef node_type_descrip__h
+#define node_type_descrip__h
+
+#include "nodeinfo.h"
+
+typedef struct {
+  enum node_type nt;
+  enum Node_Elem_Name n1;
+  enum Node_Elem_Name n2;
+  enum Node_Elem_Name n3;
+  char const * name;
+} Node_Type_Descrip;
+
+Node_Type_Descrip const * node_type_descrip(enum node_type nt);
+
+#endif
+

data/ext/node_type_descrip.rb

@@ -0,0 +1,169 @@
+require 'ruby_version_code'
+require 'ruby_source_dir'
+
+NODE_TYPE_DESCRIPS = [
+  [ 'BLOCK'       , 'HEAD'  , 'NEXT'  , 'NONE'  ], 
+  [ 'POSTEXE'     , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'BEGIN'       , 'BODY'  , 'NONE'  , 'NONE'  ], 
+  [ 'MATCH'       , 'HEAD'  , 'NONE'  , 'NONE'  ], 
+  [ 'MATCH2'      , 'RECV'  , 'VALUE' , 'NONE'  ], 
+  [ 'MATCH3'      , 'RECV'  , 'VALUE' , 'NONE'  ], 
+  [ 'OPT_N'       , 'BODY'  , 'NONE'  , 'NONE'  ], 
+  [ 'SELF'        , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'NIL'         , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'TRUE'        , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'FALSE'       , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'IF'          , 'BODY'  , 'ELSE'  , 'COND'  ], 
+  [ 'WHEN'        , 'HEAD'  , 'BODY'  , 'NEXT'  ], 
+  [ 'CASE'        , 'HEAD'  , 'BODY'  , 'NEXT'  ], 
+  [ 'WHILE'       , 'COND'  , 'BODY'  , 'STATE' ], 
+  [ 'UNTIL'       , 'COND'  , 'BODY'  , 'STATE' ], 
+  [ 'BLOCK_PASS'  , 'BODY'  , 'ITER'  , 'NONE'  ], 
+  [ 'ITER'        , 'VAR'   , 'BODY'  , 'ITER'  ], 
+  [ 'FOR'         , 'VAR'   , 'BODY'  , 'ITER'  ], 
+  [ 'BREAK'       , 'STTS'  , 'NONE'  , 'NONE'  ], 
+  [ 'NEXT'        , 'STTS'  , 'NONE'  , 'NONE'  ], 
+  [ 'REDO'        , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'RETRY'       , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'YIELD'       , 'STTS'  , 'NONE'  , 'NONE'  ], 
+  [ 'RESCUE'      , 'HEAD'  , 'RESQ'  , 'ELSE'  ], 
+  [ 'RESBODY'     , 'HEAD'  , 'RESQ'  , 'ENSR'  ], 
+  [ 'ENSURE'      , 'HEAD'  , 'ENSR'  , 'NONE'  ], 
+  [ 'AND'         , '1ST'   , '2ND'   , 'NONE'  ], 
+  [ 'OR'          , '1ST'   , '2ND'   , 'NONE'  ], 
+  [ 'NOT'         , 'BODY'  , 'NONE'  , 'NONE'  ], 
+  [ 'DOT2'        , 'BEG'   , 'END'   , 'STATE' ], 
+  [ 'DOT3'        , 'BEG'   , 'END'   , 'STATE' ], 
+  [ 'FLIP2'       , 'CNT'   , 'BEG'   , 'END'   ], 
+  [ 'FLIP3'       , 'CNT'   , 'BEG'   , 'END'   ], 
+  [ 'RETURN'      , 'STTS'  , 'NONE'  , 'NONE'  ], 
+  [ 'ARGS'        , 'CNT'   , 'REST'  , 'OPT'   ], 
+  [ 'ARGSCAT'     , 'HEAD'  , 'BODY'  , 'NONE'  ], 
+  [ 'ARGSPUSH'    , 'HEAD'  , 'BODY'  , 'NONE'  ], 
+  [ 'CALL'        , 'RECV'  , 'ARGS'  , 'MID'   ], 
+  [ 'FCALL'       , 'ARGS'  , 'MID'   , 'NONE'  ], 
+  [ 'VCALL'       , 'MID'   , 'NONE'  , 'NONE'  ], 
+  [ 'SUPER'       , 'ARGS'  , 'NONE'  , 'NONE'  ], 
+  [ 'ZSUPER'      , 'ARGS'  , 'NONE'  , 'NONE'  ], 
+  # rval holds an object, not a node
+  [ 'SCOPE'       , 'RVAL'  , 'TBL'   , 'NEXT'  ], 
+  [ 'OP_ASGN1'    , 'RECV'  , 'ARGS'  , 'MID'   ], 
+  [ 'OP_ASGN2'    , 'VID'   , 'RECV'  , 'VALUE' ], 
+  [ 'OP_ASGN_AND' , 'HEAD'  , 'VALUE' , 'NONE'  ], 
+  [ 'OP_ASGN_OR'  , 'HEAD'  , 'VALUE' , 'NONE'  ], 
+  [ 'MASGN'       , 'VALUE' , 'HEAD'  , 'ARGS'  ], 
+  [ 'LASGN'       , 'VID'   , 'VALUE' , 'CNT'   ], 
+  [ 'DASGN'       , 'VALUE' , 'VID'   , 'NONE'  ], 
+  [ 'DASGN_CURR'  , 'VALUE' , 'VID'   , 'NONE'  ], 
+  [ 'GASGN'       , 'VID'   , 'VALUE' , 'ENTRY' ], 
+  [ 'IASGN'       , 'VID'   , 'VALUE' , 'NONE'  ], 
+  [ 'CDECL'       , 'VID'   , 'VALUE' , 'NONE'  ], 
+  [ 'CVDECL'      , 'VALUE' , 'VID'   , 'NONE'  ], 
+  [ 'CVASGN'      , 'VALUE' , 'VID'   , 'NONE'  ], 
+  [ 'LVAR'        , 'CNT'   , 'VID'   , 'NONE'  ], 
+  [ 'DVAR'        , 'VID'   , 'NONE'  , 'NONE'  ], 
+  [ 'GVAR'        , 'VID'   , 'ENTRY' , 'NONE'  ], 
+  [ 'IVAR'        , 'VID'   , 'NONE'  , 'NONE'  ], 
+  [ 'CONST'       , 'VID'   , 'NONE'  , 'NONE'  ], 
+  [ 'CVAR'        , 'VID'   , 'NONE'  , 'NONE'  ], 
+  [ 'BLOCK_ARG'   , 'CNT'   , 'NONE'  , 'NONE'  ], 
+  [ 'COLON2'      , 'HEAD'  , 'MID'   , 'NONE'  ], 
+  [ 'COLON3'      , 'MID'   , 'NONE'  , 'NONE'  ], 
+  [ 'NTH_REF'     , 'NTH'   , 'CNT'   , 'NONE'  ], 
+  [ 'BACK_REF'    , 'NTH'   , 'CNT'   , 'NONE'  ], 
+  [ 'HASH'        , 'HEAD'  , 'NONE'  , 'NONE'  ], 
+  [ 'ZARRAY'      , 'NONE'  , 'NONE'  , 'NONE'  ], 
+  [ 'ARRAY'       , 'ALEN'  , 'HEAD'  , 'NEXT'  ], 
+  [ 'STR'         , 'LIT'   , 'NONE'  , 'NONE'  ], 
+  [ 'DREGX'       , 'LIT'   , 'NEXT'  , 'CFLAG' ], 
+  [ 'DREGX_ONCE'  , 'LIT'   , 'NEXT'  , 'CFLAG' ], 
+  [ 'DSTR'        , 'LIT'   , 'NEXT'  , 'NONE'  ], 
+  [ 'DXSTR'       , 'LIT'   , 'NEXT'  , 'NONE'  ], 
+  [ 'XSTR'        , 'LIT'   , 'NONE'  , 'NONE'  ], 
+  [ 'ALLOCA'      , 'LIT'   , 'VALUE' , 'CNT'   ], 
+  [ 'LIT'         , 'LIT'   , 'NONE'  , 'NONE'  ], 
+  [ 'ATTRSET'     , 'VID'   , 'NONE'  , 'NONE'  ], 
+  [ 'DEFN'        , 'DEFN'  , 'MID'   , 'NOEX'  ], 
+  [ 'DEFS'        , 'DEFN'  , 'RECV'  , 'MID'   ], 
+  [ 'UNDEF'       , 'MID'   , 'NONE'  , 'NONE'  ], 
+  [ 'ALIAS'       , '1ST'   , '2ND'   , 'NONE'  ], 
+  [ 'VALIAS'      , '1ST'   , '2ND'   , 'NONE'  ], 
+  [ 'SCLASS'      , 'RECV'  , 'BODY'  , 'NONE'  ], 
+  [ 'DEFINED'     , 'HEAD'  , 'NONE'  , 'NONE'  ], 
+  [ 'IFUNC'       , 'CFNC'  , 'TVAL'  , 'ARGC'  ], 
+  [ 'CFUNC'       , 'CFNC'  , 'TVAL'  , 'ARGC'  ], 
+  [ 'CREF'        , 'CLSS'  , 'NEXT'  , 'BODY'  ], 
+  [ 'BMETHOD'     , 'CVAL'  , 'NONE'  , 'NONE'  ], 
+  [ 'MEMO'        , 'LIT'   , 'TVAL'  , 'NONE'  ], 
+]
+if RUBY_VERSION_CODE < 180 then
+# (0, 180)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'EVSTR'       , 'LIT'   , 'NONE'  , 'NONE'  ], 
+]
+else
+# [180, oo)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'EVSTR'       , 'BODY'  , 'NONE'  , 'NONE'  ], 
+]
+end
+if RUBY_VERSION_CODE < 190 then
+# (0, 190)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'DMETHOD'     , 'CVAL'  , 'NONE'  , 'NONE'  ], 
+  [ 'NEWLINE'     , 'NTH'   , 'NEXT'  , 'NONE'  ], 
+  [ 'METHOD'      , 'NOEX'  , 'BODY'  , 'NONE'  ], 
+  [ 'FBODY'       , 'ORIG'  , 'MID'   , 'HEAD'  ], 
+]
+else
+# [190, oo)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'METHOD'      , 'BODY'  , 'CLSS'  , 'NOEX'  ], 
+  [ 'FBODY'       , 'BODY'  , 'OID'   , 'CNT'  ], 
+]
+end
+if RUBY_VERSION_CODE < 180 then
+# (0, 180)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'CVAR2'       , 'VID'   , 'NONE'  , 'NONE'  ], 
+  [ 'RESTARGS'    , 'HEAD'  , 'NONE'  , 'NONE'  ], 
+  [ 'CLASS'       , 'SUPER' , 'CNAME' , 'BODY'  ], 
+  [ 'MODULE'      , 'CNAME' , 'BODY'  , 'NONE'  ], 
+]
+if RUBY_VERSION_CODE >= 170 then
+# [170, oo)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'RESTARY'     , 'HEAD'  , 'NONE'  , 'NONE'  ], 
+  [ 'REXPAND'     , 'HEAD'  , 'NONE'  , 'NONE'  ], 
+  [ 'REGX'        , 'CFLAG' , 'NONE'  , 'NONE'  ], 
+]
+end
+else # RUBY_VERSION_CODE >= 180
+# [180, oo)
+NODE_TYPE_DESCRIPS.concat [
+  [ 'CLASS'       , 'SUPER' , 'CPATH' , 'BODY'  ], 
+  [ 'MODULE'      , 'CPATH' , 'BODY'  , 'NONE'  ], 
+  [ 'DSYM'        , 'LIT'   , 'NEXT'  , 'NONE'  ],
+  [ 'ATTRASGN'    , 'MID'   , 'RECV'  , 'ARGS'  ],
+]
+end
+
+
+# *** MUST BE LAST ***
+NODE_TYPE_DESCRIPS.concat [
+  [ 'LAST'        , 'NONE'  , 'NONE'  , 'NONE'  ], 
+]
+
+
+Node_Type_Descrip = Struct.new(:name, :node1, :node2, :node3)
+
+NODE_TYPE_DESCRIPS.map! { |x| Node_Type_Descrip.new(*x) }
+
+NEN_TO_NODE_TYPE = {}
+NODE_TYPE_DESCRIPS.each do |descrip|
+  [descrip.node1, descrip.node2, descrip.node3].each do |nen|
+    NEN_TO_NODE_TYPE[nen] ||= []
+    NEN_TO_NODE_TYPE[nen] << descrip.name
+  end
+end
+