rubynode 0.1.1 → 0.1.2

data/Changelog

@@ -1,5 +1,9 @@
 Changelog
 
+-- 0.1.2
+
+* Out of the box 1.8.5-p2 and 1.8.5-p12 support
+
 -- 0.1.1
 
 * RubyNode is available as gem now

data/README

@@ -14,9 +14,9 @@ s-expressions), which are easy to manipulate and work with.
 Requirements
 ------------
 
-RubyNode is tested with Ruby 1.8.4 and 1.8.5, but it should also work with
-other 1.8 versions and also with 1.9 (but there might be some node types that
-are not fully supported).
+RubyNode is tested with Ruby 1.8.4 and 1.8.5 (including patchlevels 2 and 12),
+but it should also work with other 1.8 versions and also with 1.9 (but there
+might be some node types that are not fully supported).
 
 
 Installation
@@ -25,9 +25,10 @@ Installation
 RubyNode generates some of its C source code from Ruby's source code, because
 the node types and other details differ between Ruby versions.
 
-For the official releases of Ruby 1.8.4 and 1.8.5 the needed source files are
-included in the package. To compile RubyNode for any other Ruby version, you
-will need that version's source tar ball extracted somewhere.
+For the official releases of Ruby 1.8.4 and 1.8.5 (including patchlevels 2 and
+12) the needed source files are included in the package. To compile RubyNode
+for any other Ruby version, you will need that version's source tar ball
+extracted somewhere.
 
 So, for Ruby 1.8.4 and 1.8.5 just run (as root):
 

data/doc/api.html

@@ -9,7 +9,7 @@
 
 
 	<p>RubyNode consists of two parts: a C extension, which provides the core
-functionality and a Ruby library, which adds additional functionality.</p>
+functionality, and a Ruby library, which adds additional functionality.</p>
 
 
 	<p>To get only the C extension <code>require "rubynode_ext"</code>, to get the full
@@ -23,7 +23,7 @@ functionality (recommended) just <code>require "rubynode"</code>.</p>
 
 
 	<p>Ruby mainly uses the NODEs to store the <span class="caps">AST</span> (abstract syntax tree) of parsed
-Ruby files, but they are also used for some other things. On the C side, <span class="caps">NODE</span>
+Ruby files, but they are also used for some other things. On the C side <span class="caps">NODE</span>
 is a struct:</p>
 
 
@@ -135,11 +135,11 @@ interchangeably, they are just aliases.</p>
 
 
 	<p><code>u1_as_long</code>, <code>u2_argc</code>, <code>u3_cnt</code> and <code>u3_state</code> always return the raw &#8220;long&#8221;,
-that is stored in the union as Integer.</p>
+that is stored in the union, as Integer.</p>
 
 
 	<p><code>u1_cfunc</code> returns the unsigned value of the function pointer, that is stored
-in the union as Integer.</p>
+in the union, as Integer.</p>
 
 
 	<p><code>u1_tbl</code> returns the local variable table for a scope node as an Array, for
@@ -147,7 +147,7 @@ all other node types it returns <code>nil</code>.</p>
 
 
 	<p>All these methods never raise exceptions, they just return <code>nil</code>, if the
-value, that is stored in the union does not have the requested type.</p>
+value that is stored in the union does not have the requested type.</p>
 
 
 	<p><code>u3.entry</code> is not supported (for obvious reasons).</p>
@@ -216,7 +216,7 @@ Those nodes can be accessed using the methods <code>body_node</code>, <code>var_
 
 	<p>RubyNode adds a <code>parse_to_nodes</code> method to String, which will parse the given
 string using Ruby&#8217;s parser. The parsing will be done in the current
-context/binding/scope, so it basically returns the <span class="caps">AST</span>, that eval would see,
+context/binding/scope, so it basically returns the <span class="caps">AST</span> that eval would see,
 given this string.</p>
 
 
@@ -264,7 +264,7 @@ something like the following:</p>
 =&gt; {:lit=&gt;2}
 </code></pre>
 
-	<p>So, there is an even nicer way: the method <code>transform</code>. It is basically a
+	<p>So, there is an even better way: the method <code>transform</code>. It is basically a
 recursive version of <code>attribs_hash</code>, it transforms a node tree into a tree of
 arrays and hashes. Example:</p>
 

data/doc/index.html

@@ -24,9 +24,9 @@ s-expressions), which are easy to manipulate and work with.</p>
 	<h2 id="section1">Requirements</h2>
 
 
-	<p>RubyNode is tested with Ruby 1.8.4 and 1.8.5, but it should also work with
-other 1.8 versions and also with 1.9 (but there might be some node types that
-are not fully supported).</p>
+	<p>RubyNode is tested with Ruby 1.8.4 and 1.8.5 (including patchlevels 2 and 12),
+but it should also work with other 1.8 versions and also with 1.9 (but there
+might be some node types that are not fully supported).</p>
 
 
 	<h2 id="section2">Download</h2>
@@ -45,9 +45,10 @@ are not fully supported).</p>
 the node types and other details differ between Ruby versions.</p>
 
 
-	<p>For the official releases of Ruby 1.8.4 and 1.8.5 the needed source files are
-included in the package. To compile RubyNode for any other Ruby version, you
-will need that version&#8217;s source tar ball extracted somewhere.</p>
+	<p>For the official releases of Ruby 1.8.4 and 1.8.5 (including patchlevels 2 and
+12) the needed source files are included in the package. To compile RubyNode
+for any other Ruby version, you will need that version&#8217;s source tar ball
+extracted somewhere.</p>
 
 
 	<p>So, for <strong>Ruby 1.8.4</strong> and <strong>1.8.5</strong> just run (as root):</p>

data/ext/rubynode_ext/extconf.rb

@@ -1,13 +1,21 @@
 require "mkmf"
 
-begin
-	$rbsrcdir = File.join(File.dirname(__FILE__), "ruby_src/#{RUBY_VERSION}_#{RUBY_RELEASE_DATE}")
+def ruby_source_dir_error(extra = nil)
+	warn "==================== ERROR ====================="
+	if extra
+		warn extra
+		warn ""
+	end
+	warn "Please set RUBY_SOURCE_DIR to the source path of ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})!"
+	warn "================================================"
+	exit! 1
+end
 
-	$rbsrcdir = ENV["RUBY_SOURCE_DIR"] unless File.directory? $rbsrcdir
+begin
+	$rbsrcdir = ENV["RUBY_SOURCE_DIR"] || File.join(File.dirname(__FILE__), "ruby_src/#{RUBY_VERSION}_#{RUBY_RELEASE_DATE}")
 
-	unless $rbsrcdir
-		warn "RUBY_SOURCE_DIR not set, please set it to the source path of ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})!"
-		exit! 1
+	unless File.directory? $rbsrcdir
+		ruby_source_dir_error
 	end
 
 	node_h = IO.read(File.join($rbsrcdir, "node.h"))
@@ -15,12 +23,8 @@ begin
 	eval_c = IO.read(File.join($rbsrcdir, "eval.c"))
 	# check if $hdrdir is "compatible" with $rbsrcdir
 	unless node_h == IO.read(File.join($hdrdir, "node.h"))
-		warn File.join($hdrdir, "node.h")
-		warn "is different from"
-		warn File.join($rbsrcdir, "node.h")
-		warn ""
-		warn "Please set RUBY_SOURCE_DIR to the source path of ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})!"
-		exit! 1
+		ruby_source_dir_error(File.join($hdrdir, "node.h") +
+			"\nis different from\n" + File.join($rbsrcdir, "node.h"))
 	end
 
 	raise "node.h does not contain 'enum node_type'" unless node_h =~ /enum node_type \{(.*?)\};/m

data/ext/rubynode_ext/ruby_src/1.8.5_2006-12-04/eval.c

@@ -0,0 +1,44 @@
+/**********************************************************************
+
+  eval.c -
+
+  $Author: matz $
+  $Date: 2006/08/07 03:43:39 $
+  created at: Thu Jun 10 14:22:17 JST 1993
+
+  Copyright (C) 1993-2003 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+
+**********************************************************************/
+
+/* extract from eval.c from ruby 1.8.5 */
+
+struct BLOCK {
+    NODE *var;
+    NODE *body;
+    VALUE self;
+    struct FRAME frame;
+    struct SCOPE *scope;
+    VALUE klass;
+    NODE *cref;
+    int iter;
+    int vmode;
+    int flags;
+    int uniq;
+    struct RVarmap *dyna_vars;
+    VALUE orig_thread;
+    VALUE wrapper;
+    VALUE block_obj;
+    struct BLOCK *outer;
+    struct BLOCK *prev;
+};
+
+struct METHOD {
+    VALUE klass, rklass;
+    VALUE recv;
+    ID id, oid;
+    int safe_level;
+    NODE *body;
+};
+

data/ext/rubynode_ext/ruby_src/1.8.5_2006-12-04/gc.c

@@ -0,0 +1,272 @@
+/**********************************************************************
+
+  gc.c -
+
+  $Author: matz $
+  $Date: 2006/08/25 08:12:46 $
+  created at: Tue Oct  5 09:44:46 JST 1993
+
+  Copyright (C) 1993-2003 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+
+**********************************************************************/
+
+/* extract from gc.c from ruby 1.8.5 */
+
+static void
+gc_mark_children(ptr, lev)
+    VALUE ptr;
+    int lev;
+{
+    register RVALUE *obj = RANY(ptr);
+
+    goto marking;		/* skip */
+
+  again:
+    obj = RANY(ptr);
+    if (rb_special_const_p(ptr)) return; /* special const not marked */
+    if (obj->as.basic.flags == 0) return;       /* free cell */
+    if (obj->as.basic.flags & FL_MARK) return;  /* already marked */
+    obj->as.basic.flags |= FL_MARK;
+
+  marking:
+    if (FL_TEST(obj, FL_EXIVAR)) {
+	rb_mark_generic_ivar(ptr);
+    }
+
+    switch (obj->as.basic.flags & T_MASK) {
+      case T_NIL:
+      case T_FIXNUM:
+	rb_bug("rb_gc_mark() called for broken object");
+	break;
+
+      case T_NODE:
+	mark_source_filename(obj->as.node.nd_file);
+	switch (nd_type(obj)) {
+	  case NODE_IF:		/* 1,2,3 */
+	  case NODE_FOR:
+	  case NODE_ITER:
+	  case NODE_CREF:
+	  case NODE_WHEN:
+	  case NODE_MASGN:
+	  case NODE_RESCUE:
+	  case NODE_RESBODY:
+	  case NODE_CLASS:
+	    gc_mark((VALUE)obj->as.node.u2.node, lev);
+	    /* fall through */
+	  case NODE_BLOCK:	/* 1,3 */
+	  case NODE_ARRAY:
+	  case NODE_DSTR:
+	  case NODE_DXSTR:
+	  case NODE_DREGX:
+	  case NODE_DREGX_ONCE:
+	  case NODE_FBODY:
+	  case NODE_ENSURE:
+	  case NODE_CALL:
+	  case NODE_DEFS:
+	  case NODE_OP_ASGN1:
+	    gc_mark((VALUE)obj->as.node.u1.node, lev);
+	    /* fall through */
+	  case NODE_SUPER:	/* 3 */
+	  case NODE_FCALL:
+	  case NODE_DEFN:
+	  case NODE_NEWLINE:
+	    ptr = (VALUE)obj->as.node.u3.node;
+	    goto again;
+
+	  case NODE_WHILE:	/* 1,2 */
+	  case NODE_UNTIL:
+	  case NODE_AND:
+	  case NODE_OR:
+	  case NODE_CASE:
+	  case NODE_SCLASS:
+	  case NODE_DOT2:
+	  case NODE_DOT3:
+	  case NODE_FLIP2:
+	  case NODE_FLIP3:
+	  case NODE_MATCH2:
+	  case NODE_MATCH3:
+	  case NODE_OP_ASGN_OR:
+	  case NODE_OP_ASGN_AND:
+	  case NODE_MODULE:
+	  case NODE_ALIAS:
+	  case NODE_VALIAS:
+	  case NODE_ARGS:
+	    gc_mark((VALUE)obj->as.node.u1.node, lev);
+	    /* fall through */
+	  case NODE_METHOD:	/* 2 */
+	  case NODE_NOT:
+	  case NODE_GASGN:
+	  case NODE_LASGN:
+	  case NODE_DASGN:
+	  case NODE_DASGN_CURR:
+	  case NODE_IASGN:
+	  case NODE_CVDECL:
+	  case NODE_CVASGN:
+	  case NODE_COLON3:
+	  case NODE_OPT_N:
+	  case NODE_EVSTR:
+	  case NODE_UNDEF:
+	    ptr = (VALUE)obj->as.node.u2.node;
+	    goto again;
+
+	  case NODE_HASH:	/* 1 */
+	  case NODE_LIT:
+	  case NODE_STR:
+	  case NODE_XSTR:
+	  case NODE_DEFINED:
+	  case NODE_MATCH:
+	  case NODE_RETURN:
+	  case NODE_BREAK:
+	  case NODE_NEXT:
+	  case NODE_YIELD:
+	  case NODE_COLON2:
+	  case NODE_SPLAT:
+	  case NODE_TO_ARY:
+	  case NODE_SVALUE:
+	    ptr = (VALUE)obj->as.node.u1.node;
+	    goto again;
+
+	  case NODE_SCOPE:	/* 2,3 */
+	  case NODE_BLOCK_PASS:
+	  case NODE_CDECL:
+	    gc_mark((VALUE)obj->as.node.u3.node, lev);
+	    ptr = (VALUE)obj->as.node.u2.node;
+	    goto again;
+
+	  case NODE_ZARRAY:	/* - */
+	  case NODE_ZSUPER:
+	  case NODE_CFUNC:
+	  case NODE_VCALL:
+	  case NODE_GVAR:
+	  case NODE_LVAR:
+	  case NODE_DVAR:
+	  case NODE_IVAR:
+	  case NODE_CVAR:
+	  case NODE_NTH_REF:
+	  case NODE_BACK_REF:
+	  case NODE_REDO:
+	  case NODE_RETRY:
+	  case NODE_SELF:
+	  case NODE_NIL:
+	  case NODE_TRUE:
+	  case NODE_FALSE:
+	  case NODE_ATTRSET:
+	  case NODE_BLOCK_ARG:
+	  case NODE_POSTEXE:
+	    break;
+	  case NODE_ALLOCA:
+	    mark_locations_array((VALUE*)obj->as.node.u1.value,
+				 obj->as.node.u3.cnt);
+	    ptr = (VALUE)obj->as.node.u2.node;
+	    goto again;
+
+	  default:		/* unlisted NODE */
+	    if (is_pointer_to_heap(obj->as.node.u1.node)) {
+		gc_mark((VALUE)obj->as.node.u1.node, lev);
+	    }
+	    if (is_pointer_to_heap(obj->as.node.u2.node)) {
+		gc_mark((VALUE)obj->as.node.u2.node, lev);
+	    }
+	    if (is_pointer_to_heap(obj->as.node.u3.node)) {
+		gc_mark((VALUE)obj->as.node.u3.node, lev);
+	    }
+	}
+	return;			/* no need to mark class. */
+    }
+
+    gc_mark(obj->as.basic.klass, lev);
+    switch (obj->as.basic.flags & T_MASK) {
+      case T_ICLASS:
+      case T_CLASS:
+      case T_MODULE:
+	mark_tbl(obj->as.klass.m_tbl, lev);
+	mark_tbl(obj->as.klass.iv_tbl, lev);
+	ptr = obj->as.klass.super;
+	goto again;
+
+      case T_ARRAY:
+	if (FL_TEST(obj, ELTS_SHARED)) {
+	    ptr = obj->as.array.aux.shared;
+	    goto again;
+	}
+	else {
+	    long i, len = obj->as.array.len;
+	    VALUE *ptr = obj->as.array.ptr;
+
+	    for (i=0; i < len; i++) {
+		gc_mark(*ptr++, lev);
+	    }
+	}
+	break;
+
+      case T_HASH:
+	mark_hash(obj->as.hash.tbl, lev);
+	ptr = obj->as.hash.ifnone;
+	goto again;
+
+      case T_STRING:
+#define STR_ASSOC FL_USER3   /* copied from string.c */
+	if (FL_TEST(obj, ELTS_SHARED|STR_ASSOC)) {
+	    ptr = obj->as.string.aux.shared;
+	    goto again;
+	}
+	break;
+
+      case T_DATA:
+	if (obj->as.data.dmark) (*obj->as.data.dmark)(DATA_PTR(obj));
+	break;
+
+      case T_OBJECT:
+	mark_tbl(obj->as.object.iv_tbl, lev);
+	break;
+
+      case T_FILE:
+      case T_REGEXP:
+      case T_FLOAT:
+      case T_BIGNUM:
+      case T_BLKTAG:
+	break;
+
+      case T_MATCH:
+	if (obj->as.match.str) {
+	    ptr = obj->as.match.str;
+	    goto again;
+	}
+	break;
+
+      case T_VARMAP:
+	gc_mark(obj->as.varmap.val, lev);
+	ptr = (VALUE)obj->as.varmap.next;
+	goto again;
+
+      case T_SCOPE:
+	if (obj->as.scope.local_vars && (obj->as.scope.flags & SCOPE_MALLOC)) {
+	    int n = obj->as.scope.local_tbl[0]+1;
+	    VALUE *vars = &obj->as.scope.local_vars[-1];
+
+	    while (n--) {
+		gc_mark(*vars++, lev);
+	    }
+	}
+	break;
+
+      case T_STRUCT:
+	{
+	    long len = obj->as.rstruct.len;
+	    VALUE *ptr = obj->as.rstruct.ptr;
+
+	    while (len--) {
+		gc_mark(*ptr++, lev);
+	    }
+	}
+	break;
+
+      default:
+	rb_bug("rb_gc_mark(): unknown data type 0x%lx(0x%lx) %s",
+	       obj->as.basic.flags & T_MASK, obj,
+	       is_pointer_to_heap(obj) ? "corrupted object" : "non object");
+    }
+}
+