fastruby 0.0.13 → 0.0.14

data/lib/fastruby/translator/translator.rb

@@ -336,12 +336,44 @@ module FastRuby
                 #{literal_value signature}
                 );
 
-          rb_define_method(#{literal_value klass}, RSTRING(method_name)->ptr, #{alt_method_name}, #{size});
+          ID id = rb_intern(RSTRING(method_name)->ptr);
+          
+          rb_funcall(
+                #{literal_value FastRuby},
+                #{intern_num :set_builder_module},
+                1,
+                #{literal_value klass}
+                );
+          
+          VALUE rb_method_hash;
+          void** address = 0;
+          rb_method_hash = rb_funcall(#{literal_value klass}, #{intern_num :method_hash},1,#{literal_value method_name});
+
+          if (rb_method_hash != Qnil) {
+            VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
+            if (tmp != Qnil) {
+                address = (void*)FIX2LONG(tmp);
+            }
+          }
+          
+          if (address == 0) {
+            address = malloc(sizeof(void*));
+          }
+          *address = #{alt_method_name};
+          
+          rb_funcall(
+              #{literal_value klass},
+              #{intern_num :register_method_value}, 
+              3,
+              #{literal_value method_name},
+              LONG2FIX(id),
+              LONG2FIX(address)
+              );
         }
       "
     end
 
-    def to_c_method(tree)
+    def to_c_method(tree, signature = nil)
       method_name = tree[1]
       args_tree = tree[2]
       impl_tree = tree[3][1]
@@ -350,7 +382,7 @@ module FastRuby
         initialize_method_structs(args_tree)
 
         strargs = if args_tree.size > 1
-          "VALUE block, VALUE _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg.to_s.gsub("*","")}" }.join(",") }"
+          "VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
         else
           "VALUE block, VALUE _parent_frame"
         end
@@ -447,16 +479,68 @@ module FastRuby
         initialize_method_structs(args_tree)
 
         strargs = if args_tree.size > 1
-          "VALUE block, VALUE _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg.to_s.gsub("*","")}" }.join(",") }"
+          "VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
         else
           "VALUE block, VALUE _parent_frame"
         end
+        
+        is_splat_args = args_tree[1..-1].find{|x| x.to_s.match(/\*/) }
+        
+        if is_splat_args
+          
+          i = -1
+          
+          read_arguments_code = args_tree[1..-2].map { |arg|
+              arg = arg.to_s
+              i = i + 1
+              "plocals->#{arg} = arg#{i};\n"
+            }.join("")
+            
+            arguments_array = [(signature.size-1) - (args_tree.size-2)] + (args_tree.size-2..signature.size-1).map{|x| "arg#{x}"}
+            
+          read_arguments_code << "
+            plocals->#{args_tree[-1].to_s.gsub("*","")} = rb_ary_new3(
+                  #{arguments_array.join(",")} 
+                  );
+          "
+
+          validate_arguments_code = if signature.size-1 >= args_tree.size-2
+            "
+            "
+          else
+            "
+              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size} for #{args_tree.size-2})\");
+            "
+          end
+          
+        else
+          
+          i = -1
+          
+          read_arguments_code = args_tree[1..-1].map { |arg|
+              arg = arg.to_s
+              i = i + 1
+              "plocals->#{arg} = arg#{i};\n"
+            }.join("")
+
+          validate_arguments_code = if signature.size-1 >= args_tree.size-1
+            "
+            "
+          else
+            "
+              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{args_tree.size-1})\");
+            "
+          end
+          
+        end
+        
 
         ret = "VALUE #{@alt_method_name || method_name}(#{strargs}) {
+          #{validate_arguments_code}
 
           #{@frame_struct} frame;
           #{@frame_struct} *pframe;
-
+          
           frame.parent_frame = (void*)_parent_frame;
           frame.return_value = Qnil;
           frame.rescue = 0;
@@ -523,11 +607,7 @@ module FastRuby
 
           plocals->self = self;
 
-          #{args_tree[1..-1].map { |arg|
-            arg = arg.to_s
-            arg.gsub!("*","")
-            "plocals->#{arg} = #{arg};\n"
-          }.join("") }
+          #{read_arguments_code}
 
           pblock = (void*)block;
           if (pblock) {
@@ -934,8 +1014,11 @@ module FastRuby
 
     def encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name = nil)
       name = self.add_global_name("void*", 0);
-      cruby_name = self.add_global_name("void*", 0);
-      cruby_len = self.add_global_name("int", 0);
+      address_name = self.add_global_name("void**", 0);
+      @last_address_name = address_name
+      cfunc_address_name = self.add_global_name("void**", 0);
+      cfunc_real_address_name  = self.add_global_name("void*", 0);
+      tree_pointer_name = self.add_global_name("VALUE*", 0);
       args_tree = call_tree[3]
       method_tree = nil
 
@@ -944,7 +1027,6 @@ module FastRuby
       rescue NoMethodError
       end
 
-
       strargs_signature = (0..args_tree.size-2).map{|x| "VALUE arg#{x}"}.join(",")
       strargs = (0..args_tree.size-2).map{|x| "arg#{x}"}.join(",")
       inprocstrargs = (1..args_tree.size-1).map{|x| "((VALUE*)method_arguments)[#{x}]"}.join(",")
@@ -958,54 +1040,105 @@ module FastRuby
         toprocstrargs = "self"
       end
 
-      ruby_wrapper = anonymous_function{ |funcname| "
+      value_cast = ( ["VALUE"]*(args_tree.size) ).join(",") + ",VALUE,VALUE"
+
+      recvdump = nil
+
+      begin
+         recvdump = literal_value recvtype
+      rescue
+      end
+      
+      pureruby_wrapper = anonymous_function{ |funcname| "
         static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
           #{@frame_struct}* pframe = frame;
-
           VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
-
+  
           return #{
             protected_block "rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
             };
         }
-        "
+      "
       }
-
-      value_cast = ( ["VALUE"]*(args_tree.size) ).join(",")
-
-      cruby_wrapper = anonymous_function{ |funcname| "
+      
+      generic_wrapper = anonymous_function{ |funcname| "
         static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
+        
           #{@frame_struct}* pframe = frame;
-
           VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
-
-          // call to #{recvtype}::#{mname}
-
-          if (#{cruby_len} == -1) {
-            return #{
-              protected_block "((VALUE(*)(int,VALUE*,VALUE))#{cruby_name})(#{args_tree.size-1}, ((VALUE*)method_arguments)+1,*((VALUE*)method_arguments));", false, "method_arguments"
-              };
-
-          } else if (#{cruby_len} == -2) {
+          
+          void* fptr = 0;
+          
+          if (*#{address_name} == 0) {
+            if (#{tree_pointer_name} != 0) {
+              if (*#{tree_pointer_name} != Qnil) {
+                VALUE signature = #{literal_value signature};
+                VALUE recvtype = #{recvdump};
+                VALUE mname = #{literal_value mname};
+                
+                rb_funcall(recvtype, #{intern_num :build}, 2, signature, mname);
+              }
+            }
+          }
+          
+          fptr = *#{address_name};
+          
+          #{
+            if args_tree.size < 25
+            "
+            if (fptr == 0) {
+              fptr = *#{cfunc_address_name};
+              if (fptr != 0) {
+                VALUE params[2] = {self,LONG2FIX(#{args_tree.size-1})};
+                return ( (VALUE(*)(#{value_cast})) (fptr) )((VALUE)params,(VALUE)block,(VALUE)frame#{inprocstrargs});  
+              }
+            }
+            "
+            end
+          } 
+          
+          if (fptr == 0) {
             return #{
-              protected_block "((VALUE(*)(VALUE,VALUE))#{cruby_name})(*((VALUE*)method_arguments), rb_ary_new4(#{args_tree.size-1},((VALUE*)method_arguments)+1) );", false, "method_arguments"
+              protected_block "rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
               };
-
           } else {
-            return #{
-              protected_block "((VALUE(*)(#{value_cast}))#{cruby_name})(((VALUE*)method_arguments)[0] #{inprocstrargs});", false, "method_arguments"
-              };
+            return ( (VALUE(*)(#{value_cast})) (fptr) )(self,(VALUE)block,(VALUE)frame#{inprocstrargs});  
           }
         }
         "
       }
 
-      recvdump = nil
 
-      begin
-         recvdump = literal_value recvtype
-      rescue
-      end
+      cfunc_value_cast = (["VALUE"]*args_tree.size).join(",")
+      cfunc_wrapper = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE* params, void* block,void* frame#{strargs_signature}){
+            VALUE self = params[0];
+            VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
+            return ( (VALUE(*)(#{cfunc_value_cast})) (#{cfunc_real_address_name}) )(self#{inprocstrargs});
+        }
+        "
+      }
+      
+      toprocstrargs = (0..25).map{|x| "arg#{x}"}.join(",")
+      strargs_signature = (0..25).map{|x| "VALUE arg#{x}"}.join(",")
+
+      cfunc_wrapper_1 = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE* params, void* block,void* frame, #{strargs_signature}){
+            VALUE self = params[0];
+            VALUE method_arguments[26] = {#{toprocstrargs}};
+            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(FIX2LONG(params[1]),method_arguments,self);
+        }
+        "
+      }
+
+      cfunc_wrapper_2 = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE* params, void* block,void* frame, #{strargs_signature}){
+            VALUE self = params[0];
+            VALUE args = rb_ary_new3(FIX2LONG(params[1]),#{toprocstrargs});
+            return ( (VALUE(*)(VALUE,VALUE)) (#{cfunc_real_address_name}) )(self,args);
+        }
+        "
+      }
 
       if recvdump and recvtype
         init_extra << "
@@ -1015,67 +1148,96 @@ module FastRuby
             VALUE signature = #{literal_value signature};
             VALUE mname = #{literal_value mname};
             VALUE tree = #{literal_value method_tree};
-            VALUE convention = rb_funcall(recvtype, #{intern_num :convention}, 3,signature,mname,#{inference_complete ? "Qtrue" : "Qfalse"});
-            VALUE mobject = rb_funcall(recvtype, #{intern_num :method_from_signature},3,signature,mname,#{inference_complete ? "Qtrue" : "Qfalse"});
-
-            struct METHOD {
-              VALUE klass, rklass;
-              VALUE recv;
-              ID id, oid;
-              int safe_level;
-              NODE *body;
-            };
-
-            int len = 0;
-            void* address = 0;
-
-            if (mobject != Qnil) {
-
-              struct METHOD *data;
-              Data_Get_Struct(mobject, struct METHOD, data);
-
-              if (nd_type(data->body) == NODE_CFUNC) {
-              address = data->body->nd_cfnc;
-              len = data->body->nd_argc;
+            VALUE rb_str_signature = rb_funcall(
+                                      #{literal_value FastRuby},
+                                      #{intern_num :make_str_signature},
+                                      2,
+                                      mname,
+                                      signature);
+
+
+
+            VALUE fastruby_method = rb_funcall(recvtype, #{intern_num :fastruby_method}, 1, mname);
+            #{tree_pointer_name} = (VALUE*)FIX2LONG(fastruby_method_tree_pointer(fastruby_method));
+            
+            ID id;
+            ID default_id = rb_intern(\"default\");
+            VALUE rb_method_hash;
+            void** address = 0;
+            void** default_address = 0;
+            id = rb_intern(RSTRING(rb_str_signature)->ptr);
+            rb_method_hash = rb_funcall(recvtype, #{intern_num :method_hash},1,mname);
+
+            if (rb_method_hash != Qnil) {
+              VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
+              if (tmp != Qnil) {
+                  address = (void*)FIX2LONG(tmp);
+              }
+              
+              tmp = rb_hash_aref(rb_method_hash, LONG2FIX(default_id));
+              if (tmp != Qnil) {
+                 default_address = (void*)FIX2LONG(tmp);
               }
             }
-
-            if (address==0) convention = #{literal_value :ruby};
-
-            #{convention_global_name ? convention_global_name + " = 0;" : ""}
-            if (recvtype != Qnil) {
-
-              if (convention == #{literal_value :fastruby}) {
-                #{convention_global_name ? convention_global_name + " = 1;" : ""}
-                #{name} = address;
-              } else if (convention == #{literal_value :fastruby_array}) {
-                // ruby, wrap rb_funcall
-                #{name} = (void*)#{ruby_wrapper};
-              } else if (convention == #{literal_value :cruby}) {
-                // cruby, wrap direct call
-                #{cruby_name} = address;
-
-                if (#{cruby_name} == 0) {
-                  #{name} = (void*)#{ruby_wrapper};
-                } else {
-                  #{cruby_len} = len;
-                  #{name} = (void*)#{cruby_wrapper};
+            
+            if (default_address==0) {
+              default_address = malloc(sizeof(void*));
+              NODE* body = rb_method_node(recvtype,#{intern_num mname});
+              *default_address = 0;
+              
+              if (body != 0) {
+                if (nd_type(body) == NODE_CFUNC) {
+                  if (body->nd_argc == #{args_tree.size-1}) {
+                    *default_address = #{cfunc_wrapper};
+                    #{cfunc_real_address_name} = (void*)body->nd_cfnc;
+                  } else if (body->nd_argc == -1) {
+                    *default_address = #{cfunc_wrapper_1};
+                    #{cfunc_real_address_name} = (void*)body->nd_cfnc;
+                  } else if (body->nd_argc == -2) {
+                    *default_address = #{cfunc_wrapper_2};
+                    #{cfunc_real_address_name} = (void*)body->nd_cfnc;
+                  }
                 }
-              } else {
-                // ruby, wrap rb_funcall
-                #{name} = (void*)#{ruby_wrapper};
               }
-            } else {
-              // ruby, wrap rb_funcall
-              #{name} = (void*)#{ruby_wrapper};
+            
+              if (recvtype != Qnil) { 
+                rb_funcall(
+                    recvtype,
+                    #{intern_num :register_method_value}, 
+                    3,
+                    #{literal_value mname},
+                    LONG2FIX(default_id),
+                    LONG2FIX(default_address)
+                    );
+              }
             }
 
+            if (address==0) {
+              address = malloc(sizeof(void*));
+              
+              if (recvtype != Qnil) { 
+                rb_funcall(
+                    recvtype,
+                    #{intern_num :register_method_value}, 
+                    3,
+                    #{literal_value mname},
+                    LONG2FIX(id),
+                    LONG2FIX(address)
+                    );
+              }
+  
+              *address = 0; //(void*)
+            }
+            
+            #{address_name} = address;
+            #{cfunc_address_name} = default_address;
+            #{name} = (void*)#{generic_wrapper};
           }
         "
       else
         init_extra << "
         // ruby, wrap rb_funcall
-        #{name} = (void*)#{ruby_wrapper};
+        #{name} = (void*)#{pureruby_wrapper};
         "
       end
 

data/lib/fastruby.rb

@@ -25,14 +25,5 @@ require "fastruby/custom_require"
 require "fastruby/set_tree"
 
 module FastRuby
-  class << self
-    attr_accessor :fastruby_script_path
-    attr_accessor :fastruby_load_path
-  end
-
-  FastRuby.fastruby_script_path = File.expand_path(__FILE__)
-  FastRuby.fastruby_load_path = File.expand_path(File.dirname(__FILE__))
-
-  VERSION = "0.0.13" unless defined? FastRuby::VERSION
+  VERSION = "0.0.14" unless defined? FastRuby::VERSION
 end
-

data/lib/fastruby_load_path.rb

@@ -0,0 +1,29 @@
+=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
+  class << self
+    attr_accessor :fastruby_script_path
+    attr_accessor :fastruby_load_path
+  end
+
+  FastRuby.fastruby_script_path = File.expand_path(__FILE__)
+  FastRuby.fastruby_load_path = File.expand_path(File.dirname(__FILE__))
+end

data/spec/call/base_call_spec.rb

@@ -0,0 +1,82 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  def self.test_arguments(x)
+    it "should allow #{x} arguments calling to cfunc" do
+      
+          arguments = (0..x).map(&:to_s).join(",")
+      
+            fastruby "
+          class ::CYR#{x}
+              def foo
+                a = []
+                a.infer(Array).push(#{arguments})
+                a
+              end
+          end
+            "
+          
+          eval("::CYR#{x}").new.foo.should be == eval("[#{arguments}]")
+    end
+  end
+  
+  test_arguments(10)
+  test_arguments(15)
+  test_arguments(20)
+  
+  (23..27).each do |i|
+    test_arguments(i)
+  end
+  
+  test_arguments(20)
+  
+    
+  def self.test_fastruby_arguments(argnum)
+    it "should allow #{argnum} arguments calling fastruby" do
+      
+          arguments_name = (0..argnum-1).map{|x| "a"+x.to_s}.join(",")
+          arguments = (0..argnum-1).map(&:to_s).join(",")
+      
+            fastruby "
+          class ::CYR1_#{argnum}
+              def foo(#{arguments_name})
+                [#{arguments_name}]
+              end
+          end
+            "
+          
+          array = eval("[#{arguments}]")
+          
+          eval("::CYR1_#{argnum}").new.foo(*array).should be == array 
+    end
+  end
+  
+  (8..12).each do |i|
+    test_fastruby_arguments(i)
+  end
+  
+  def self.test_invalid_fastruby_arguments(argnum)
+    it "should allow #{argnum} arguments calling fastruby" do
+      
+          arguments_name = (0..argnum-1).map{|x| "a"+x.to_s}.join(",")
+          arguments = (0..argnum-1).map(&:to_s).join(",")
+      
+            fastruby "
+          class ::CYR1_#{argnum}
+              def foo(#{arguments_name})
+                [#{arguments_name}]
+              end
+          end
+            "
+          
+          array = eval("[#{arguments}]")
+          
+          lambda {
+          eval("::CYR1_#{argnum}").new.foo(*array).should be == array
+          }.should raise_error(ArgumentError) 
+    end
+  end
+  
+  test_invalid_fastruby_arguments(15)
+  
+end

data/spec/defn/multiple_args_spec.rb

@@ -268,4 +268,15 @@ describe FastRuby, "fastruby" do
     }.should raise_error(ArgumentError)
   end
   
+  it "should call Array#to_s when infering array type for splat argument" do
+      fastruby "
+        class ::CF18
+          def foo(*x)
+            x.to_s
+          end
+        end
+      "
+
+      ::CF18.new.foo(1,2,3,4,5).should be == "12345"
+  end
 end

data/spec/defn/replacement_spec.rb

@@ -0,0 +1,102 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  it "should allow replace methods after they are called and compiled at runtime" do
+    fastruby "
+      class JU1
+        def foo
+          6
+        end
+      end
+    "
+    
+    ::JU1.new.foo
+    
+    fastruby "
+      class JU1
+        def foo
+          9
+        end
+      end
+    "
+    
+    ::JU1.new.foo.should be == 9
+  end
+
+  it "should allow replace methods after they are called and compiled at runtime (through other method)" do
+    fastruby "
+      class JU2
+        def foo
+          6
+        end
+        
+        def bar
+          foo
+        end
+      end
+    "
+    
+    ::JU2.new.bar
+    
+    fastruby "
+      class JU2
+        def foo
+          9
+        end
+      end
+    "
+    
+    ::JU2.new.bar.should be == 9
+  end
+  
+  it "should allow replace methods using ruby after they are called and compiled at runtime (through other method)" do
+    fastruby "
+      class ::JU3
+        def foo
+          6
+        end
+        
+        def bar
+          foo
+        end
+      end
+    "
+    
+    ::JU3.new.bar
+    
+      class ::JU3
+        def foo
+          9
+        end
+      end
+    
+    ::JU3.new.bar.should be == 9
+  end  
+  
+  it "should allow replace methods using indentical code string" do
+    code = "
+      class ::JU4
+        def foo
+          6
+        end
+      end
+    "
+    
+    fastruby code
+    
+    ::JU4.new.foo.should be == 6
+    
+    fastruby "class ::JU4
+        def foo
+          9
+        end
+      end
+    "
+
+    ::JU4.new.foo.should be == 9
+
+    fastruby code
+
+    ::JU4.new.foo.should be == 6
+  end  
+end