fastruby 0.0.16 → 0.0.17

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

@@ -33,10 +33,10 @@ module FastRuby
           pframe = (void*)frame_param;
           plocals = (void*)pframe->plocals;
 
-          if (FIX2LONG(plocals->block_function_address) == 0) {
+          if ((plocals->block_function_address) == 0) {
             #{_raise("rb_eLocalJumpError", "no block given")};
           } else {
-            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))FIX2LONG(plocals->block_function_address))(size, block_args, FIX2LONG(plocals->block_function_param), (VALUE)pframe);
+            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))(plocals->block_function_address))(size, block_args, (VALUE)(plocals->block_function_param), (VALUE)pframe);
           }
         }
       "
@@ -45,15 +45,20 @@ module FastRuby
       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])};
+        ret = "
+          VALUE splat_array = Qnil;
+          VALUE block_aux = Qnil;
+           #{to_c(splat_arg[1], "splat_array")};
           
           if (CLASS_OF(splat_array) == rb_cArray) {
             VALUE block_args[_RARRAY_LEN(splat_array) + #{tree.size}];
             int i;
             #{ 
               (0..tree.size-3).map{|i|
-                "block_args[#{i}] = #{to_c(tree[i+1])}"
+                "
+                #{to_c(tree[i+1], "block_aux")};
+                block_args[#{i}] = block_aux;
+                "
               }.join(";\n")
             };
             
@@ -61,53 +66,55 @@ module FastRuby
               block_args[i+#{tree.size-2}] = rb_ary_entry(splat_array,i);
             }
             
-            return #{anonymous_function(&block_code)}((VALUE)pframe, block_args, _RARRAY_LEN(splat_array) + #{tree.size-2});
+            last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, _RARRAY_LEN(splat_array) + #{tree.size-2});
           } else {
             VALUE block_args[1+#{tree.size}];
             #{ 
               (0..tree.size-3).map{|i|
-                "block_args[#{i}] = #{to_c(tree[i+1])}"
+                "
+                #{to_c(tree[i+1], "block_aux")};
+                block_args[#{i}] = block_aux;
+                "
               }.join(";\n")
             };
             
             block_args[#{tree.size-2}] = splat_array;
-            return #{anonymous_function(&block_code)}((VALUE)pframe, block_args, #{tree.size-1});
+            last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, #{tree.size-1});
           }
           
         "
       else
         ret = if tree.size > 1
-            anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}},#{tree.size-1})"
+            "last_expression = " + 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})"
+            "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){}, #{tree.size-1})"
           end
       end
       
       protected_block(ret, false)
     end
 
-    def to_c_block(tree)
+    def to_c_block(tree, result_variable = nil)
       if tree.size == 1
         return inline_block("return Qnil;")
       end
-
+      
       str = ""
       str = tree[1..-2].map{ |subtree|
-        to_c(subtree)
+        to_c(subtree,"last_expression")
       }.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
+          str = str + ";#{to_c(tree[-1],"last_expression")};"
       end
 
-      str << "return last_expression;"
-
-      inline_block str
+      if result_variable
+        str << "#{result_variable} = last_expression;"
+        str
+      else
+        str << "return last_expression;"
+        inline_block str
+      end
     end
     
   end

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

@@ -23,12 +23,18 @@ module FastRuby
     
     register_translator_module self
 
-    def to_c_call(tree, repass_var = nil)
+    def to_c_call(tree, result_var = nil)
       directive_code = directive(tree)
+      repass_var = @repass_var
+
       if directive_code
-        return directive_code
+        if result_var
+          return "#{result_var} = #{directive_code};\n"
+        else
+          return directive_code
+        end
       end
-
+      
       if tree[2] == :require
         tree[2] = :fastruby_require
       elsif tree[2] == :raise
@@ -36,10 +42,11 @@ module FastRuby
         args = tree[3]
         return _raise(args[1],args[2])
       end
-      
+
       recv = tree[1]
       mname = tree[2]
       args = tree[3]
+      args_tree = tree[3]
       
       # search block_pass on arguments
       block_pass_arg = args.find{|arg| if arg == :arglist
@@ -47,24 +54,18 @@ module FastRuby
           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)
+        args_tree = args_tree.dup.reject{|st| 
+          if st.respond_to? :node_type
+            st.node_type == :block_pass
+          else 
+            false
+          end
+         }
+        args = args_tree
       end
-
+ 
       mname = :require_fastruby if mname == :require
 
       argnum = args.size - 1
@@ -74,12 +75,40 @@ module FastRuby
       recvtype = infer_type(recv)
       
       if args.size > 1
+        if (not recvtype) or args.last[0] == :splat
+          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, s(:lvar, :__x_proc), :call, s(:arglist, s(:splat, s(:lvar, :__xblock_arguments))))
+            
+            replace_iter_tree = s(:block,
+                s(:lasgn, :__x_proc, s(:call, block_pass_arg[1], :to_proc, s(:arglist))),
+                s(:iter, call_tree, block_arguments_tree, block_tree)
+                ).to_fastruby_sexp
+          
+            if result_var  
+              return to_c(replace_iter_tree,result_var)
+            else
+              return to_c(replace_iter_tree)
+            end
+          end
+        end
+
         if args.last[0] == :splat
-          return protected_block(
-            inline_block(
+          aux_varname = "_aux_" + rand(1000000).to_s
+          code = protected_block(
             "
             
-            VALUE array = #{to_c args.last[1]};
+            VALUE array = Qnil;
+            
+            #{to_c args.last[1], "array"};
             
             if (TYPE(array) != T_ARRAY) {
               array = rb_ary_new4(1,&array);
@@ -87,15 +116,21 @@ module FastRuby
             
             int argc = #{args.size-2};
             VALUE argv[#{args.size} + _RARRAY_LEN(array)];
-            
+            VALUE #{aux_varname} = Qnil;
             #{
               i = -1
               args[1..-2].map {|arg|
                 i = i + 1
-                "argv[#{i}] = #{to_c arg}"
+                "#{to_c arg, aux_varname};
+                argv[#{i}] = #{aux_varname};
+                "
               }.join(";\n")
             };
             
+            VALUE recv = Qnil;
+            
+            #{to_c recv, "recv"};
+            
             int array_len = _RARRAY_LEN(array);
             
             int i;
@@ -104,14 +139,17 @@ module FastRuby
               argc++; 
             }
             
-            return rb_funcall2(#{to_c recv}, #{intern_num tree[2]}, argc, argv);
-            "
-            ), true, repass_var)
+            last_expression = rb_funcall2(recv, #{intern_num tree[2]}, argc, argv);
+            ", true, repass_var)
+            
+          if result_var
+           return "#{result_var} = #{code};\n"
+          else
+           return code
+          end
         end
       end
 
-      strargs = args[1..-1].map{|arg| to_c arg}.join(",")
-
       if recvtype
 
         address = nil
@@ -136,19 +174,158 @@ module FastRuby
           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)); 
+            }
+          "
+          }
+ 
           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)"
+
+
+              if block_pass_arg or result_var
+                code = "
+                {
+                VALUE recv = Qnil;
+                #{to_c recv, "recv"};
+
+                #{@block_struct} block, *pblock = Qfalse;
+
+                #{if block_pass_arg
+                "
+                VALUE proc = Qnil;
+                #{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"}));
+                  block.proc = proc;
+                  pblock = █
+                } else {
+                  // create a block from a proc
+                  block.block_function_address = ((void*)#{anonymous_function(&block_wrapping_proc)});
+                  block.block_function_param = (void*)proc;
+                  block.proc = proc;
+                  pblock = █
+                }
+
+                "
+                end
+                }
+
+                #{if result_var
+                "
+                #{result_var} = ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe);
+                "
+                else
+                "
+                ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe);
+                "
+                end
+                }
+                }
+                "
+              
+                result_var ? code : inline_block(code)
+              else
+                 "((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe)"               
+              end          
+
           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})"
+            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 = "
+                {
+                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;
+
+                #{if block_pass_arg
+                "
+                VALUE proc = Qnil;
+                #{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"}));
+                  block.proc = proc;
+                  pblock = █
+                } else {
+                  // create a block from a proc
+                  block.block_function_address = ((void*)#{anonymous_function(&block_wrapping_proc)});
+                  block.block_function_param = (void*)proc;
+                  block.proc = proc;
+                  pblock = █
+                }
+
+                "
+                end
+                }
+
+                #{if result_var
+                "
+                #{result_var} = ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, #{strargs});
+                "
+                else
+                "
+                ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(recv, (VALUE)pblock, (VALUE)pframe, #{strargs});
+                "
+                end
+                }
+
+                
+                }
+                "
+                result_var ? code : inline_block(code)
+              else
+                strargs = args[1..-1].map{|arg| to_c arg}.join(",")
+                "((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{strargs})"
+              end
           end
 
       else # else recvtype
         if argnum == 0
-          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
+          code = protected_block("last_expression = rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
+          if result_var
+          "
+            #{result_var} = #{code};
+          "
+          else
+            code
+          end
         else
-          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", true, repass_var)
+          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
+          "
+            #{result_var} = #{code};
+          "
+          else
+            code
+          end
         end
       end # if recvtype
     end

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

@@ -22,7 +22,7 @@ module FastRuby
   module DefnTranslator
     register_translator_module self
 
-    def to_c_defn(tree)
+    def to_c_defn(tree, result_var = nil)
 
       method_name = tree[1]
       args_tree = tree[2].select{|x| x.to_s[0] != ?&}
@@ -40,27 +40,49 @@ module FastRuby
       alt_options.delete(:self)
       alt_options.delete(:main)
 
-      inline_block "
+      code = "
       
-        usleep(0);
-        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1);
+      
+        if (rb_obj_is_kind_of(plocals->self, rb_cClass) || rb_obj_is_kind_of(plocals->self, rb_cModule)) {
+          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}
+  
+                  );
+          
+        } 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}, 5,
+                  #{global_klass_variable},
+                  rb_str_new2(#{method_name.to_s.inspect}),
+                  #{literal_value tree},
+                  #{literal_value snippet_hash},
+                  #{literal_value alt_options}
+  
+                  );
+        }
         
-        #{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}
-
-                );
-
         "
 
+      if result_var
+        code + "\n#{result_var} = Qnil;"
+      else
+        inline_block code + "\nreturn Qnil;\n"
+      end
     end
 
-    def to_c_defs(tree)
+    def to_c_defs(tree, result_var = nil)
       method_name = tree[2]
       args_tree = tree[3].select{|x| x.to_s[0] != ?&}
       
@@ -78,9 +100,10 @@ module FastRuby
       alt_options.delete(:self)
       alt_options.delete(:main)
 
-      inline_block "
+      code = "
       
-        VALUE obj = #{to_c tree[1]};
+        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);
@@ -95,12 +118,22 @@ module FastRuby
                 );
 
         "
+
+      if result_var
+        code + "\n#{result_var} = Qnil;"
+      else
+        inline_block code + "\nreturn Qnil;\n"
+      end
         
     end
 
-    def to_c_scope(tree)
+    def to_c_scope(tree, result_var = nil)
       if tree[1]
-        to_c(tree[1])
+        if result_var
+          to_c(tree[1], result_var)
+        else
+          to_c(tree[1])
+        end
       else
         "Qnil"
       end
@@ -120,11 +153,11 @@ private
           method_name[1] = 0;
 
           sprintf(method_name+1, \"#{method_name}\");
-          sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(self))));
+          sprintf(method_name+strlen(method_name), \"%lu\", (unsigned long)NUM2PTR(rb_obj_id(CLASS_OF(self))));
           
                       int i;
                       for (i=0; i<argc_; i++) {
-                        sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(argv[i]))));
+                        sprintf(method_name+strlen(method_name), \"%lu\", (unsigned long)NUM2PTR(rb_obj_id(CLASS_OF(argv[i]))));
                       }
 
           void** address = 0;
@@ -136,9 +169,9 @@ private
           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, LONG2FIX(id));
+            VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
             if (tmp != Qnil) {
-                address = (void**)FIX2LONG(tmp);
+                address = (void**)NUM2PTR(tmp);
                 fptr = *address;
             }
           }
@@ -159,9 +192,9 @@ private
             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, LONG2FIX(id));
+              VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
               if (tmp != Qnil) {
-                  address = (void**)FIX2LONG(tmp);
+                  address = (void**)NUM2PTR(tmp);
                   fptr = *address;
               }
             }
@@ -190,16 +223,18 @@ private
               frame.thread_data = rb_current_thread_data();
               frame.targetted = 0;
 
-              VALUE block = Qfalse;
+              volatile VALUE block = Qfalse;
 
               if (rb_block_given_p()) {
                 struct {
-                  void *block_function_address;
-                  void *block_function_param;
+                  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;
               }

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

@@ -86,7 +86,7 @@ module FastRuby
         end
 
         frame_call(
-          frame(to_c(tree[1])+";","
+          "ret = " + frame(to_c(tree[1])+";","
             #{rescue_code}
           ", else_tree ? to_c(else_tree) : nil, 1)