fastruby 0.0.19 → 0.0.20

data/lib/fastruby/translator/scope_mode_helper.rb~

@@ -0,0 +1,138 @@
+=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
+require "fastruby/sexp_extension"
+
+module FastRuby
+  class ScopeModeHelper
+    def self.get_scope_mode(tree_)
+      new.get_scope_mode(tree_)
+    end
+
+    def get_scope_mode(tree_)
+      tree = FastRuby::FastRubySexp.from_sexp(tree_)
+
+      if tree.node_type == :defn
+        args_tree = tree[2]
+        impl_tree = tree[3]
+      elsif tree.node_type == :defs
+        args_tree = tree[3]
+        impl_tree = tree[4]
+      end
+
+
+      p $search_array.call(impl_tree)      
+      graph = impl_tree.to_graph
+
+      args_tree[1..-1].each do |subtree|
+        return :dag if subtree.to_s =~ /^\&/
+      end
+
+      tree.walk_tree do |subtree|
+        if subtree.node_type == :iter
+          iter_impl = subtree[3]
+          
+          return :dag if has_local_variable_access?(subtree[3])
+          return :dag if subtree[2]
+
+          if iter_impl
+            return_node = iter_impl.find_tree{|st2| st2.node_type == :return}
+
+            if return_node
+              return :dag
+            end
+          end
+        elsif subtree.node_type == :block_pass
+          return :dag
+        end
+      end
+
+      impl_tree.walk_tree do |subtree|
+        graph.each_path_from(subtree) do |path|
+          # verify path prohibitive for :linear scope (local variable read after call)
+          has_call = false
+          writes = Set.new
+
+          path.each do |st2|
+            next unless st2 
+            if st2.node_type == :call
+              if has_call and st2[1] == nil
+                return :dag
+              end
+
+              writes.clear
+              has_call = true
+            elsif st2.node_type == :iter
+              if has_call and st2[1][1] == nil
+                return :dag
+              end
+
+              writes.clear
+              has_call = true
+            elsif st2.node_type == :lasgn
+              writes << st2[1] # record local writes
+            elsif st2.node_type == :lvar or st2.node_type == :self or 
+                  st2.node_type == :return or st2.node_type == :yield
+
+              if has_call
+                if st2.node_type == :lvar
+                  if writes.include? st2[1]
+                    # no problem
+                  else
+                    # read after call, the scope of this function must be implemented on heap
+                    return :dag
+                  end
+                else
+                  return :dag
+                end              
+              end
+            end
+          end
+        end
+      end
+
+      :linear
+    end
+    
+private
+    def has_local_variable_access?(*trees) 
+      trees.each do |tree|
+        return false unless tree.kind_of? FastRuby::FastRubySexp
+
+        tree.walk_tree do |subtree|
+          if subtree.node_type == :lvar or 
+            subtree.node_type == :self or 
+            subtree.node_type == :yield or
+            subtree.node_type == :return or 
+            subtree.node_type == :lasgn
+            return true
+          end
+          
+          if subtree.node_type == :call
+            if subtree[1] == nil
+              return true
+            end
+          end
+        end
+      end
+      false
+    end 
+  end
+end

data/lib/fastruby/translator/translator.rb

@@ -26,16 +26,14 @@ require "fastruby/set_tree"
 require "fastruby/exceptions"
 require "fastruby/translator/translator_modules"
 require "fastruby/translator/scope_mode_helper"
+require "fastruby/modules"
 require "define_method_handler"
+require "base64"
 
 module FastRuby
   class Context
-    attr_accessor :infer_lvar_map
-    attr_accessor :alt_method_name
     attr_accessor :locals
     attr_accessor :options
-    attr_accessor :infer_self
-    attr_accessor :snippet_hash
     attr_reader :no_cache
     attr_reader :init_extra
     attr_reader :extra_code
@@ -73,13 +71,17 @@ module FastRuby
       "#{result_var} = #{to_c(tree)};"
     }.condition{|*x| x.size == 2 }
     
-    define_method_handler(:to_c, :priority => -10000) do |tree, result_var=nil|
+    define_method_handler(:to_c, :priority => -10000) do |*x|
+      tree, result_var = x
+
       raise "undefined translator for node type :#{tree.node_type}"
     end
     
     define_method_handler(:initialize_to_c){|*x|}.condition{|*x|false}
 
-    define_translator_for(:call, :priority => 100){ |tree, result_var=nil|
+    define_translator_for(:call, :priority => 100){ |*x|
+      tree, result_var = x
+
       tree[2] = :fastruby_require
       to_c(tree)
     }.condition{|*x|
@@ -89,13 +91,8 @@ module FastRuby
     define_method_handler(:infer_value, :priority => -1000) do |tree|
       nil
     end
-
-    TranslatorModules.instance.each_under(FastRuby.fastruby_load_path + "/fastruby/translator/modules/") do |path|
-      groupname = path.split("/").last.split(".").first.to_sym
-      handler_scope(:group => groupname) do
-        require path
-      end
-    end
+    
+    FastRuby::Modules.load_all("translator")
     
     def catch_block(*catchs)
         old_catch_blocks = @catch_blocks.dup
@@ -107,11 +104,11 @@ module FastRuby
       end
     end
 
-    def initialize(common_func = true)
+    def initialize(common_func = true, inferencer = nil)
       initialize_to_c
       
+      @inferencer = inferencer
       @catch_blocks = []
-      @infer_lvar_map = Hash.new
       @no_cache = false
       @extra_code = ""
       @options = {}
@@ -409,7 +406,7 @@ module FastRuby
           if (address == 0) {
             address = malloc(sizeof(void*));
           }
-          *address = #{alt_method_name};
+          *address = #{@alt_method_name};
           
           rb_funcall(
               class_self_,
@@ -447,6 +444,12 @@ module FastRuby
         impl_tree = tree[4][1]
       end
       
+      if "0".respond_to?(:ord)
+        @alt_method_name = "_" + method_name.to_s.gsub("_x_", "_x__x_").gsub(/\W/){|x| "_x_#{x.ord}" } + "_" + rand(10000000000).to_s
+      else
+        @alt_method_name = "_" + method_name.to_s.gsub("_x_", "_x__x_").gsub(/\W/){|x| "_x_#{x[0]}" } + "_" + rand(10000000000).to_s
+      end
+
       args_tree = original_args_tree.select{|x| x.to_s[0] != ?&}
 
         initialize_method_structs(original_args_tree)
@@ -592,9 +595,28 @@ module FastRuby
 
         end
 
-        require "fastruby/sexp_extension"       
-        scope_mode = FastRuby::ScopeModeHelper.get_scope_mode(tree)
+        require "fastruby/sexp_extension"
+        
+        trs = lambda{|tree| 
+            if not tree.respond_to? :node_type 
+              next tree
+            elsif tree.node_type == :call
+              mmname = tree[2]
+              next trs.call(tree[1]) || tree[1] if mmname == :infer
+              next fs(:nil) if mmname == :_throw or mmname == :_loop or mmname == :_raise
+              next fs(:nil) if mmname == :== and infer_value(tree)
+            elsif tree.node_type == :iter
+              mmname = tree[1][2]
+              next fs(:nil) if mmname == :_static
+              next fs(:block, trs.call(tree[3]) || tree[3]) if mmname == :_catch
+            end
 
+            tree.map &trs
+          }
+          
+        evaluate_tree = tree.transform &trs
+        
+        scope_mode = FastRuby::ScopeModeHelper.get_scope_mode(evaluate_tree)
         ret = "VALUE #{@alt_method_name || method_name}(#{options[:main] ? "VALUE self" : strargs}) {
           #{validate_arguments_code}
 
@@ -746,7 +768,7 @@ end
         extra_code << ret
       
       "
-        static VALUE dummy_#{method_name}_#{alt_method_name}_#{rand(1000000000000000000000000000000000)}(VALUE a) {
+        static VALUE dummy_#{@alt_method_name}_#{rand(1000000000000000000000000000000000)}(VALUE a) {
           return Qnil;
         }
       "
@@ -783,16 +805,10 @@ end
     end
 
     def infer_type(recv)
-      if recv[0] == :call
-        if recv[2] == :infer
-          eval(recv[3].last.last.to_s)
-        end
-      elsif recv[0] == :lvar
-        @infer_lvar_map[recv[1]]
-      elsif recv[0] == :self
-        @infer_self
-      elsif recv[0] == :str or recv[0] == :lit
-        recv[1].class
+      array = @inferencer.infer(recv).to_a
+      
+      if array.size == 1
+        array[0]
       else
         nil
       end
@@ -813,12 +829,6 @@ end
 
       if mname == :infer
         return to_c(recv)
-      elsif mname == :lvar_type
-        lvar_name = args[1][1] || args[1][2]
-        lvar_type = eval(args[2][1].to_s)
-
-        @infer_lvar_map[lvar_name] = lvar_type
-        return "Qnil"
       elsif mname == :block_given?
         return "plocals->block_function_address == 0 ? Qfalse : Qtrue"
       elsif mname == :inline_c
@@ -1154,8 +1164,6 @@ fastruby_local_next:
           "
         else
           
-          require "base64"
-
           init_extra << "
           
             {
@@ -1181,13 +1189,18 @@ fastruby_local_next:
       name
     end
 
-    def encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name = nil)
+    def encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name = nil, is_block_call = false)
       name = self.add_global_name("void*", 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);
+      
+      if call_tree[3].select{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
+        is_block_call = true
+      end
+      
       args_tree = call_tree[3].reject{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
       method_tree = nil
 
@@ -1280,9 +1293,9 @@ fastruby_local_next:
                         #{@block_struct} *pblock;
                         pblock = (typeof(pblock))( ((VALUE*)method_arguments)[3] );
                         last_expression = rb_iterate(
-                        #{anonymous_function{|name|
+                        #{anonymous_function{|name_|
                           "
-                            static VALUE #{name} (VALUE data) {
+                            static VALUE #{name_} (VALUE data) {
                               VALUE* method_arguments = (VALUE*)data;
                               return rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);
                             }
@@ -1290,9 +1303,9 @@ fastruby_local_next:
                         }},
                           (VALUE)method_arguments,
                           
-                        #{anonymous_function{|name|
+                        #{anonymous_function{|name_|
                           "
-                            static VALUE #{name} (VALUE arg_, VALUE param, int argc, VALUE* argv) {
+                            static VALUE #{name_} (VALUE arg_, VALUE param, int argc, VALUE* argv) {
 
            VALUE arg;
             #{
@@ -1338,7 +1351,7 @@ fastruby_local_next:
       cfunc_value_cast = (["VALUE"]*args_tree.size).join(",")
       cfunc_wrapper = anonymous_function{ |funcname| "
         static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
-            return ( (VALUE(*)(#{cfunc_value_cast})) (#{cfunc_real_address_name}) )(self#{cfuncall1inprocargs});
+          return rb_vm_call(ruby_current_thread, self, #{intern_num mname.to_sym}, argc, argv, #{cfunc_real_address_name});
         }
         "
       }
@@ -1370,55 +1383,33 @@ fastruby_local_next:
                 if (1) {
                   *default_address = 0;
     
-    #ifdef RUBY_1_8
-    
-          // this only works with ruby1.8
-    
-                  NODE* body = rb_method_node(recvtype,#{intern_num mname});
-                  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;
-                      }
-                    }
-                  }
-    #endif
-    #ifdef RUBY_1_9
+    #{
+    if RUBY_VERSION == "1.9.2"
+      
+    "
                   rb_method_entry_t* me = rb_method_entry(recvtype,#{intern_num mname});
                   if (me != 0) {
                     rb_method_definition_t* def = me->def;
                     
                     if (def->type == VM_METHOD_TYPE_CFUNC) {
-                      if (def->body.cfunc.argc == #{args_tree.size-1}) {
-                        *default_address = #{cfunc_wrapper};
-                        #{cfunc_real_address_name} = (void*)def->body.cfunc.func;
-                      } else if (def->body.cfunc.argc == -1) {
-                        *default_address = #{cfunc_wrapper_1};
-                        #{cfunc_real_address_name} = (void*)def->body.cfunc.func;
-                      } else if (def->body.cfunc.argc == -2) {
-                        *default_address = #{cfunc_wrapper_2};
-                        #{cfunc_real_address_name} = (void*)def->body.cfunc.func;
-                      }
+                      *default_address = #{cfunc_wrapper};
+                      #{cfunc_real_address_name} = (void*)me;
                     }
                   }
-    #endif
-    
-                  if (recvtype != Qnil) { 
-                    rb_funcall(
-                        recvtype,
-                        #{intern_num :register_method_value}, 
-                        3,
-                        #{literal_value mname},
-                        PTR2NUM(default_id),
-                        PTR2NUM(default_address)
-                        );
+    "
+    end
+    }
+                  if (default_address != 0) {
+                    if (recvtype != Qnil) { 
+                      rb_funcall(
+                          recvtype,
+                          #{intern_num :register_method_value}, 
+                          3,
+                          #{literal_value mname},
+                          PTR2NUM(default_id),
+                          PTR2NUM(default_address)
+                          );
+                    }
                   }
                 }
               return Qnil;
@@ -1473,14 +1464,18 @@ fastruby_local_next:
               *default_address = 0;
             }
             #{cfunc_address_name} = default_address;
-            
-            #{update_cfunc_method}();
-            rb_iterate(#{anonymous_function{|funcname|
-              "static VALUE #{funcname}(VALUE recv) {
-                return rb_funcall(recv, #{intern_num :observe}, 1, #{literal_value(alt_method_name + "#" + cfunc_address_name)});
-              }
+            #{unless is_block_call
               "
-            }},fastruby_method,#{update_cfunc_method},Qnil);
+              #{update_cfunc_method}();
+              rb_iterate(#{anonymous_function{|funcname|
+                "static VALUE #{funcname}(VALUE recv) {
+                  return rb_funcall(recv, #{intern_num :observe}, 1, #{literal_value(@alt_method_name + "#" + cfunc_address_name)});
+                }
+                "
+              }},fastruby_method,#{update_cfunc_method},Qnil);
+              "
+            end
+            }
 
             if (address==0) {
               address = malloc(sizeof(void*));