ruby-internal 0.6.0

data/ext/internal/node/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
+#ifdef HAVE_NODE_ALLOCA
+    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[NUM_NODE_TYPE_DESCRIPS];
+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 node type %d (%s is also %s)\n", descrip->nt, descrip->name, node_type_descrips[descrip->nt]->name);
+      }
+      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/internal/node/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/internal/node/node_type_descrip.rb

@@ -0,0 +1,39 @@
+$: << '../..'
+require 'ruby_source_dir'
+require 'nodes'
+
+NODE_TYPE_DESCRIPS = []
+
+ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
+
+nodes = Nodes.new
+nodes.each do |name, node|
+  members = node['members'] || {}
+  version_range = node['version_range']
+  if version_range.includes?(ruby_version_code) then
+    node_name = node['name'].upcase
+    member_names = [
+      (members.keys[0] || 'NONE').upcase,
+      (members.keys[1] || 'NONE').upcase,
+      (members.keys[2] || 'NONE').upcase,
+    ]
+    NODE_TYPE_DESCRIPS << [ node_name, *member_names ]
+  end
+end
+
+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
+

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

@@ -0,0 +1,587 @@
+#include "nodeinfo.h"
+#include "version.h"
+#include "global_entry.h"
+#include "builtins.h"
+
+static int is_flip_state(ID id)
+{
+  if(id == 0)
+  {
+    return 1;
+  }
+#ifdef HAVE_RB_IS_LOCAL_ID
+  if(!rb_is_local_id(id))
+  {
+    return 1;
+  }
+#endif
+  return 0;
+}
+
+static VALUE variable_names(ID * tbl)
+{
+  if(tbl)
+  {
+    size_t j;
+    VALUE arr = rb_ary_new();
+    /* A tbl contains the names of local variables.  The first
+     * element is the size of the table.  The next two elements
+     * are $_ and $~.  The rest of the elements are the names of
+     * the variables themselves.
+     */
+    for(j = 3; j <= tbl[0]; ++j)
+    {
+      if(is_flip_state(tbl[j]))
+      {
+        /* flip state */
+        rb_ary_push(arr, Qnil);
+      }
+      else
+      {
+        rb_ary_push(arr, ID2SYM(tbl[j]));
+      }
+    }
+    return arr;
+  }
+  else
+  {
+    return Qnil;
+  }
+}
+
+/* Every node contains three elements.  This function takes any one of
+ * those elements, converts it to a Ruby object that can be dumped
+ * (since nodes can't be dumped), and puts the resulting object into
+ * node_hash.
+ */
+VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
+{
+  switch(nen)
+  {
+    case NEN_NONE:
+      return Qnil;
+#ruby <<END
+  require 'read_node_h'
+  require 'nodes'
+  require 'node_type_descrip'
+
+  NODEINFO.sort.each do |node_elem_name, node_elem_ref|
+    puts <<-END
+    case NEN_#{node_elem_name.upcase}:
+    END
+
+    if node_elem_name == "noex" or node_elem_name == "cflag" then
+      # noex and cflag point to an id but are really a long
+      node_elem_ref.sub!('id', 'cnt')
+    end
+
+    if node_elem_name == "rval" then
+      # rval points to a value but is really a node
+      node_elem_ref.sub!('value', 'node')
+      node_elem_name = '2nd'
+    end
+
+    case node_elem_ref
+    when /\.node/
+      puts <<-END
+      if(n->nd_#{node_elem_name})
+      {
+        int node_type;
+        if(#{node_elem_name == "next" ? 1 : 0} && nd_type(n) == NODE_OP_ASGN2)
+        {
+          /* All children of NODE_OP_ASGN2 are NODE_OP_ASGN2_ARG */
+          node_type = NODE_OP_ASGN2_ARG;
+        }
+        else
+        {
+          node_type = nd_type(n->nd_#{node_elem_name});
+        }
+
+        dump_node_or_iseq_to_hash(
+          (VALUE)n->nd_#{node_elem_name},
+          node_type,
+          node_hash);
+        return node_id(n->nd_#{node_elem_name});
+      }
+      else
+      {
+        return Qnil;
+      }
+      END
+    when /\.value$/
+      puts <<-END
+      switch(TYPE(n->nd_#{node_elem_name}))
+      {
+        case T_CLASS:
+        case T_MODULE:
+        {
+          /* When dumping a class, we dump just the name (otherwise we'd
+           * get multiple copies of the class each time we load a method
+           * on the other side).
+           */
+          VALUE klass = (VALUE)n->nd_#{node_elem_name};
+          VALUE path;
+          if(FL_TEST(klass, FL_SINGLETON))
+          {
+            VALUE singleton = rb_iv_get(klass, "__attached__");
+            path = rb_class_path(singleton);
+          }
+          else
+          {
+            path = rb_class_path(klass);
+            if(STR2CSTR(path)[0] == '#')
+            {
+              rb_raise(rb_eArgError, "cannot dump anonymous class");
+            }
+          }
+          return rb_assoc_new(
+              INT2NUM(((struct RBasic *)(n->nd_#{node_elem_name}))->flags),
+              path);
+        }
+
+        case T_NODE:
+          rb_raise(
+              rb_eRuntimeError,
+              "Wrong node elem #{node_elem_name} for node type %d",
+              nd_type(n));
+        
+        default:
+          /* TODO: would like to dump flags, not type */
+          return rb_assoc_new(
+              INT2NUM(TYPE((VALUE)n->nd_#{node_elem_name})),
+              (VALUE)n->nd_#{node_elem_name});
+      }
+      END
+    when /\.id$/
+      puts <<-END
+      if(n->nd_#{node_elem_name} == 0)
+      {
+        return Qfalse;
+      }
+      else if(n->nd_#{node_elem_name} == 1)
+      {
+        return Qtrue;
+      }
+      else
+      {
+        return ID2SYM(n->nd_#{node_elem_name});
+      }
+      END
+    when /\.(argc|state|cnt)$/
+      puts <<-END
+      {
+      return LONG2NUM((long)n->nd_#{node_elem_name});
+      }
+      END
+    when /\.(tbl)$/
+      puts <<-END
+      {
+      VALUE v = variable_names(n->nd_#{node_elem_name});
+      return v;
+      }
+      END
+    when /\.(entry)$/
+      puts <<-END
+      if(n->nd_#{node_elem_name}->id == 0)
+      {
+        return Qfalse;
+      }
+      else
+      {
+        return ID2SYM(n->nd_#{node_elem_name}->id);
+      }
+      END
+    when /\.(cfunc)$/
+      puts <<-END
+      /* rb_funcall(rb_cObject, rb_intern("pp"), wrap_node(n), 0); */
+      rb_raise(rb_eArgError, "Cannot dump #{$1}");
+      END
+    end
+  end
+  nil
+END
+  }
+  rb_raise(rb_eArgError, "Invalid Node_Elem_Name %d", nen);
+}
+
+void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash, VALUE id_hash)
+{
+  switch(nen)
+  {
+    case NEN_NONE:
+      return;
+#ruby <<END
+  NODEINFO.sort.each do |node_elem_name, node_elem_ref|
+    puts <<-END
+    case NEN_#{node_elem_name.upcase}:
+    {
+    END
+
+    if node_elem_name == "noex" or node_elem_name == "cflag" then
+      # noex and cflag point to an id but are really a long
+      node_elem_ref.sub!('id', 'cnt')
+    end
+
+    if node_elem_name == "rval" then
+      # rval points to a value but is really a node
+      node_elem_ref.sub!('value', 'node')
+      node_elem_name = '2nd'
+    end
+
+    case node_elem_ref
+    when /\.node$/
+      puts <<-END
+      if(v == Qnil)
+      {
+        n->nd_#{node_elem_name} = 0;
+      }
+      else
+      {
+        VALUE nid = rb_hash_aref(id_hash, v);
+        if(RTEST(nid))
+        {
+          n->nd_#{node_elem_name} = id_to_node(nid);
+        }
+        else
+        {
+          n->#{node_elem_ref} = (NODE *)load_node_or_iseq_from_hash(
+              v, node_hash, id_hash);
+          if(nd_type(n->#{node_elem_ref}) == NODE_OP_ASGN2_ARG)
+          {
+            nd_set_type(n->#{node_elem_ref}, NODE_OP_ASGN2);
+          }
+        }
+      }
+      return;
+      END
+    when /\.value$/
+      puts <<-END
+      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]);
+      switch(flags & T_MASK)
+      {
+        case T_CLASS:
+        case T_MODULE:
+        {
+          VALUE str = RARRAY_PTR(v)[1];
+          Check_Type(str, T_STRING);
+          VALUE klass = rb_path2class(STR2CSTR(str));
+          if(flags & FL_SINGLETON)
+          {
+            *(VALUE *)(&n->nd_#{node_elem_name}) =
+              rb_singleton_class(klass);
+          }
+          else
+          {
+            *(VALUE *)(&n->nd_#{node_elem_name}) =
+              klass;
+          }
+          break;
+        }
+        default:
+          *(VALUE *)(&n->nd_#{node_elem_name}) = RARRAY_PTR(v)[1];
+          break;
+      }
+      return;
+      END
+    when /\.id$/
+      puts <<-END
+      if(v == Qfalse)
+      {
+        n->nd_#{node_elem_name} = 0;
+      }
+      else if(v == Qfalse)
+      {
+        n->nd_#{node_elem_name} = 1;
+      }
+      else
+      {
+        n->nd_#{node_elem_name} = SYM2ID(v);
+      }
+      return;
+      END
+    when /\.(argc|state|cnt)$/
+      puts <<-END
+      n->nd_#{node_elem_name} = NUM2LONG(v);
+      return;
+      END
+    when /\.(tbl)$/
+      puts <<-END
+      if(v == Qnil)
+      {
+        n->nd_#{node_elem_name} = 0;
+      }
+      else
+      {
+        size_t len, j;
+        ID * tmp_tbl;
+
+        Check_Type(v, T_ARRAY);
+        len = RARRAY_LEN(v);
+        tmp_tbl = ALLOCA_N(ID, len + 3);
+        tmp_tbl[0] = (ID)(len + 2);
+        tmp_tbl[1] = (ID)('_');
+        tmp_tbl[2] = (ID)('~');
+        for(j = 0; j < len; ++j)
+        {
+          VALUE e = RARRAY_PTR(v)[j];
+          if(e == Qnil)
+          {
+            /* flip state */
+            tmp_tbl[j + 3] = 0;
+          }
+          else
+          {
+            tmp_tbl[j + 3] = SYM2ID(e);
+          }
+        }
+        n->nd_#{node_elem_name} = ALLOC_N(ID, len + 3);
+        memcpy(n->nd_#{node_elem_name}, tmp_tbl, sizeof(ID) * (len + 3));
+      }
+      return;
+      END
+    when /\.(entry)$/
+      puts <<-END
+      n->nd_#{node_elem_name} = rb_global_entry(SYM2ID(v));
+      return;
+      END
+    when /\.(cfunc)$/
+      puts <<-END
+      rb_raise(rb_eRuntimeError, "Cannot load #{$1}");
+      END
+    end
+    puts <<-END
+      }
+    END
+  end
+  nil
+END
+  }
+  rb_raise(rb_eRuntimeError, "Internal error: invalid Node_Elem_Name %d", nen);
+}
+
+#ruby <<END
+  NODEINFO.sort.each do |node_elem_name, node_elem_ref|
+    # get rid of warning about unused functions
+    nen = node_elem_name.upcase
+    next if NEN_TO_NODE_TYPE[nen].nil?
+
+    if node_elem_name == "noex" or node_elem_name == "cflag" then
+      # noex and cflag point to an id but are really a long
+      node_elem_ref.sub!('id', 'cnt')
+    end
+
+    case node_elem_ref
+    when /\.node$/, /\.value$/
+      puts <<-END
+/*
+ * Return the Node's _#{node_elem_name}_ member.  The return type is
+ * either a Node or an Object.
+ */
+static VALUE node_#{node_elem_name}(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+
+  if(TYPE(n->nd_#{node_elem_name}) == T_NODE)
+  {
+    if(#{node_elem_name == "next" ? 1 : 0} && nd_type(n) == NODE_OP_ASGN2)
+    {
+      return wrap_node_as(
+        (NODE *)n->nd_#{node_elem_name},
+        rb_cNodeSubclass[NODE_OP_ASGN2_ARG]);
+    }
+    else
+    {
+      return wrap_node((NODE *)n->nd_#{node_elem_name});
+    }
+  }
+  else
+  {
+    return (VALUE)n->nd_#{node_elem_name};
+  }
+}
+      END
+    when /\.id$/
+      puts <<-END
+/*
+ * Return the Node's _#{node_elem_name}_ member.  The return type is a
+ * Symbol.
+ */
+static VALUE node_#{node_elem_name}(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+  if(n->nd_#{node_elem_name} == 0)
+  {
+    return Qfalse;
+  }
+  else if(n->nd_#{node_elem_name} == 1)
+  {
+    return Qtrue;
+  }
+  else
+  {
+    return ID2SYM(n->nd_#{node_elem_name});
+  }
+}
+      END
+    when /\.(argc|state|cnt)$/
+      puts <<-END
+/*
+ * Return the Node's _#{node_elem_name}_ member.  The return type is an
+ * Integer.
+ */
+static VALUE node_#{node_elem_name}(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+  return LONG2NUM(n->nd_#{node_elem_name});
+}
+      END
+    when /\.(tbl)$/
+      puts <<-END
+/*
+ * Return the Node's _#{node_elem_name}_ member.  The return value is an
+ * Array holding names of variables.
+ */
+static VALUE node_#{node_elem_name}(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+  return variable_names(n->nd_#{node_elem_name});
+}
+      END
+    when /\.(entry)$/
+      puts <<-END
+/*
+ * Return the Node's _#{node_elem_name}_ member.  The return type is
+ * either a Node or an Object.
+ */
+static VALUE node_#{node_elem_name}(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+  if(n->nd_#{node_elem_name}->id == 0)
+  {
+    return Qfalse;
+  }
+  else
+  {
+    return ID2SYM(n->nd_#{node_elem_name}->id);
+  }
+}
+      END
+    when /\.(cfunc)$/
+      puts <<-END
+static VALUE node_#{node_elem_name}(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+  return LONG2NUM((long)(n->nd_#{node_elem_name}));
+}
+      END
+    end
+  end
+  nil
+END
+
+/*
+ * Return an array of strings containing the names of the node class's
+ * members.
+ */
+VALUE node_s_members(VALUE klass)
+{
+  return rb_iv_get(klass, "__member__");
+}
+
+#ruby <<END
+  nodes = Nodes.new
+  nil
+END
+
+void define_node_subclass_methods()
+{
+  /* For rdoc: rb_cNode = rb_define_class("Node", rb_cObject); */
+  VALUE rb_cNode = rb_const_get(rb_cObject, rb_intern("Node"));
+  VALUE members;
+  int j;
+
+  for(j = 0; j < NODE_LAST; ++j)
+  {
+    rb_cNodeSubclass[j] = Qnil;
+  }
+
+#ruby <<END
+  ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
+
+  nodes.each do |key, node|
+
+    version_range = node.version_range
+    next if not version_range.includes?(ruby_version_code)
+
+    node_type = "rb_c#{node.name}"
+
+    if node.doc then
+      doc = "\n  /* Document-class: Node::#{node.name}"
+      node.doc.each_line do |line|
+        doc << "\n   * #{line.chomp}"
+      end
+      doc << "\n   */\n"
+      puts doc
+    else
+      $stderr.puts "WARNING: No documentation for #{node.name}"
+    end
+
+    if node.name == 'ALLOCA' then
+      puts <<-END
+#ifdef HAVE_NODE_ALLOCA
+      END
+    end
+
+    puts <<-END
+  {
+    VALUE #{node_type} = rb_define_class_under(rb_cNode, "#{node.name}", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_#{node.name}] = #{node_type};
+    rb_iv_set(#{node_type}, "__member__", members);
+    rb_iv_set(#{node_type}, "__type__", INT2NUM(NODE_#{node.name}));
+    rb_define_singleton_method(#{node_type}, "members", node_s_members, 0);
+    END
+    node.members.each do |member_name, member|
+      mname = member_name
+      mname = 'first' if member_name == '1st'
+      mname = 'second' if member_name == '2nd'
+      if member.doc then
+        doc = "\n    /* Document-method: #{mname}"
+        member.doc.each_line do |line|
+          doc << "\n     * #{line.chomp}"
+        end
+        doc << "\n     */\n"
+        puts doc
+      end
+      puts <<-END
+    rb_define_method(#{node_type}, "#{mname}", node_#{member_name}, 0);
+    rb_ary_push(members, rb_str_new2("#{mname}"));
+      END
+    end
+    puts <<-END
+  }
+    END
+
+    if node.name == 'ALLOCA' then
+      puts <<-END
+#endif
+      END
+    end
+
+  end
+  nil
+END
+}
+
+