fastruby 0.0.15 → 0.0.16

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.0.16	Limited (see known issues on README) support for ruby1.9-p180 (tested with rvm)
+
+		Support for ruby1.8-p334 (tested with rvm)
+
 0.0.15	Support for continuation objects and callcc
 
 		Fixed fastruby protocol to support unlimited number of arguments from ruby

data/README

@@ -57,6 +57,8 @@ I will stabilize the API and document it for next releases. I promise
 
 == Known Limitations & Issues
 
+* fastruby now works with ruby1.9, but features specific to ruby1.9 (such fibers and new hash notation) will not work or will work with unexpected behaviour
+* fastruby on ruby1.8 is faster than ruby1.8 on a few cases (see benchmarks) but is slower than ruby1.9
 * callcc is not supported, it works but using it may result in unexpected behaviour
 * calls with blocks to ruby or cruby methods are almost as slow as normal ruby (if the called method is defined by fastruby, the call is pretty fast)
 * replacement of methods using identical code strings will work, but it will generate duplicated objects on the cache each time te snippet run

data/Rakefile

@@ -7,13 +7,13 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.15'
+  s.version = '0.0.16'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY
   s.summary = 'fast execution of ruby code'
   s.homepage = "http://github.com/tario/fastruby"
-  s.add_dependency "RubyInline", "= 3.9.0"
+  s.add_dependency "RubyInline", "= 3.11.0"
   s.add_dependency "ruby_parser", "= 2.0.6"
   s.has_rdoc = true
   s.extra_rdoc_files = [ 'README' ]

data/ext/fastruby_base/extconf.rb

@@ -1,7 +1,17 @@
 require 'mkmf'
 dir_config('fastruby_base')
 CONFIG['CC'] = 'gcc'
-create_makefile('fastruby_base')
 
+ruby_version = Config::CONFIG["ruby_version"]
+ruby_version = ruby_version.split(".")[0..1].join(".")
 
+if ruby_version == "1.8"
+	$CFLAGS = $CFLAGS + " -DRUBY_1_8"
+elsif ruby_version == "1.9"
+	$CFLAGS = $CFLAGS + " -DRUBY_1_9"
+else
+	print "ERROR: unknown ruby version: #{ruby_version}\n"
+	print "try passing the rubyversion by argument (1.8 or 1.9)\n"
+end
 
+create_makefile('fastruby_base')

data/ext/fastruby_base/fastruby_base.inl

@@ -1,6 +1,10 @@
 #include "ruby.h"
+#include "setjmp.h"
+
+#ifdef RUBY_1_8
 #include "node.h"
 #include "env.h"
+#endif
 
 VALUE rb_cStackChunk;
 VALUE rb_cFastRubyThreadData;
@@ -26,6 +30,47 @@ struct FASTRUBYTHREADDATA {
 	void* last_plocals;
 };
 
+#ifdef RUBY_1_8
+#define _RARRAY_LEN(x) (RARRAY(x)->len)
+#define _RSTRING_PTR(x) (RSTRING(x)->ptr)
+#endif
+
+#ifdef RUBY_1_9
+
+void* rb_method_entry(VALUE klass, ID id);
+void* rb_global_entry(ID id);
+
+typedef struct RNode {
+    unsigned long flags;
+    char *nd_file;
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct rb_global_entry *entry;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
+
+#define _RARRAY_LEN(x) RARRAY_LEN(x)
+#define _RSTRING_PTR(x) RSTRING_PTR(x)
+#endif
+
 struct METHOD {
     VALUE klass, rklass;
     VALUE recv;
@@ -235,8 +280,7 @@ static VALUE clear_method_hash_addresses(VALUE klass,VALUE rb_method_hash) {
 	  VALUE rb_values = rb_funcall(rb_method_hash, rb_intern("values"),0);
 	  void** address;
 	  int i;
-	  
-	  for (i = 0; i < RARRAY(rb_values)->len; i++) {
+	  for (i = 0; i < _RARRAY_LEN(rb_values); i++) {
 	  	address = (void**)FIX2LONG(rb_ary_entry(rb_values,i));
 	  	*address = 0;
 	  }
@@ -246,7 +290,7 @@ static VALUE clear_method_hash_addresses(VALUE klass,VALUE rb_method_hash) {
 }
 
 static VALUE has_fastruby_function(VALUE self, VALUE rb_method_hash, VALUE mname) {
-	ID id = rb_intern(RSTRING(mname)->ptr);
+	ID id = rb_intern(_RSTRING_PTR(mname));
 	VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
 	
 	if (tmp != Qnil) {

data/lib/fastruby/builder.rb

@@ -18,7 +18,6 @@ you should have received a copy of the gnu general public license
 along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
-require "fastruby/inline_extension"
 require "fastruby/method_extension"
 require "fastruby/logging"
 require "fastruby/getlocals"
@@ -58,6 +57,7 @@ module FastRuby
       require "fastruby/translator/translator"
       require "rubygems"
       require "inline"
+      require "fastruby/inline_extension"
 
       context = FastRuby::Context.new
       context.locals = locals
@@ -105,10 +105,23 @@ module FastRuby
 
       begin
 
+        unless $inline_extra_flags
+          $inline_extra_flags = true
+          
+          ['CFLAGS','CXXFLAGS','OPTFLAGS','cflags','cxxflags','optflags'].each do |name|
+            RbConfig::CONFIG[name].gsub!(/\-O\d/,"-O1") if RbConfig::CONFIG[name]
+          end
+          
+          if RUBY_VERSION =~ /^1\.8/
+            RbConfig::CONFIG['CFLAGS'] << " -DRUBY_1_8 -Wno-clobbered"
+          elsif RUBY_VERSION =~ /^1\.9/
+            RbConfig::CONFIG['CFLAGS'] << " -DRUBY_1_9 -Wno-clobbered"
+          end
+        end
+        
         @owner.class_eval do
           inline :C  do |builder|
             builder.inc << context.extra_code
-            builder.include "<node.h>"
             builder.init_extra = context.init_extra
 
               def builder.generate_ext

data/lib/fastruby/cache/cache.rb

@@ -18,7 +18,7 @@ you should have received a copy of the gnu general public license
 along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
-require "sha1"
+require "digest"
 require "fileutils"
 
 module FastRuby
@@ -37,7 +37,7 @@ module FastRuby
     end
 
     def hash_snippet(snippet, addition)
-      SHA1.hexdigest(snippet + addition)
+      Digest::SHA1.hexdigest(snippet + addition)
     end
 
     def insert(hash,path)

data/lib/fastruby/inline_extension.rb

@@ -21,67 +21,20 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 module Inline
 class C
 	attr_reader :inc
-
-    def generate(src, options={})
-      options = {:expand_types=>options} unless Hash === options
-
-      expand_types = options[:expand_types]
-      singleton = options[:singleton]
-      result = self.strip_comments(src)
-
-      signature = parse_signature(src, !expand_types)
-      function_name = signature['name']
-      method_name = options[:method_name]
-      method_name ||= test_to_normal function_name
-      return_type = signature['return']
-      arity = options[:arity] || signature['arity']
-
-      raise ArgumentError, "too many arguments" if arity > MAGIC_ARITY_THRESHOLD
-
-      if expand_types then
-        prefix = "static VALUE #{function_name}("
-        if arity <= MAGIC_ARITY then
-          prefix += "int argc, VALUE *argv, VALUE self"
-        else
-          prefix += "VALUE self"
-          prefix += signature['args'].map { |arg, type| ", VALUE _#{arg}"}.join
-        end
-        prefix += ") {\n"
-        prefix += signature['args'].map { |arg, type|
-          "  #{type} #{arg} = #{ruby2c(type)}(_#{arg});\n"
-        }.join
-
-        # replace the function signature (hopefully) with new sig (prefix)
-        result.sub!(/[^;\/\"\>]+#{function_name}\s*\([^\{]+\{/, "\n" + prefix)
-        result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
-        unless return_type == "void" then
-          raise SyntaxError, "Couldn't find return statement for #{function_name}" unless
-            result =~ /return/
-        else
-          result.sub!(/\s*\}\s*\Z/, "\nreturn Qnil;\n}")
-        end
-      else
-        prefix = "static #{return_type} #{function_name}("
-        result.sub!(/[^;\/\"\>]+#{function_name}\s*\(/, prefix)
-        result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
+	
+	  def module_name
+      unless defined? @module_name then
+        module_name = if @mod.name
+           @mod.name.gsub('::','__')
+         else
+           rand(1000000000000000).to_s
+         end
+        md5 = Digest::MD5.new
+        @sig.keys.sort_by { |x| x.to_s }.each { |m| md5 << m.to_s }
+        @module_name = "Inline_#{module_name}_#{md5}"
       end
-
-      delta = if result =~ /\A(static.*?\{)/m then
-                $1.split(/\n/).size
-              else
-                warn "WAR\NING: Can't find signature in #{result.inspect}\n" unless $TESTING
-                0
-              end
-
-      file, line = caller[1].split(/:/)
-      result = "# line #{line.to_i + delta} \"#{file}\"\n" + result unless $DEBUG and not $TESTING
-
-      @src << result
-      @sig[function_name] = [arity,singleton,method_name]
-
-      return result if $TESTING
-    end # def generate
-
+      @module_name
+	  end
 end
 end
 

data/lib/fastruby/object.rb

@@ -81,7 +81,7 @@ class Object
 
       return unless tree
         method_name = "_anonymous_" + rand(100000000000).to_s
-        Object.execute_tree(FastRuby.encapsulate_tree(tree,method_name), :main => method_name, :self => self, :snippet_hash => snippet_hash, *[options_hash])
+        Object.execute_tree(FastRuby.encapsulate_tree(tree,method_name), {:main => method_name, :self => self, :snippet_hash => snippet_hash}.merge(options_hash))
 
     else
 

data/lib/fastruby/self

@@ -0,0 +1,82 @@
+translator/modules/variable.rb   27|      "rb_cvar_get(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]})"
+translator/modules/variable.rb   31|      "__rb_cvar_set(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]},#{to_c tree[2]},Qfalse)"
+translator/modules/variable.rb   55|      "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
+translator/modules/variable.rb  170|      "rb_ivar_defined(plocals->self,#{intern_num tree[1][1]}) ? #{literal_value "instance-variable"} : Qnil"
+translator/modules/defn.rb   46|        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);
+translator/modules/defn.rb   48|        #{global_klass_variable} = plocals->self;
+translator/modules/method_group.rb  115|            plocals->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
+translator/modules/method_group.rb  120|            plocals->active = Qtrue;
+translator/modules/method_group.rb  121|            plocals->self = self;
+translator/modules/method_group.rb  122|            plocals->targetted = Qfalse;
+translator/modules/method_group.rb  123|            plocals->call_frame = LONG2FIX(0);
+translator/modules/method_group.rb  134|            plocals->active = Qfalse;
+translator/modules/iter.rb  107|            str_arg_initialization << "plocals->#{args_tree[1]} = arg;"
+translator/modules/iter.rb  111|                plocals->#{args_tree[1]} = arg;
+translator/modules/iter.rb  113|                plocals->#{args_tree[1]} = rb_ary_entry(arg,0);
+translator/modules/iter.rb  138|              str_arg_initialization << "plocals->#{arguments[i].last} = rb_ary_entry(arg,#{i});\n"
+translator/modules/iter.rb  140|              str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(_RARRAY_LEN(arg)-#{i});\n
+translator/modules/iter.rb  144|                  rb_ary_store(plocals->#{arg.last.last},i-#{i},rb_ary_entry(arg,i));
+translator/modules/iter.rb  156|          str_recv = "plocals->self" unless recv_tree
+translator/modules/iter.rb  209|          str_recv = "plocals->self" unless recv_tree
+translator/modules/iter.rb  286|                    if (plocals->targetted == 1) {
+translator/modules/iter.rb  341|                      if (plocals->targetted == 1) {
+translator/modules/iter.rb  342|                        if (plocals->active == Qfalse) {
+translator/modules/iter.rb  451|          fastruby_str_arg_initialization = "plocals->#{args_tree[1]} = argv[0];"
+translator/modules/iter.rb  458|              fastruby_str_arg_initialization << "plocals->#{arg.last} = #{i} < argc ? argv[#{i}] : Qnil;\n"
+translator/modules/iter.rb  460|              fastruby_str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(#{arguments.size-1-i});\n
+translator/modules/iter.rb  464|                  rb_ary_store(plocals->#{arg.last.last},i-#{i},argv[i]);
+translator/modules/iter.rb  513|        str_recv = "plocals->self"
+translator/modules/iter.rb  537|                VALUE old_call_frame = plocals->call_frame;
+translator/modules/iter.rb  538|                plocals->call_frame = LONG2FIX(&call_frame);
+translator/modules/iter.rb  551|                    plocals->call_frame = old_call_frame;
+translator/modules/iter.rb  561|              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
+translator/modules/iter.rb  646|                  current_plocals->active = Qfalse;
+translator/modules/iter.rb  647|                  current_plocals = (typeof(current_plocals))FIX2LONG(current_plocals->parent_locals); 
+translator/modules/iter.rb  657|                  current_plocals->active = Qtrue;
+translator/modules/iter.rb  658|                  current_plocals = (typeof(current_plocals))FIX2LONG(current_plocals->parent_locals); 
+translator/modules/iter.rb  684|                plocals->call_frame = old_call_frame;
+translator/modules/iter.rb  693|                plocals->call_frame = old_call_frame;
+translator/modules/block.rb   36|          if (FIX2LONG(plocals->block_function_address) == 0) {
+translator/modules/block.rb   39|            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))FIX2LONG(plocals->block_function_address))(size, block_args, FIX2LONG(plocals->block_function_param), (VALUE)pframe);
+translator/modules/nonlocal.rb   27|        plocals->return_value = #{to_c(tree[1])};
+translator/modules/nonlocal.rb   28|        plocals->targetted = 1;
+translator/modules/nonlocal.rb   41|         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+translator/modules/nonlocal.rb   47|         plocals->call_frame = LONG2FIX(0);
+translator/modules/nonlocal.rb   60|         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+translator/translator.rb  213|        VALUE old_call_frame = plocals->call_frame;
+translator/translator.rb  214|        plocals->call_frame = LONG2FIX(&call_frame);
+translator/translator.rb  226|                    plocals->call_frame = old_call_frame;
+translator/translator.rb  232|                    plocals->call_frame = old_call_frame;
+translator/translator.rb  243|        plocals->call_frame = old_call_frame;
+translator/translator.rb  398|          plocals->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
+translator/translator.rb  402|          plocals->active = Qtrue;
+translator/translator.rb  403|          plocals->targetted = Qfalse;
+translator/translator.rb  404|          plocals->pframe = LONG2FIX(&frame);
+translator/translator.rb  420|            plocals->active = Qfalse;
+translator/translator.rb  422|            return plocals->return_value;
+translator/translator.rb  425|          plocals->self = self;
+translator/translator.rb  430|            "plocals->#{arg} = #{arg};\n"
+translator/translator.rb  433|          plocals->block_function_address = LONG2FIX(0);
+translator/translator.rb  434|          plocals->block_function_param = LONG2FIX(Qnil);
+translator/translator.rb  435|          plocals->call_frame = LONG2FIX(0);
+translator/translator.rb  445|          plocals->active = Qfalse;
+translator/translator.rb  525|                    "plocals->#{arg} = argv[#{i}];\n"
+translator/translator.rb  547|                      plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new3(0);
+translator/translator.rb  551|                      plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new4(
+translator/translator.rb  570|            plocals->#{block_argument.to_s.gsub("&","")} = #{to_c FastRuby::FastRubySexp.from_sexp(proc_reyield_block_tree)};
+translator/translator.rb  616|          plocals->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
+translator/translator.rb  621|          plocals->active = Qtrue;
+translator/translator.rb  622|          plocals->targetted = Qfalse;
+translator/translator.rb  623|          plocals->pframe = LONG2FIX(&frame);
+translator/translator.rb  624|          plocals->call_frame = LONG2FIX(0);
+translator/translator.rb  633|            plocals->active = Qfalse;
+translator/translator.rb  642|            if (plocals->targetted == Qfalse || aux != FASTRUBY_TAG_RETURN) {
+translator/translator.rb  650|            return plocals->return_value;
+translator/translator.rb  653|          plocals->self = self;
+translator/translator.rb  659|            plocals->block_function_address = LONG2FIX(pblock->block_function_address);
+translator/translator.rb  660|            plocals->block_function_param = LONG2FIX(pblock->block_function_param);
+translator/translator.rb  662|            plocals->block_function_address = LONG2FIX(0);
+translator/translator.rb  663|            plocals->block_function_param = LONG2FIX(Qnil);
+translator/translator.rb  674|          plocals->active = Qfalse;
+translator/translator.rb  693|      "plocals->"
+translator/translator.rb  759|        return "FIX2LONG(plocals->block_function_address) == 0 ? Qfalse : Qtrue"

data/lib/fastruby/sexp_extension.rb

@@ -26,12 +26,20 @@ class Object
   end
 end
 
+module FastRuby
+  class FastRubySexp
+    def self.from_sexp(value)
+      ary = FastRuby::FastRubySexp.new
+      value.each do |x|
+        ary << x.to_fastruby_sexp
+      end
+      ary
+    end
+  end
+end
+
 class Sexp
   def to_fastruby_sexp
-    ary = FastRuby::FastRubySexp.new
-    each do |x|
-      ary << x.to_fastruby_sexp
-    end
-    ary
+    FastRuby::FastRubySexp.from_sexp(self)
   end
 end

data/lib/fastruby/translator/modules/block.rb

@@ -49,7 +49,7 @@ module FastRuby
           VALUE splat_array = #{to_c(splat_arg[1])};
           
           if (CLASS_OF(splat_array) == rb_cArray) {
-            VALUE block_args[RARRAY(splat_array)->len + #{tree.size}];
+            VALUE block_args[_RARRAY_LEN(splat_array) + #{tree.size}];
             int i;
             #{ 
               (0..tree.size-3).map{|i|
@@ -57,11 +57,11 @@ module FastRuby
               }.join(";\n")
             };
             
-            for (i=0; i<RARRAY(splat_array)->len; i++) {
+            for (i=0; i<_RARRAY_LEN(splat_array); i++) {
               block_args[i+#{tree.size-2}] = rb_ary_entry(splat_array,i);
             }
             
-            return #{anonymous_function(&block_code)}((VALUE)pframe, block_args, RARRAY(splat_array)->len + #{tree.size-2});
+            return #{anonymous_function(&block_code)}((VALUE)pframe, block_args, _RARRAY_LEN(splat_array) + #{tree.size-2});
           } else {
             VALUE block_args[1+#{tree.size}];
             #{ 

data/lib/fastruby/translator/modules/call.rb

@@ -86,7 +86,7 @@ module FastRuby
             }
             
             int argc = #{args.size-2};
-            VALUE argv[#{args.size} + RARRAY(array)->len];
+            VALUE argv[#{args.size} + _RARRAY_LEN(array)];
             
             #{
               i = -1
@@ -96,7 +96,7 @@ module FastRuby
               }.join(";\n")
             };
             
-            int array_len = RARRAY(array)->len;
+            int array_len = _RARRAY_LEN(array);
             
             int i;
             for (i=0; i<array_len;i++) {

data/lib/fastruby/translator/modules/defn.rb

@@ -41,7 +41,9 @@ module FastRuby
       alt_options.delete(:main)
 
       inline_block "
-        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+      
+        usleep(0);
+        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);
         
         #{global_klass_variable} = plocals->self;
         // set tree

data/lib/fastruby/translator/modules/iter.rb

@@ -103,22 +103,39 @@ module FastRuby
 
         if not args_tree
         elsif args_tree.first == :lasgn
-          str_arg_initialization << "plocals->#{args_tree[1]} = arg;"
+          if RUBY_VERSION =~ /^1\.8/
+            str_arg_initialization << "plocals->#{args_tree[1]} = arg;"
+          elsif RUBY_VERSION =~ /^1\.9/
+            str_arg_initialization << "
+              if (TYPE(arg) != T_ARRAY) {
+                plocals->#{args_tree[1]} = arg;
+              } else {
+                plocals->#{args_tree[1]} = rb_ary_entry(arg,0);
+              }
+              "
+          end
         elsif args_tree.first == :masgn
           
-          str_arg_initialization << "
-              {
-                if (TYPE(arg) != T_ARRAY) {
-                  if (arg != Qnil) {
+          if RUBY_VERSION =~ /^1\.8/
+            str_arg_initialization << "
+                {
+                  if (TYPE(arg) != T_ARRAY) {
+                    if (arg != Qnil) {
+                      arg = rb_ary_new4(1,&arg);
+                    } else {
+                      arg = rb_ary_new2(0);
+                    }
+                  } else if (_RARRAY_LEN(arg) <= 1) {
                     arg = rb_ary_new4(1,&arg);
-                  } else {
-                    arg = rb_ary_new2(0);
                   }
-                } else if (RARRAY(arg)->len <= 1) {
-                  arg = rb_ary_new4(1,&arg);
                 }
-              }
-              "          
+                "
+          elsif RUBY_VERSION =~ /^1\.9/
+            str_arg_initialization << "
+                {
+                }
+                "
+          end
           
           arguments = args_tree[1][1..-1]
           
@@ -127,10 +144,10 @@ module FastRuby
             if arg[0] == :lasgn 
               str_arg_initialization << "plocals->#{arguments[i].last} = rb_ary_entry(arg,#{i});\n"
             elsif arg[0] == :splat
-              str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(RARRAY(arg)->len-#{i});\n
+              str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(_RARRAY_LEN(arg)-#{i});\n
               
                 int i;
-                for (i=#{i};i<RARRAY(arg)->len;i++){
+                for (i=#{i};i<_RARRAY_LEN(arg);i++){
                   rb_ary_store(plocals->#{arg.last.last},i-#{i},rb_ary_entry(arg,i));
                 }
                "
@@ -158,7 +175,7 @@ module FastRuby
                   }
                   
                   int argc = #{call_args_tree.size-2};
-                  VALUE argv[#{call_args_tree.size} + RARRAY(array)->len];
+                  VALUE argv[#{call_args_tree.size} + _RARRAY_LEN(array)];
                   
                   #{
                     i = -1
@@ -168,7 +185,7 @@ module FastRuby
                     }.join(";\n")
                   };
                   
-                  int array_len = RARRAY(array)->len;
+                  int array_len = _RARRAY_LEN(array);
                   
                   int i;
                   for (i=0; i<array_len;i++) {
@@ -239,10 +256,35 @@ module FastRuby
             }
 
         end
+        
+        argument_array_read = "
+            VALUE arg;
+            #{
+            # TODO: access directly to argc and argv for optimal execution
+            if RUBY_VERSION =~ /^1\.9/ 
+              "
+                if (TYPE(arg_) == T_ARRAY) {
+                  if (_RARRAY_LEN(arg_) <= 1) {
+                    arg = rb_ary_new4(argc,argv);
+                  } else {
+                    arg = arg_;
+                  }
+                } else {
+                  arg = rb_ary_new4(argc,argv);
+                }
+              "
+            else
+              "arg = arg_;"
+            end
+            }
+        "
+        
 
         rb_funcall_block_code_with_lambda = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+          static VALUE #{name}(VALUE arg_, VALUE _plocals, int argc, VALUE* argv) {
             // block for call to #{call_tree[2]}
+            #{argument_array_read}
+            
             VALUE last_expression = Qnil;
 
             #{@frame_struct} frame;
@@ -299,8 +341,10 @@ module FastRuby
         }
 
         rb_funcall_block_code_proc_new = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+          static VALUE #{name}(VALUE arg_, VALUE _plocals, int argc, VALUE* argv) {
             // block for call to #{call_tree[2]}
+            #{argument_array_read}
+            
             VALUE last_expression = Qnil;
 
             #{@frame_struct} frame;
@@ -353,8 +397,10 @@ module FastRuby
 
 
         rb_funcall_block_code = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+          static VALUE #{name}(VALUE arg_, VALUE _plocals, int argc, VALUE* argv) {
             // block for call to #{call_tree[2]}
+            #{argument_array_read}
+
             VALUE last_expression = Qnil;
 
             #{@frame_struct} frame;
@@ -391,7 +437,14 @@ module FastRuby
         }
 
         rb_funcall_block_code_callcc = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+          static VALUE #{name}(VALUE arg, VALUE _plocals, int argc, VALUE* argv) {
+            #{
+            # TODO: access directly to argc and argv for optimal execution
+            if RUBY_VERSION =~ /^1\.9/ 
+              "arg = rb_ary_new4(argc,argv);"
+            end
+            }
+          
             // block for call to #{call_tree[2]}
             VALUE last_expression = Qnil;
 
@@ -419,7 +472,7 @@ module FastRuby
                 }
             }
             
-            if (rb_obj_is_kind_of(arg,rb_cCont)) {
+            if (rb_obj_is_kind_of(arg, rb_const_get(rb_cObject, #{intern_num :Continuation}))) {
               struct FASTRUBYTHREADDATA* thread_data = frame.thread_data;
               rb_ivar_set(arg,#{intern_num :__stack_chunk},thread_data->rb_stack_chunk);
             }
@@ -549,8 +602,12 @@ module FastRuby
               VALUE saved_rb_stack_chunk = Qnil; 
 
               pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
-
+#ifdef RUBY_1_8
               NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
+#endif              
+#ifdef RUBY_1_9
+              void* node = rb_method_entry(CLASS_OF(pframe->next_recv), #{intern_num mname});
+#endif              
 
               if (node == #{@callcc_node_gvar}) {
                 
@@ -586,7 +643,6 @@ module FastRuby
             frame_call(
               protected_block(inline_block("
               
-              NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
               void* caller_func;
               void* block_func;
               typeof(plocals) current_plocals;
@@ -594,6 +650,13 @@ module FastRuby
               if (pframe->thread_data == 0) pframe->thread_data = rb_current_thread_data();
               void* last_plocals = pframe->thread_data->last_plocals;
 
+#ifdef RUBY_1_8
+              NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
+#endif
+#ifdef RUBY_1_9
+              void* node = rb_method_entry(CLASS_OF(pframe->next_recv), #{intern_num mname});
+#endif
+
               if (
                 node == #{@proc_node_gvar} ||
                 node == #{@lambda_node_gvar}

data/lib/fastruby/translator/modules/variable.rb

@@ -159,7 +159,11 @@ module FastRuby
       elsif nt == :const
       "rb_const_defined(rb_cObject, #{intern_num tree[1][1]}) ? #{literal_value "constant"} : Qnil"
       elsif nt == :call
-      "rb_method_node(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
+        if RUBY_VERSION =~ /^1\.8/
+        "rb_method_node(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
+        else
+        "rb_method_entry(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
+        end
       elsif nt == :yield
         "rb_block_given_p() ? #{literal_value "yield"} : Qnil"
       elsif nt == :ivar