fastruby 0.0.21 → 0.0.22

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

@@ -79,7 +79,7 @@ module FastRuby
       recvtype = infer_type(recv)
       
       if args.size > 1
-        if (not recvtype) or args.last[0] == :splat or (not RUBY_VERSION =~ /^1\\.9/)
+        if (not recvtype) or args.last[0] == :splat or (not RUBY_VERSION =~ /^1\.9/)
           if block_pass_arg
             call_tree = tree.dup
             call_tree[3] = args.select{|arg| if arg == :arglist 
@@ -152,55 +152,37 @@ module FastRuby
           end
         end
       end
+      
+      signature = if recvtype
+        [recvtype]
+      else
+        [nil]
+      end 
+
+      args[1..-1].each do |arg|
+        argtype = infer_type(arg)
+        signature << argtype
+      end
+      
+      if block_pass_arg
 
-      if recvtype
-
-        address = nil
-        mobject = nil
-
-        inference_complete = true
-        signature = [recvtype]
-
-        args[1..-1].each do |arg|
-          argtype = infer_type(arg)
-          signature << argtype
-          unless argtype
-            inference_complete = false
-          end
-        end
-
-        if repass_var
-          extraargs = ","+repass_var
-          extraargs_signature = ",VALUE " + repass_var
-        else
-          extraargs = ""
-          extraargs_signature = ""
-        end
-
-          block_proc_tree = s(:call, block_pass_arg[1], :to_proc, s(:arglist)) if block_pass_arg
-
-          block_wrapping_proc = proc { |name| "
-            static VALUE #{name}(int argc, VALUE* argv, VALUE _locals, VALUE _parent_frame) {
-              return rb_proc_call(_locals, rb_ary_new4(argc, argv)); 
-            }
-          "
+        block_proc_tree = s(:call, block_pass_arg[1], :to_proc, s(:arglist))
+        block_wrapping_proc = proc { |name| "
+          static VALUE #{name}(int argc, VALUE* argv, VALUE _locals, VALUE _parent_frame) {
+            return rb_proc_call(_locals, rb_ary_new4(argc, argv)); 
           }
- 
+        "
+        }
+                
+        code = inline_block do 
           if argnum == 0
-            value_cast = "VALUE,VALUE,VALUE"
-
-
-              if block_pass_arg or result_var
-                code = proc{ "
-                {
-                VALUE recv = Qnil;
-                #{to_c recv, "recv"};
-
-                #{@block_struct} block, *pblock = Qfalse;
+            "
+            #{@block_struct} block, *pblock = Qfalse;
+            
+            VALUE proc = Qnil;
+            VALUE recv = Qnil;
 
-                #{if block_pass_arg
-                "
-                VALUE proc = Qnil;
+                #{to_c(recv, "recv")}
                 #{to_c(block_proc_tree, "proc") }
 
                 VALUE block_address_value = rb_ivar_get(proc, #{intern_num "__block_address"});
@@ -217,61 +199,21 @@ module FastRuby
                   block.proc = proc;
                   pblock = &block;
                 }
-
-                "
-                end
-                }
-
-                #{if result_var
-                "
-                #{result_var} = ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, 0, (VALUE[]){});
-                "
-                else
-                "
-                ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, 0, (VALUE[]){});
-                "
-                end
-                }
-                }
-                "
-                }
-              
-                result_var ? code.call : inline_block(&code)
-              else
-                 "((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, 0, (VALUE[]){})"               
-              end          
-
+            
+            return #{dynamic_call(signature,mname)}(recv, (void*)pblock, (void*)pframe, 0, (VALUE[]){});" 
           else
-            value_cast = ( ["VALUE"]*(args.size) ).join(",") + ",VALUE,VALUE"
-            suffix = "_" + rand(1000000).to_s+"_"
-
-                strargs = (0..args_tree.size-2).map{|i| "#{suffix}arg#{i}"}.join(",")
-              if block_pass_arg or result_var
-                code = proc{ "
-                {
-                VALUE recv = Qnil;
-                
-                #{
-                (0..args_tree.size-2).map{ |x|
-                  "VALUE #{suffix}arg#{x};"
-                }.join("\n")
-                }
-
-                #{
-                (0..args_tree.size-2).map{ |x|
-                  to_c(args_tree[x+1], "#{suffix}arg#{x}") + ";"
-                }.join("\n")
-                }
-                
-                #{to_c recv, "recv"};
-
-                #{@block_struct} block, *pblock = Qfalse;
+            strargs = args[1..-1].map{|arg| to_c arg}.join(",")
+            "
+            #{@block_struct} block, *pblock = Qfalse;
+            
+            VALUE proc = Qnil;
+            VALUE recv = Qnil;
 
-                #{if block_pass_arg
-                "
-                VALUE proc = Qnil;
+                #{to_c(recv, "recv")}
                 #{to_c(block_proc_tree, "proc") }
+
                 VALUE block_address_value = rb_ivar_get(proc, #{intern_num "__block_address"});
+
                 if (block_address_value != Qnil) {
                   block.block_function_address = NUM2PTR(block_address_value);
                   block.block_function_param = NUM2PTR(rb_ivar_get(proc, #{intern_num "__block_param"}));
@@ -284,56 +226,35 @@ module FastRuby
                   block.proc = proc;
                   pblock = &block;
                 }
-
-                "
-                end
-                }
-
-                #{if result_var
-                "
-                #{result_var} = ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}});
-                "
-                else
-                "
-                ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}});
-                "
-                end
-                }
-
-                
-                }
-                "
-                }
-                
-                result_var ? code.call : inline_block(&code)
-              else
-                strargs = args[1..-1].map{|arg| to_c arg}.join(",")
-                "((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}})"
-              end
+            
+            
+            return #{dynamic_call(signature,mname)}(recv, (void*)pblock, (void*)pframe, #{args.size-1}, (VALUE[]){#{strargs}});"
           end
-
-      else # else recvtype
-        if argnum == 0
-          code = protected_block("last_expression = rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
-          if result_var
+        end
+        
+        return (if result_var
           "
-            #{result_var} = #{code};
+          #{result_var} = #{code};
           "
-          else
-            code
-          end
+        else
+          code
+        end)   
+      else
+        code = if argnum == 0
+          "#{dynamic_call(signature,mname)}(#{to_c recv}, (void*)Qfalse, (void*)pframe, 0, (VALUE[]){})" 
         else
           strargs = args[1..-1].map{|arg| to_c arg}.join(",")
-          code = protected_block("last_expression = rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", true, repass_var)
-          if result_var
+          "#{dynamic_call(signature,mname)}(#{to_c recv}, (void*)Qfalse, (void*)pframe, #{args.size-1}, (VALUE[]){#{strargs}})"
+        end
+  
+        return (if result_var
           "
-            #{result_var} = #{code};
+          #{result_var} = #{code};
           "
-          else
-            code
-          end
-        end
-      end # if recvtype
+        else
+          code
+        end)        
+      end
     end
 
     define_translator_for(:call, :method => :to_c_attrasgn, :arity => 1)

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

@@ -43,14 +43,14 @@ module FastRuby
       code = "
       
       
-        if (rb_obj_is_kind_of(plocals->self, rb_cClass) || rb_obj_is_kind_of(plocals->self, rb_cModule)) {
+        if (rb_obj_is_kind_of(#{locals_accessor}self, rb_cClass) || rb_obj_is_kind_of(#{locals_accessor}self, rb_cModule)) {
 
           #{unless options[:fastruby_only]
            "rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);"
           end
           }
           
-          #{global_klass_variable} = plocals->self;
+          #{global_klass_variable} = #{locals_accessor}self;
           // set tree
           rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
                   #{global_klass_variable},
@@ -61,7 +61,7 @@ module FastRuby
                   );
           
         } else {
-          VALUE obj = plocals->self;
+          VALUE obj = #{locals_accessor}self;
           rb_define_singleton_method(obj, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
           
           #{global_klass_variable} = CLASS_OF(obj);
@@ -147,120 +147,64 @@ private
     def anonymous_dispatcher(global_klass_variable, method_name)
       
       strmethodargs = "self,block,(VALUE)&frame"
-      
+      nilsignature = [nil]*32      
+
       anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
-          VALUE klass = #{global_klass_variable};
-          char method_name[argc_*40+64];
+          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;
+
+          volatile VALUE block = Qfalse;
+
+          if (rb_block_given_p()) {
+            struct {
+              void* block_function_address;
+              void* block_function_param;
+              VALUE proc;
+            } block_struct;
+
+            block_struct.block_function_address = re_yield;
+            block_struct.block_function_param = 0;
+            block_struct.proc = rb_block_proc();
+
+            block = (VALUE)&block_struct;
+          }
 
-          method_name[0] = '_';
-          method_name[1] = 0;
 
-          sprintf(method_name+1, \"#{method_name}\");
-          sprintf(method_name+strlen(method_name), \"%li\", (long)NUM2PTR(rb_obj_id(CLASS_OF(self))));
-          
-                      int i;
-                      for (i=0; i<argc_; i++) {
-                        sprintf(method_name+strlen(method_name), \"%li\", (long)NUM2PTR(rb_obj_id(CLASS_OF(argv[i]))));
-                      }
-
-          void** address = 0;
-          void* fptr = 0;
-          ID id;
-          VALUE rb_method_hash;
-
-          id = rb_intern(method_name);
-          rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value method_name});
-          
-          if (rb_method_hash != Qnil) {
-            VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
-            if (tmp != Qnil) {
-                address = (void**)NUM2PTR(tmp);
-                fptr = *address;
+          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 (fptr == 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);
-            
-            rb_funcall(#{global_klass_variable}, #{intern_num :build}, 2, signature,rb_str_new2(#{method_name.to_s.inspect}));
-  
-            id = rb_intern(method_name);
-            rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value method_name});
-            
-            if (rb_method_hash != Qnil) {
-              VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
-              if (tmp != Qnil) {
-                  address = (void**)NUM2PTR(tmp);
-                  fptr = *address;
-              }
-            }
-            
-            if (fptr == 0) {
-              rb_raise(rb_eRuntimeError, \"Error: method not found after build\");
+            if (frame.targetted == 0) {
+              frb_jump_tag(aux);
             }
 
+            return Qnil;
           }
-
-              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;
-
-              volatile VALUE block = Qfalse;
-
-              if (rb_block_given_p()) {
-                struct {
-                  void* block_function_address;
-                  void* block_function_param;
-                  VALUE proc;
-                } block_struct;
-
-                block_struct.block_function_address = re_yield;
-                block_struct.block_function_param = 0;
-                block_struct.proc = rb_block_proc();
-
-                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) {
-                    frb_jump_tag(aux);
-                }
-
-                return Qnil;
-              }
               
-              VALUE tmp = Qnil;
-              if (argv == 0) argv = &tmp;
+          VALUE tmp = Qnil;
+          if (argv == 0) argv = &tmp;
 
-              return ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))fptr)(#{strmethodargs}, argc_, argv);
+          return #{dynamic_call(nilsignature, method_name.to_sym, false, false, global_klass_variable)}(self, (void*)block, (void*)&frame, argc_, argv);
         }"
       }
+
       
     end
   end

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

@@ -0,0 +1,211 @@
+=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 Context
+    
+    define_translator_for(:defn, :method => :to_c_defn)
+    def to_c_defn(tree, result_var = nil)
+
+      method_name = tree[1]
+      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)
+
+      code = "
+      
+      
+        if (rb_obj_is_kind_of(#{locals_accessor}self, rb_cClass) || rb_obj_is_kind_of(#{locals_accessor}self, rb_cModule)) {
+
+          #{unless options[:fastruby_only]
+           "rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);"
+          end
+          }
+          
+          #{global_klass_variable} = #{locals_accessor}self;
+          // set tree
+          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 4,
+                  #{global_klass_variable},
+                  rb_str_new2(#{method_name.to_s.inspect}),
+                  #{literal_value tree},
+                  #{literal_value alt_options}
+  
+                  );
+          
+        } else {
+          VALUE obj = plocals->self;
+          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}, 4,
+                  #{global_klass_variable},
+                  rb_str_new2(#{method_name.to_s.inspect}),
+                  #{literal_value tree},
+                  #{literal_value alt_options}
+  
+                  );
+        }
+        
+        "
+
+      if result_var
+        code + "\n#{result_var} = Qnil;"
+      else
+        inline_block code + "\nreturn Qnil;\n"
+      end
+    end
+
+    define_translator_for(:defs, :method => :to_c_defs)
+    def to_c_defs(tree, result_var = nil)
+      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
+      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)
+
+      code = "
+      
+        VALUE obj = Qnil;
+        #{to_c tree[1], "obj"};
+        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}, 4,
+                #{global_klass_variable},
+                rb_str_new2(#{method_name.to_s.inspect}),
+                #{literal_value tree},
+                #{literal_value alt_options}
+
+                );
+
+        "
+
+      if result_var
+        code + "\n#{result_var} = Qnil;"
+      else
+        inline_block code + "\nreturn Qnil;\n"
+      end
+        
+    end
+
+    define_translator_for(:scope, :method => :to_c_scope)
+    def to_c_scope(tree, result_var = nil)
+      if tree[1]
+        if result_var
+          to_c(tree[1], result_var)
+        else
+          to_c(tree[1])
+        end
+      else
+        "Qnil"
+      end
+    end
+    
+private
+ 
+    def anonymous_dispatcher(global_klass_variable, method_name)
+      
+      strmethodargs = "self,block,(VALUE)&frame"
+      nilsignature = [nil]*32      
+
+      anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(int argc_, VALUE* argv, VALUE self) {
+          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;
+
+          volatile VALUE block = Qfalse;
+
+          if (rb_block_given_p()) {
+            struct {
+              void* block_function_address;
+              void* block_function_param;
+              VALUE proc;
+            } block_struct;
+
+            block_struct.block_function_address = re_yield;
+            block_struct.block_function_param = 0;
+            block_struct.proc = rb_block_proc();
+
+            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) {
+              frb_jump_tag(aux);
+            }
+
+            return Qnil;
+          }
+              
+          VALUE tmp = Qnil;
+          if (argv == 0) argv = &tmp;
+
+          return #{dynamic_call(nilsignature, method_name.to_sym, false, false, global_klass_variable)}(self, (void*)block, (void*)&frame, argc_, argv);
+        }"
+      }
+
+      
+    end
+  end
+end