ruby-internal 0.6.0

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

@@ -0,0 +1,30 @@
+#ifndef nodeinfo_h
+#define nodeinfo_h
+
+#include "ruby_internal_node.h"
+
+#include "ruby.h"
+
+enum Node_Elem_Name
+{
+  NEN_NONE,
+#ruby <<END
+  require 'read_node_h.rb'
+
+  NODEINFO.sort.each do |node_elem_name, node_elem_ref|
+    puts "  NEN_#{node_elem_name.upcase},"
+  end
+  nil
+END
+};
+
+VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash);
+void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash, VALUE id_hash);
+VALUE node_s_members(VALUE klass);
+void define_node_subclass_methods();
+
+#define NODE_OP_ASGN2_ARG NODE_LAST + 1
+#define NUM_NODE_TYPE_DESCRIPS NODE_OP_ASGN2_ARG + 1
+
+#endif
+

data/ext/internal/node/nodes.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+
+class NodeVersionRange
+  def initialize(str)
+    if not str or str =~ /^\s*$/ then
+      @inclusive_start = true
+      @range_start = 0
+      @range_end = 1.0 / 0
+      @inclusive_end = true
+    elsif str =~ / ([\[(]) (.*?), \s* (.*?) ([\])]) /x then
+      @inclusive_start = $1 == '['
+      @range_start = $2.to_i
+      @range_end = $3 == 'oo' ? (1.0 / 0) : $3.to_i
+      @inclusive_end = $4 == ']'
+    else
+      raise "Invalid version range: #{str}"
+    end
+  end
+
+  def includes?(version_code)
+    if @inclusive_start then
+      return false if version_code < @range_start
+    else
+      return false if version_code <= @range_start
+    end
+
+    if @inclusive_end then
+      return false if version_code > @range_end
+    else
+      return false if version_code >= @range_end
+    end
+
+    return true
+  end
+end
+
+class Nodes
+  NodeInfo = Struct.new(:name, :doc, :members, :version_range)
+  MemberInfo = Struct.new(:doc, :type)
+
+  def initialize(filename = nil)
+    if not filename then
+      dir = File.dirname(__FILE__)
+      filename = File.join(dir, 'nodes.yaml')
+    end
+    nodes = File.open(filename) { |io| YAML.load(io) }
+
+    @nodes = {}
+    nodes.each do |name, node|
+      members = {}
+      (node['members'] || {}).each do |member_name, member|
+        member ||= {}
+        members[member_name] = MemberInfo.new(
+            member['doc'],
+            member['type'])
+      end
+      version_range = NodeVersionRange.new(node['version'])
+      @nodes[name] = NodeInfo.new(
+          name.gsub(/\(.*\)/, ''),
+          node['doc'],
+          members,
+          version_range)
+    end
+  end
+
+  def each(&block)
+    @nodes.each(&block)
+  end
+
+  def [](name)
+    @nodes[name]
+  end
+
+  def include?(name)
+    @nodes.include?(name)
+  end
+end
+

data/ext/internal/node/read_node_h.rb

@@ -0,0 +1,34 @@
+$: << '../..'
+require 'ruby_source_dir'
+
+NODE_H_LOCATION = "#{RUBY_INCLUDE_DIR}/node.h"
+NODE_H_ALT_LOCATION = "#{RUBY_SOURCE_DIR}/node.h"
+
+def open_alt(*files, &block)
+  last_exc = nil
+  files.each do |file|
+    begin
+      File.open(file, &block)
+      return
+    rescue Errno::ENOENT
+      last_exc = $!
+    end
+  end
+  raise last_exc
+end
+
+NODEINFO = Hash.new
+open_alt(NODE_H_LOCATION, NODE_H_ALT_LOCATION) do |node_h|
+  while line = node_h.gets do
+    case line
+    when /^#define\s+nd_(\w+)\s+(.*)/
+      NODEINFO[$1] = $2
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  require 'pp'
+  pp NODEINFO
+end
+

data/ext/internal/node/ruby_internal_node.h

@@ -0,0 +1,31 @@
+#ifndef ruby_internal_node__h_
+#define ruby_internal_node__h_
+
+#include <ruby.h>
+
+#if defined(HAVE_NODE_H)
+#include "node.h"
+#elif defined(HAVE_RUBY_NODE_H)
+#include "ruby/node.h"
+#endif
+
+VALUE wrap_node(NODE * n);
+VALUE wrap_node_as(NODE * n, VALUE klass);
+
+NODE * unwrap_node(VALUE r);
+
+VALUE node_id(NODE * n);
+NODE * id_to_node(VALUE id);
+
+VALUE eval_ruby_node(NODE * node, VALUE self, VALUE cref);
+
+void dump_node_or_iseq_to_hash(VALUE n, int node_type, VALUE node_hash);
+VALUE load_node_or_iseq_from_hash(VALUE node_id, VALUE node_hash, VALUE id_hash);
+
+void dump_node_to_hash(NODE * n, int node_type, VALUE node_hash);
+NODE * load_node_from_hash(VALUE arr, VALUE orig_node_id, VALUE node_hash, VALUE id_hash);
+
+extern VALUE rb_cNodeSubclass[NODE_LAST];
+
+#endif
+

data/ext/internal/noex/extconf.rb

@@ -0,0 +1,6 @@
+$: << '../..'
+require 'mkmf-ruby-internal'
+
+have_header('ruby/node.h') or have_header('node.h')
+
+create_ruby_internal_makefile 'internal/noex/noex'

data/ext/internal/noex/noex.c

@@ -0,0 +1,44 @@
+#include <ruby.h>
+
+#include "internal/node/ruby_internal_node.h"
+
+void Init_noex(void)
+{
+  /*
+   * Document-module: Noex
+   *
+   * The Noex module contains all the Noex constants from node.h.  These
+   * constants can be passed to Module#add_method as modifiers to the
+   * method being added.
+   * 
+   * [+PUBLIC+]     Method is public.
+   * [+UNDEF+]      Method is undefined.
+   * [+PRIVATE+]    Method is private.
+   * [+PROTECTED+]  Method is protected.
+   *
+   * The following are available in Ruby 1.8 and below:
+   * [+CFUNC+]      Method is a C function.
+   *
+   * And these are available in Ruby 1.9 and above:
+   * [+NOSUPER+]    ???
+   * [+MASK+]       ???
+   */
+  VALUE rb_mNoex = rb_define_module("Noex");
+  rb_define_const(rb_mNoex, "PUBLIC",    INT2NUM(NOEX_PUBLIC));
+  rb_define_const(rb_mNoex, "UNDEF",     INT2NUM(NOEX_UNDEF));
+  rb_define_const(rb_mNoex, "PRIVATE",   INT2NUM(NOEX_PRIVATE));
+  rb_define_const(rb_mNoex, "PROTECTED", INT2NUM(NOEX_PROTECTED));
+
+#ifdef NOEX_CFUNC
+  rb_define_const(rb_mNoex, "CFUNC",     INT2NUM(NOEX_CFUNC));
+#endif
+
+#ifdef NOEX_NOSUPER
+  rb_define_const(rb_mNoex, "NOSUPER",   INT2NUM(NOEX_NOSUPER));
+#endif
+
+#ifdef NOEX_MASK
+  rb_define_const(rb_mNoex, "MASK",      INT2NUM(NOEX_MASK));
+#endif
+}
+

data/ext/internal/object/extconf.rb

@@ -0,0 +1,4 @@
+$: << '../..'
+require 'mkmf-ruby-internal'
+
+create_ruby_internal_makefile 'internal/object/object'

data/ext/internal/object/object.c

@@ -0,0 +1,75 @@
+#include <ruby.h>
+
+/*
+ * call-seq:
+ *   class.real_class => Class
+ *
+ * Return the object's first immediate ancestor; this may be the
+ * object's class, its singleton class, or a module singleton.
+ */
+static VALUE real_class(VALUE self)
+{
+  if(IMMEDIATE_P(self))
+  {
+    return CLASS_OF(self);
+  }
+  else
+  {
+    return RBASIC(self)->klass;
+  }
+}
+
+/*
+ * call-seq:
+ *   class.singleton? => true or false
+ *
+ * Return true if this object is a singleton (that is, it has the
+ * FL_SINGLETON flag set).
+ */
+static VALUE is_singleton(VALUE self)
+{
+  return FL_TEST(self, FL_SINGLETON) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   class.has_singleton? => true or false
+ *
+ * Return true if this object has a singleton class.
+ */
+static VALUE has_singleton(VALUE self)
+{
+  if(FIXNUM_P(self) || SYMBOL_P(self))
+  {
+    return Qfalse;
+  }
+  else if(rb_special_const_p(self))
+  {
+    return Qtrue;
+  }
+  else
+  {
+    return FL_TEST(RBASIC(self)->klass, FL_SINGLETON) ? Qtrue : Qfalse;
+  }
+}
+
+/*
+ * call-seq:
+ *   class.singleton_class => Class
+ *
+ * Return the object's singleton class.  Creats a new singleton class
+ * for the object if it does not have one.  See RCR#231.
+ */
+static VALUE singleton_class(VALUE self)
+{
+  return rb_singleton_class(self);
+}
+
+void Init_object(void)
+{
+  rb_define_method(rb_mKernel, "real_class", real_class, 0);
+  rb_define_method(rb_mKernel, "singleton?", is_singleton, 0);
+  rb_define_method(rb_mKernel, "has_singleton?", has_singleton, 0);
+  rb_define_method(rb_mKernel, "singleton_class", singleton_class, 0);
+}
+

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

@@ -0,0 +1,44 @@
+#ifndef ruby_internal_block__h_
+#define ruby_internal_block__h_
+
+#include <ruby.h>
+
+#ifndef RUBY_VM
+#include "env.h"
+#endif
+
+#ruby <<END
+  $: << '../..'
+  require 'ruby_source_dir'
+  vm_c_location = "#{RUBY_SOURCE_DIR}/vm.c"
+  eval_c_location = "#{RUBY_SOURCE_DIR}/eval.c"
+
+  [ vm_c_location, eval_c_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |eval_c|
+      write = false
+      stopwrite = false
+      while (line = eval_c.gets) != nil do
+        case line
+        when /^struct (BLOCK)/
+          write = true
+          stopwrite = false
+        when /^\}/
+          stopwrite = true
+        end
+        puts line if write
+        if write and stopwrite then
+          stopwrite = false
+          write = false
+          puts ''
+        end
+      end
+    end
+  end
+
+  nil
+END
+
+#endif
+

data/ext/internal/proc/extconf.rb

@@ -0,0 +1,9 @@
+$: << '../..'
+require 'mkmf-ruby-internal'
+
+have_header('iseq.h')
+
+have_header('ruby/node.h') or have_header('node.h')
+
+create_ruby_internal_makefile 'internal/proc/proc'
+

data/ext/internal/proc/proc.c

@@ -0,0 +1,331 @@
+#include <ruby.h>
+#include "internal/node/ruby_internal_node.h"
+#include "block.h"
+
+#ifdef RUBY_VM
+#include "vm_core.h"
+#endif
+
+#ifdef HAVE_ISEQ_H
+#include "iseq.h"
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+static VALUE rb_cUnboundProc = Qnil;
+
+static VALUE rb_mMarshal;
+
+static VALUE marshal_dump(VALUE obj, VALUE limit)
+{
+  return rb_funcall(rb_mMarshal, rb_intern("dump"), 2, obj, limit);
+}
+
+static VALUE marshal_load(VALUE obj)
+{
+  return rb_funcall(rb_mMarshal, rb_intern("load"), 1, obj);
+}
+
+/*
+ * call-seq:
+ *   proc.body => Node
+ *
+ * Returns the Proc's body Node.
+ *
+ * On YARV, this will return the instruction sequence for the proc's
+ * block.
+ */
+static VALUE proc_body(VALUE self)
+{
+#ifdef RUBY_VM
+  rb_proc_t * p;
+  GetProcPtr(self, p);
+  return p->block.iseq->self;
+#else
+  struct BLOCK * b;
+  if(rb_safe_level() >= 4)
+  {
+    /* no access to potentially sensitive data from the sandbox */
+    rb_raise(rb_eSecurityError, "Insecure: can't get proc body");
+  }
+  Data_Get_Struct(self, struct BLOCK, b);
+  return wrap_node(b->body);
+#endif
+}
+
+#ifndef RUBY_VM
+/*
+ * call-seq:
+ *   proc.var => Node
+ *
+ * Returns the Proc's argument Node.
+ *
+ * This method is undefined on YARV.
+ */
+static VALUE proc_var(VALUE self)
+{
+  struct BLOCK * b;
+  if(rb_safe_level() >= 4)
+  {
+    /* no access to potentially sensitive data from the sandbox */
+    rb_raise(rb_eSecurityError, "Insecure: can't get proc var");
+  }
+  Data_Get_Struct(self, struct BLOCK, b);
+  if(b->var == (NODE*)1)
+  {
+    /* no parameter || */
+    return INT2NUM(1);
+  }
+  else if(b->var == (NODE*)2)
+  {
+    /* also no params, but I'm not sure how this one gets generated */
+    return INT2NUM(2);
+  }
+  else
+  {
+    return wrap_node(b->var);
+  }
+}
+
+#else
+
+/* From iseq.c */
+static rb_iseq_t *
+iseq_check(VALUE val)
+{
+  rb_iseq_t *iseq;
+  if(!rb_obj_is_kind_of(val, rb_cISeq))
+  {
+    rb_raise(
+        rb_eTypeError,
+        "Expected VM::InstructionSequence, but got %s",
+        rb_class2name(CLASS_OF(val)));
+  }
+  GetISeqPtr(val, iseq);
+  if (!iseq->name) {
+    rb_raise(rb_eTypeError, "uninitialized InstructionSequence");
+  }
+  return iseq;
+}
+
+#endif
+
+/*
+ * call-seq:
+ *   proc.dump(limit) => String
+ *
+ * Dump a Proc to a String.
+ */
+static VALUE proc_dump(VALUE self, VALUE limit)
+{
+  if(rb_safe_level() >= 4)
+  {
+    /* no access to potentially sensitive data from the sandbox */
+    rb_raise(rb_eSecurityError, "Insecure: can't dump proc");
+  }
+
+  {
+#ifdef RUBY_VM
+    rb_proc_t * p;
+    VALUE iseq;
+    rb_iseq_t * iseqdat;
+    GetProcPtr(self, p);
+    iseq = p->block.iseq->self;
+    iseqdat = iseq_check(iseq);
+    iseqdat->type = ISEQ_TYPE_TOP; /* TODO: is this right? */
+    VALUE str = marshal_dump(iseq, limit);
+    return str;
+#else
+    struct BLOCK * b;
+    VALUE body, var, arr;
+
+    Data_Get_Struct(self, struct BLOCK, b);
+    body = wrap_node(b->body);
+    var = wrap_node(b->var);
+    arr = rb_assoc_new(body, var);
+    return marshal_dump(arr, limit);
+#endif
+  }
+}
+
+#ifdef RUBY_VM
+
+static VALUE create_proc(VALUE klass, VALUE binding, rb_iseq_t * iseq)
+{
+  VALUE new_proc;
+  rb_proc_t * p;
+
+  if(binding == Qnil)
+  {
+    binding = rb_binding_new();
+  }
+  new_proc = rb_funcall(
+      rb_cObject, rb_intern("eval"), 2, rb_str_new2("proc { }"), binding);
+  GetProcPtr(new_proc, p);
+  p->block.iseq = iseq;
+  RBASIC(new_proc)->klass = klass;
+  return new_proc;
+}
+
+#else
+
+static VALUE create_proc(VALUE klass, VALUE binding, NODE * body, NODE * var)
+{
+  /* Calling eval will do a security check */
+  VALUE new_proc = rb_funcall(
+      rb_cObject, rb_intern("eval"), 2, rb_str_new2("proc { }"), binding);
+  struct BLOCK * b;
+  Data_Get_Struct(new_proc, struct BLOCK, b);
+  b->body = body;
+  b->var = var;
+  RBASIC(new_proc)->klass = klass;
+  return new_proc;
+}
+
+#endif
+
+/*
+ * call-seq:
+ *   Proc.load(str) => UnboundProc
+ *
+ * Load a Proc from a String.  When it is loaded, it will be an
+ * UnboundProc, until it is bound to a Binding with UnboundProc#bind.
+ */
+static VALUE proc_load(VALUE klass, VALUE str)
+{
+#ifdef RUBY_VM
+  VALUE iseq = marshal_load(str);
+  return create_proc(rb_cUnboundProc, Qnil, iseq_check(iseq));
+#else
+  VALUE arr = marshal_load(str);
+  NODE * body, * var;
+
+  if(   rb_safe_level() >= 4
+     || (rb_safe_level() >= 1 && OBJ_TAINTED(str)))
+  {
+    /* no playing with knives in the sandbox */
+    rb_raise(rb_eSecurityError, "Insecure: can't load proc");
+  }
+
+  Check_Type(arr, T_ARRAY);
+  body = unwrap_node(RARRAY_PTR(arr)[0]);
+  var = unwrap_node(RARRAY_PTR(arr)[1]);
+  return create_proc(rb_cUnboundProc, Qnil, body, var);
+#endif
+}
+
+/*
+ * call-seq:
+ *   proc.unbind => UnboundProc
+ *
+ * Create an UnboundProc from a Proc.
+ */
+static VALUE proc_unbind(VALUE self)
+{
+#ifdef RUBY_VM
+  rb_proc_t * p;
+  GetProcPtr(self, p);
+  return create_proc(rb_cUnboundProc, Qnil, p->block.iseq);
+#else
+  struct BLOCK * b;
+  Data_Get_Struct(self, struct BLOCK, b);
+  /* no need for a security check to unbind a proc -- though without the
+   * ability to bind, this doesn't seem very useful.
+   */
+  return create_proc(rb_cUnboundProc, Qnil, b->body, b->var);
+#endif
+}
+
+/*
+ * call-seq:
+ *   proc.push(anotherProc) => self
+ *
+ * Append the body of anotherProc onto proc.
+ */
+static VALUE proc_push(VALUE self, VALUE other)
+{
+#ifdef RUBY_VM
+  rb_raise(rb_eRuntimeError, "Proc#push not implemented yet for YARV");
+#else
+  struct BLOCK * b1;
+  struct BLOCK * b2;
+  Data_Get_Struct(self, struct BLOCK, b1);
+  Data_Get_Struct(other, struct BLOCK, b2);
+  b1->body = NEW_NODE(NODE_BLOCK, b1->body, 0, b2->body);
+  return self;
+#endif
+}
+
+/*
+ * call-seq:
+ *   unbound_proc.bind(Binding) => Proc
+ *
+ * Bind an UnboundProc to a Binding.  Returns a Proc that has been bound
+ * to the given binding.
+ */
+static VALUE unboundproc_bind(VALUE self, VALUE binding)
+{
+#ifdef RUBY_VM
+  rb_proc_t * p;
+  GetProcPtr(self, p);
+  return create_proc(rb_cProc, binding, p->block.iseq);
+#else
+  struct BLOCK * b;
+  Data_Get_Struct(self, struct BLOCK, b);
+  /* create_proc will do a security check */
+  return create_proc(rb_cProc, binding, b->body, b->var);
+#endif
+}
+
+/*
+ * call-seq:
+ *   unbound_proc.call => raises TypeError
+ *
+ * Raises a TypeError; UnboundProc objects cannot be called.
+ */
+static VALUE unboundproc_call(VALUE self, VALUE args)
+{
+  rb_raise(rb_eTypeError, "you cannot call unbound proc; bind first");
+}
+
+/*
+ * call-seq:
+ *   unbound_proc.binding => raises TypeError
+ *
+ * Raises a TypeError; UnboundProc objects have no binding.
+ */
+static VALUE unboundproc_binding(VALUE self)
+{
+  rb_raise(rb_eTypeError, "unbound proc has no binding");
+}
+
+void Init_proc(void)
+{
+  rb_require("internal/node");
+
+  rb_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
+
+  /* For rdoc: rb_cProc = rb_define_class("Proc", rb_cObject) */
+  rb_define_method(rb_cProc, "body", proc_body, 0);
+#ifndef RUBY_VM
+  rb_define_method(rb_cProc, "var", proc_var, 0);
+#endif
+  rb_define_method(rb_cProc, "unbind", proc_unbind, 0);
+  rb_define_method(rb_cProc, "<<", proc_push, 1);
+  rb_define_method(rb_cProc, "push", proc_push, 1);
+  rb_define_method(rb_cProc, "_dump", proc_dump, 1);
+  rb_define_singleton_method(rb_cProc, "_load", proc_load, 1);
+
+  rb_cUnboundProc = rb_define_class("UnboundProc", rb_cProc);
+  rb_define_method(rb_cUnboundProc, "bind", unboundproc_bind, 1);
+  rb_define_method(rb_cUnboundProc, "call", unboundproc_call, -2);
+  rb_define_method(rb_cUnboundProc, "[]", unboundproc_call, -2);
+  rb_define_method(rb_cUnboundProc, "binding", unboundproc_binding, 0);
+}
+