fastruby 0.0.14 → 0.0.15

data/CHANGELOG

@@ -1,3 +1,15 @@
+0.0.15	Support for continuation objects and callcc
+
+		Fixed fastruby protocol to support unlimited number of arguments from ruby
+
+		Support for default arguments (e.g. def foo(a, b=c.to_s, c=99) )
+
+		Minor fixes to splat arguments on blocks
+
+		Support for receving block as proc (i.e. def foo(&block); end)
+
+		Support for passing proc as block (i.e. foo(&block))
+ 
 0.0.14	Support for method replacement ("monkey patching")
 
 		Internal: Implemented method hash to store implementation pointers

data/README

@@ -58,9 +58,7 @@ I will stabilize the API and document it for next releases. I promise
 == Known Limitations & Issues
 
 * callcc is not supported, it works but using it may result in unexpected behaviour
-* recursive methods will be slow since the optimization of method calls only works with already defined methods
 * 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)
-* When calling fastruby methods from normal ruby, the max. number of arguments allowed is 15
 * replacement of methods using identical code strings will work, but it will generate duplicated objects on the cache each time te snippet run
 
 == Usage

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.14'
+  s.version = '0.0.15'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/benchmarks/benchmark.rb

@@ -53,6 +53,7 @@ y2 = Y2.new
 x2 = X2.new
 
 Y.build([Y,X],:bar)
+X.build([X,Fixnum,Fixnum],:foo)
 
 require 'benchmark'
 

data/benchmarks/benchmark5.rb

@@ -20,8 +20,8 @@ class Y
 			i = 1000000
 			
 			lvar_type(i,Fixnum)
+			lvar_type(x2,X)
 	
-			x2 = 0
 			ret = 0
 			while i > 0
 				x.foo do |x2|
@@ -66,6 +66,8 @@ y2 = Y2.new
 x2 = X2.new
 
 Y.build([Y,X],:bar) 
+X.build([X],:foo)
+X.build([X],:bar)
 
 require 'benchmark'
 

data/ext/fastruby_base/fastruby_base.inl

@@ -23,6 +23,7 @@ struct FASTRUBYTHREADDATA {
 	VALUE exception;
 	VALUE accumulator;
 	VALUE rb_stack_chunk;
+	void* last_plocals;
 };
 
 struct METHOD {
@@ -196,6 +197,7 @@ static inline VALUE rb_thread_data_create() {
 	thread_data->exception = Qnil;
 	thread_data->accumulator = Qnil;
 	thread_data->rb_stack_chunk = Qnil;
+	thread_data->last_plocals = 0;
 
 	return ret;
 }

data/lib/fastruby/builder.rb

@@ -27,24 +27,6 @@ require "fastruby_load_path"
 require FastRuby.fastruby_load_path + "/../ext/fastruby_base/fastruby_base"
 
 module FastRuby
-
-  def self.build_defs(tree, *options)
-    method_name = tree[2].to_s
-
-    FastRuby.logger.info "Building singleton method #{self}::#{@method_name}"
-
-    locals = GetLocalsProcessor.get_locals(tree)
-    locals << :self
-
-    context = FastRuby::Context.new(false)
-    context.locals = locals
-    context.options = options
-
-    context.alt_method_name = "singleton_" + method_name + rand(100000000).to_s
-
-    [context.extra_code + context.to_c_method_defs(tree), context.alt_method_name, context.init_extra]
-  end
-
   class Method
     attr_accessor :locals
     attr_accessor :options
@@ -81,19 +63,29 @@ module FastRuby
       context.locals = locals
       context.options = options
 
-      args_tree = tree[2]
+      args_tree = if tree[0] == :defn
+         tree[2]
+      elsif tree[0] == :defs
+         tree[3]
+      else
+        raise ArgumentError, "unknown type of method definition #{tree[0]}"
+      end
 
       # create random method name
       context.snippet_hash = snippet_hash
       context.alt_method_name = "_" + @method_name.to_s + "_" + rand(10000000000).to_s
 
-      (1..signature.size).each do |i|
+      (1..signature.size-1).each do |i|
         arg = args_tree[i]
-        if arg
-          if arg.to_s.match(/\*/)
-            context.infer_lvar_map[arg.to_s.gsub("*","").to_sym] = Array
-          else
-            context.infer_lvar_map[arg.to_sym] = signature[i]
+        
+        if arg.instance_of? Symbol
+          
+          if arg
+            if arg.to_s.match(/\*/)
+              context.infer_lvar_map[arg.to_s.gsub("*","").to_sym] = Array
+            else
+              context.infer_lvar_map[arg.to_sym] = signature[i]
+            end
           end
         end
       end
@@ -122,11 +114,7 @@ module FastRuby
               def builder.generate_ext
                 ext = []
 
-                if @include_ruby_first
-                  @inc.unshift "#include \"ruby.h\""
-                else
-                  @inc.push "#include \"ruby.h\""
-                end
+                @inc.unshift "#include \"ruby.h\""
 
                 ext << @inc
                 ext << nil
@@ -173,18 +161,6 @@ module FastRuby
       unless options[:no_cache]
         FastRuby.cache.insert(snippet_hash, so_name) unless no_cache
       end
-
-      ret = Object.new
-
-      ret.extend MethodExtent
-      ret.yield_signature = context.yield_signature
-
-      ret
-
-    end
-
-    module MethodExtent
-      attr_accessor :yield_signature
     end
   end
 

data/lib/fastruby/exceptions.rb

@@ -21,4 +21,12 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 module FastRuby
   class TypeMismatchAssignmentException < Exception
   end
+  
+  class JumpTagException < Exception
+    attr_reader :state
+    
+    def initialize(state_)
+      @state = state_
+    end
+  end
 end

data/lib/fastruby/getlocals.rb

@@ -34,6 +34,23 @@ module FastRuby
       if tree.node_type == :lasgn
        @locals << tree[1]
       end
+      
+      if tree[0] == :args
+
+        tree[1..-1].each do |subtree|
+          if subtree.instance_of? Symbol
+             @locals << subtree.to_s.gsub("*","").gsub("&","").to_sym
+          end
+        end
+
+        if tree.find{|x| x.to_s[0] == ?&}
+          @locals << :__xproc_arguments
+        end
+      end
+
+      if tree[0] == :block_pass
+        @locals << :__xblock_arguments
+      end
 
       tree.select{|subtree| subtree.instance_of? FastRuby::FastRubySexp}.each do |subtree|
         process(subtree)

data/lib/fastruby/object.rb

@@ -103,26 +103,13 @@ class Object
     end
   end
 
-  def self.execute_tree(argument,*options_hashes)
+  def self.execute_tree(tree,*options_hashes)
     options_hash = {:validate_lvar_types => true}
     options_hashes.each do |opt|
       options_hash.merge!(opt)
     end
 
     require "fastruby/fastruby_sexp"
-    if argument.instance_of? FastRuby::FastRubySexp
-      tree = argument
-    elsif argument.instance_of? String
-      require "rubygems"
-      require "ruby_parser"
-      require "fastruby/sexp_extension"
-      tree = RubyParser.new.parse(argument).to_fastruby_sexp
-    else
-      require "pry"
-      binding.pry
-      raise ArgumentError
-    end
-
     method_name = tree[1]
 
     self_ = options_hash[:self]
@@ -141,22 +128,5 @@ class Object
     $refered_from_code_array = Array.new unless $refered_from_code_array
     $refered_from_code_array << self
   end
-
-  private
-      def self.to_class_name(argument)
-        require "sexp"
-        if argument.instance_of? Symbol
-          argument.to_s
-        elsif argument.instance_of? Sexp
-          if argument[0] == :colon3
-            "::" + to_class_name(argument[1])
-          elsif argument[0] == :colon2
-            to_class_name(argument[1]) + "::" + to_class_name(argument[2])
-          elsif argument[0] == :const
-            to_class_name(argument[1])
-          end
-        end
-      end
-
 end
 

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

@@ -26,7 +26,7 @@ module FastRuby
     def to_c_yield(tree)
 
       block_code = proc { |name| "
-        static VALUE #{name}(VALUE frame_param, VALUE* block_args) {
+        static VALUE #{name}(VALUE frame_param, VALUE* block_args, int size) {
 
           #{@locals_struct} *plocals;
           #{@frame_struct} *pframe;
@@ -36,38 +36,60 @@ module FastRuby
           if (FIX2LONG(plocals->block_function_address) == 0) {
             #{_raise("rb_eLocalJumpError", "no block given")};
           } else {
-            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))FIX2LONG(plocals->block_function_address))(#{tree.size-1}, block_args, FIX2LONG(plocals->block_function_param), (VALUE)pframe);
+            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))FIX2LONG(plocals->block_function_address))(size, block_args, FIX2LONG(plocals->block_function_param), (VALUE)pframe);
           }
         }
       "
       }
 
-      new_yield_signature = tree[1..-1].map{|subtree| infer_type subtree}
-      # merge the new_yield_signature with the new
-      if @yield_signature
-        if new_yield_signature.size == @yield_signature.size
-          (0..new_yield_signature.size-1).each do |i|
-            if @yield_signature[i] != new_yield_signature[i]
-              @yield_signature[i] = nil
-            end
-          end
-        else
-          @yield_signature = new_yield_signature.map{|x| nil}
-        end
+      splat_arg = tree.find{|x| x == :yield ? false : x[0] == :splat}
+      ret = nil      
+      if splat_arg
+        ret = inline_block "
+          VALUE splat_array = #{to_c(splat_arg[1])};
+          
+          if (CLASS_OF(splat_array) == rb_cArray) {
+            VALUE block_args[RARRAY(splat_array)->len + #{tree.size}];
+            int i;
+            #{ 
+              (0..tree.size-3).map{|i|
+                "block_args[#{i}] = #{to_c(tree[i+1])}"
+              }.join(";\n")
+            };
+            
+            for (i=0; i<RARRAY(splat_array)->len; 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});
+          } else {
+            VALUE block_args[1+#{tree.size}];
+            #{ 
+              (0..tree.size-3).map{|i|
+                "block_args[#{i}] = #{to_c(tree[i+1])}"
+              }.join(";\n")
+            };
+            
+            block_args[#{tree.size-2}] = splat_array;
+            return #{anonymous_function(&block_code)}((VALUE)pframe, block_args, #{tree.size-1});
+          }
+          
+        "
       else
-        @yield_signature = new_yield_signature
+        ret = if tree.size > 1
+            anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}},#{tree.size-1})"
+          else
+            anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){}, #{tree.size-1})"
+          end
       end
-
-      ret = if tree.size > 1
-          anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}})"
-        else
-          anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){})"
-        end
-
+      
       protected_block(ret, false)
     end
 
     def to_c_block(tree)
+      if tree.size == 1
+        return inline_block("return Qnil;")
+      end
 
       str = ""
       str = tree[1..-2].map{ |subtree|

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

@@ -36,10 +36,34 @@ module FastRuby
         args = tree[3]
         return _raise(args[1],args[2])
       end
-
+      
       recv = tree[1]
       mname = tree[2]
       args = tree[3]
+      
+      # search block_pass on arguments
+      block_pass_arg = args.find{|arg| if arg == :arglist
+            false
+          else
+          arg[0] == :block_pass
+            end} 
+      if block_pass_arg
+        
+        call_tree = tree.dup
+        call_tree[3] = args.select{|arg| if arg == :arglist 
+            true
+            else
+              arg[0] != :block_pass
+              end
+              }
+        
+        block_arguments_tree = s(:masgn, s(:array, s(:splat, s(:lasgn, :__xblock_arguments))))
+        block_tree = s(:call, block_pass_arg[1], :call, s(:arglist, s(:splat, s(:lvar, :__xblock_arguments))))
+        
+        replace_iter_tree = s(:iter, call_tree, block_arguments_tree, block_tree).to_fastruby_sexp
+        
+        return to_c(replace_iter_tree)
+      end
 
       mname = :require_fastruby if mname == :require
 

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

@@ -25,8 +25,43 @@ module FastRuby
     def to_c_defn(tree)
 
       method_name = tree[1]
-      args_tree = tree[2]
+      args_tree = tree[2].select{|x| x.to_s[0] != ?&}
+      
+      global_klass_variable = add_global_name("VALUE", "Qnil");
+
+      hash = Hash.new
+      value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
+      
+      strmethodargs = "self,block,(VALUE)&frame"
+      
+      anonymous_method_name = anonymous_dispatcher(global_klass_variable, method_name)
+      alt_options = options.dup
 
+      alt_options.delete(:self)
+      alt_options.delete(:main)
+
+      inline_block "
+        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+        
+        #{global_klass_variable} = plocals->self;
+        // set tree
+        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
+                #{global_klass_variable},
+                rb_str_new2(#{method_name.to_s.inspect}),
+                #{literal_value tree},
+                #{literal_value snippet_hash},
+                #{literal_value alt_options}
+
+                );
+
+        "
+
+    end
+
+    def to_c_defs(tree)
+      method_name = tree[2]
+      args_tree = tree[3].select{|x| x.to_s[0] != ?&}
+      
       global_klass_variable = add_global_name("VALUE", "Qnil");
 
       hash = Hash.new
@@ -34,9 +69,50 @@ module FastRuby
       
       strmethodargs = "self,block,(VALUE)&frame"
       
-      anonymous_method_name = anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
+      anonymous_method_name = anonymous_dispatcher(global_klass_variable, method_name)
+
+      alt_options = options.dup
+
+      alt_options.delete(:self)
+      alt_options.delete(:main)
+
+      inline_block "
+      
+        VALUE obj = #{to_c tree[1]};
+        rb_define_singleton_method(obj, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+        
+        #{global_klass_variable} = CLASS_OF(obj);
+        // set tree
+        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
+                #{global_klass_variable},
+                rb_str_new2(#{method_name.to_s.inspect}),
+                #{literal_value tree},
+                #{literal_value snippet_hash},
+                #{literal_value alt_options}
+
+                );
+
+        "
+        
+    end
+
+    def to_c_scope(tree)
+      if tree[1]
+        to_c(tree[1])
+      else
+        "Qnil"
+      end
+    end
+    
+private
+ 
+    def anonymous_dispatcher(global_klass_variable, method_name)
+      
+      strmethodargs = "self,block,(VALUE)&frame"
+      
+      anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
           VALUE klass = #{global_klass_variable};
-          char method_name[0x100];
+          char method_name[argc_*40+64];
 
           method_name[0] = '_';
           method_name[1] = 0;
@@ -133,67 +209,19 @@ module FastRuby
                 }
 
                 if (frame.targetted == 0) {
-                    rb_jump_tag(aux);
+                    frb_jump_tag(aux);
                 }
 
                 return Qnil;
               }
+              
+              VALUE tmp = Qnil;
+              if (argv == 0) argv = &tmp;
 
-                  if (argc_ == 0) return ((VALUE(*)(VALUE,VALUE,VALUE))fptr)(#{strmethodargs});
-                    
-                  #{ (1..15).map{ |i|
-                    value_cast = ( ["VALUE"]*(i+3) ).join(",")
-                    "if (argc_ == #{i}) return ((VALUE(*)(#{value_cast}))fptr)(#{strmethodargs}, #{(0..i-1).map{|x| "argv[#{x}]"}.join(",")});"
-                    }.join("\n");
-                  }
-
-              rb_raise(rb_eArgError, \"too many arguments: %d\", argc_);
+              return ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))fptr)(#{strmethodargs}, argc_, argv);
         }"
       }
-
-      alt_options = options.dup
-
-      alt_options.delete(:self)
-      alt_options.delete(:main)
-
-      inline_block "
-        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
-        
-        #{global_klass_variable} = plocals->self;
-        // set tree
-        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
-                #{global_klass_variable},
-                rb_str_new2(#{method_name.to_s.inspect}),
-                #{literal_value tree},
-                #{literal_value snippet_hash},
-                #{literal_value alt_options}
-
-                );
-
-        "
-
-    end
-
-    def to_c_defs(tree)
-      args_tree = tree[3];
-
-      tmp = FastRuby.build_defs(tree)
-
-      extra_code << tmp[0]
-      @init_extra = @init_extra + tmp[2]
-
-      inline_block "
-        rb_define_singleton_method(#{to_c tree[1]}, \"#{tree[2].to_s}\", (void*)#{tmp[1]}, #{args_tree.size-1});
-        return Qnil;
-        "
-    end
-
-    def to_c_scope(tree)
-      if tree[1]
-        to_c(tree[1])
-      else
-        "Qnil"
-      end
+      
     end
   end
 end