fastruby 0.0.12 → 0.0.13

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.0.13	Argument splat method calls (not optimized yet)
+
+		Array arguments on methods (optional arguments, variable number of arguments)
+		
+		Fixed bug of return when trying to return from a proc (illegal overwrite of memory on stack when trying to flag frame as targetted)
+
+		Internal refactor
+
 0.0.12	Completed exception support (multiple rescue clauses,  multiple exceptions in only one rescue, assign exceptions to variables and fastruby internal exceptions)
 
 0.0.11	Fixed packaging error

data/README

@@ -61,7 +61,6 @@ I will stabilize the API and document it for next releases. I promise
 * 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 it's pretty fast)
-* does not support methods with variable number of arguments
 
 == 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.12'
+  s.version = '0.0.13'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/lib/fastruby/builder.rb

@@ -88,7 +88,14 @@ module FastRuby
           end
 
           if method_tree
-            :fastruby
+            
+            args_tree = method_tree[2]
+            
+            if args_tree.any?{|x|x.to_s.match(/\*/)}
+              :fastruby_array
+            else
+              :fastruby
+            end
           else
             :cruby
           end
@@ -98,7 +105,7 @@ module FastRuby
     end
 
     def build(signature, noreturn = false)
-      require "fastruby/translator"
+      require "fastruby/translator/translator"
       require "rubygems"
       require "inline"
 

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

@@ -0,0 +1,92 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module FastRuby
+  module BlockTranslator
+    
+    register_translator_module self
+    
+    def to_c_yield(tree)
+
+      block_code = proc { |name| "
+        static VALUE #{name}(VALUE frame_param, VALUE* block_args) {
+
+          #{@locals_struct} *plocals;
+          #{@frame_struct} *pframe;
+          pframe = (void*)frame_param;
+          plocals = (void*)pframe->plocals;
+
+          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);
+          }
+        }
+      "
+      }
+
+      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
+      else
+        @yield_signature = new_yield_signature
+      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)
+
+      str = ""
+      str = tree[1..-2].map{ |subtree|
+        to_c(subtree)
+      }.join(";")
+
+      if tree[-1]
+
+        if tree[-1][0] != :return
+          str = str + ";last_expression = #{to_c(tree[-1])};"
+        else
+          str = str + ";#{to_c(tree[-1])};"
+        end
+      end
+
+      str << "return last_expression;"
+
+      inline_block str
+    end
+    
+  end
+end

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

@@ -0,0 +1,137 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module FastRuby
+  module CallTranslator
+    
+    register_translator_module self
+
+    def to_c_call(tree, repass_var = nil)
+      directive_code = directive(tree)
+      if directive_code
+        return directive_code
+      end
+
+      if tree[2] == :require
+        tree[2] = :fastruby_require
+      elsif tree[2] == :raise
+        # raise code
+        args = tree[3]
+        return _raise(args[1],args[2])
+      end
+
+      recv = tree[1]
+      mname = tree[2]
+      args = tree[3]
+
+      mname = :require_fastruby if mname == :require
+
+      argnum = args.size - 1
+
+      recv = recv || s(:self)
+
+      recvtype = infer_type(recv)
+      
+      if args.size > 1
+        if args.last[0] == :splat
+          return protected_block(
+            inline_block(
+            "
+            
+            VALUE array = #{to_c args.last[1]};
+            
+            if (TYPE(array) != T_ARRAY) {
+              array = rb_ary_new4(1,&array);
+            }
+            
+            int argc = #{args.size-2};
+            VALUE argv[#{args.size} + RARRAY(array)->len];
+            
+            #{
+              i = -1
+              args[1..-2].map {|arg|
+                i = i + 1
+                "argv[#{i}] = #{to_c arg}"
+              }.join(";\n")
+            };
+            
+            int array_len = RARRAY(array)->len;
+            
+            int i;
+            for (i=0; i<array_len;i++) {
+              argv[argc] = rb_ary_entry(array,i);
+              argc++; 
+            }
+            
+            return rb_funcall2(#{to_c recv}, #{intern_num tree[2]}, argc, argv);
+            "
+            ), true, repass_var)
+        end
+      end
+
+      strargs = args[1..-1].map{|arg| to_c arg}.join(",")
+
+      if recvtype
+
+        address = nil
+        mobject = nil
+
+        inference_complete = true
+        signature = [recvtype]
+
+        args[1..-1].each do |arg|
+          argtype = infer_type(arg)
+          if argtype
+            signature << argtype
+          else
+            inference_complete = false
+          end
+        end
+
+        if repass_var
+          extraargs = ","+repass_var
+          extraargs_signature = ",VALUE " + repass_var
+        else
+          extraargs = ""
+          extraargs_signature = ""
+        end
+
+          if argnum == 0
+            value_cast = "VALUE,VALUE,VALUE"
+            "((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe)"
+          else
+            value_cast = ( ["VALUE"]*(args.size) ).join(",") + ",VALUE,VALUE"
+            "((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{strargs})"
+          end
+
+      else # else recvtype
+        if argnum == 0
+          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
+        else
+          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", true, repass_var)
+        end
+      end # if recvtype
+    end
+
+    def to_c_attrasgn(tree)
+      to_c_call(tree)
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module FastRuby
+  module DefnTranslator
+    register_translator_module self
+
+    def to_c_defn(tree)
+
+      method_name = tree[1]
+      args_tree = tree[2]
+
+      global_klass_variable = add_global_name("VALUE", "Qnil");
+
+      hash = Hash.new
+      value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
+      
+      multiple_arguments = args_tree[1..-1].find{|x| x.to_s =~ /\*/}
+      
+      args_array_accessors = if multiple_arguments
+        (0..args_tree.size-3).map{|x| "argv[#{x}]"} + ["argarray"]
+      else
+        (0..args_tree.size-2).map{|x| "argv[#{x}]"}
+      end
+      
+      strmethodargs = ""
+
+      if args_tree.size > 1
+        strmethodargs = "self,block,(VALUE)&frame,#{args_array_accessors.map(&:to_s).join(",") }"
+      else
+        strmethodargs = "self,block,(VALUE)&frame"
+      end
+      
+      strmakecall = if multiple_arguments
+                "
+                  if (argc_ > #{args_tree.size-2}) {
+                    VALUE argarray = rb_ary_new4(argc_-#{args_tree.size-2}, argv+#{args_tree.size-2});
+                    return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
+                  } else if (argc_ == #{args_tree.size-2}) {
+                    // pass pre-calculated method arguments plus an empty array
+                    VALUE argarray = rb_ary_new();
+                    return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
+                  } else {
+                    rb_raise(rb_eArgError, \"wrong number of arguments (%d for #{args_tree.size-2}))\", argc_);
+                  }
+                "
+              else
+                "if (argc_ == #{args_tree.size-1} && argc == #{args_tree.size+1}) {
+                  return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
+                } else {
+                  rb_raise(rb_eArgError, \"wrong number of arguments (%d for #{args_tree.size-1}))\", argc_);
+                }"
+              end
+
+      anonymous_method_name = anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
+
+          VALUE klass = #{global_klass_variable};
+          char method_name[0x100];
+
+          method_name[0] = '_';
+          method_name[1] = 0;
+
+          sprintf(method_name+1, \"#{method_name}\");
+          
+          int i;
+          for (i=0; i<argc_; i++) {
+            sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(argv[i]))));
+          }
+
+          NODE* body;
+          ID id;
+
+          id = rb_intern(method_name);
+          body = rb_method_node(klass,id);
+
+          if (body == 0) {
+            VALUE argv_class[argc_+1];
+            
+            argv_class[0] = CLASS_OF(self); 
+            for (i=0; i<argc_; i++) {
+              argv_class[i+1] = CLASS_OF(argv[i]);
+            }
+            
+            VALUE signature = rb_ary_new4(argc_+1,argv_class);
+            VALUE mobject = rb_funcall(#{global_klass_variable}, #{intern_num :build}, 2, signature,rb_str_new2(#{method_name.to_s.inspect}));
+
+            struct METHOD {
+              VALUE klass, rklass;
+              VALUE recv;
+              ID id, oid;
+              int safe_level;
+              NODE *body;
+            };
+
+            struct METHOD *data;
+            Data_Get_Struct(mobject, struct METHOD, data);
+            body = data->body;
+
+            if (body == 0) {
+              rb_raise(rb_eRuntimeError,\"method not found after build: '%s'\", method_name);
+            }
+          }
+
+            if (nd_type(body) == NODE_CFUNC) {
+              struct {
+                void* parent_frame;
+                void* plocals;
+                jmp_buf jmp;
+                VALUE return_value;
+                int rescue;
+                VALUE last_error;
+                VALUE next_recv;
+                int targetted;
+                struct FASTRUBYTHREADDATA* thread_data;
+              } frame;
+
+              frame.parent_frame = 0;
+              frame.rescue = 0;
+              frame.return_value = Qnil;
+              frame.thread_data = rb_current_thread_data();
+              frame.targetted = 0;
+
+              int argc = body->nd_argc;
+
+              VALUE block = Qfalse;
+
+              if (rb_block_given_p()) {
+                struct {
+                  void *block_function_address;
+                  void *block_function_param;
+                } block_struct;
+
+                block_struct.block_function_address = re_yield;
+                block_struct.block_function_param = 0;
+
+                block = (VALUE)&block_struct;
+              }
+
+              int aux = setjmp(frame.jmp);
+              if (aux != 0) {
+                if (aux == FASTRUBY_TAG_RAISE) {
+                  rb_funcall(self, #{intern_num :raise}, 1, frame.thread_data->exception);
+                }
+
+                if (frame.targetted == 0) {
+                    rb_jump_tag(aux);
+                }
+
+                return Qnil;
+              }
+
+              #{strmakecall}
+            }
+
+          return Qnil;
+        }"
+      }
+
+      alt_options = options.dup
+
+      alt_options.delete(:self)
+      alt_options.delete(:main)
+
+      inline_block "
+        #{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}
+
+                );
+
+        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+        "
+
+    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

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

@@ -0,0 +1,134 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+module FastRuby
+  module ExceptionsTranslator
+    register_translator_module self
+
+
+    def to_c_rescue(tree)
+      if tree[1][0] == :resbody
+        else_tree = tree[2]
+
+        if else_tree
+          to_c else_tree
+        else
+          "Qnil"
+        end
+      else
+        resbody_tree = tree[2]
+        else_tree = nil
+        if tree[-1]
+          if tree[-1][0] != :resbody
+            else_tree = tree[-1]
+          end
+        end
+
+        catch_condition_array = []
+        lasgn_code = ""
+        resbody_code = to_c(resbody_tree[2])
+
+        rescue_code = ""
+
+        tree[1..-1].each do |resbody_tree|
+          next if resbody_tree[0] != :resbody
+
+          if resbody_tree[1].size == 1
+            resbody_tree[1][1] = [:const, :Exception]
+          end
+
+          if resbody_tree[1].last[0] == :lasgn
+            lasgn_code = to_c(resbody_tree[1].last)
+          end
+
+          resbody_tree[1][1..-1].each do |xtree|
+            if xtree[0] != :lasgn
+              trapcode = "rb_eException";
+
+              if xtree
+                trapcode = to_c(xtree)
+              end
+
+              catch_condition_array << "(rb_obj_is_kind_of(frame.thread_data->exception,#{trapcode}) == Qtrue)"
+            end
+          end
+
+          rescue_code << "
+            if (aux == FASTRUBY_TAG_RAISE) {
+              if (#{catch_condition_array.join(" || ")})
+              {
+                // trap exception
+                frame.targetted = 1;
+
+                #{lasgn_code};
+
+                 #{resbody_code};
+              }
+            }
+          "
+        end
+
+        frame_call(
+          frame(to_c(tree[1])+";","
+            #{rescue_code}
+          ", else_tree ? to_c(else_tree) : nil, 1)
+
+          )
+      end
+    end
+
+    def to_c_ensure(tree)
+      if tree.size == 2
+        to_c tree[1]
+      else
+        ensured_code = to_c tree[2]
+        inline_block "
+          #{frame(to_c(tree[1]),ensured_code,ensured_code,1)};
+        "
+      end
+    end
+
+    def _raise(class_tree, message_tree = nil)
+      class_tree = to_c class_tree unless class_tree.instance_of? String
+
+      if message_tree.instance_of? String
+        message_tree = "rb_str_new2(#{message_tree.inspect})"
+      else
+        message_tree = to_c message_tree
+      end
+
+      if message_tree
+        return inline_block("
+            pframe->thread_data->exception = rb_funcall(#{class_tree}, #{intern_num :exception},1,#{message_tree});
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+            return Qnil;
+            ")
+      else
+        return inline_block("
+            pframe->thread_data->exception = rb_funcall(#{class_tree}, #{intern_num :exception},0);
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+            return Qnil;
+            ")
+      end
+
+    end
+    
+  end
+end