fastruby 0.0.16 → 0.0.17

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

@@ -27,8 +27,27 @@ module FastRuby
       "rb_cvar_get(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]})"
     end
 
-    def to_c_cvasgn(tree)
+    def to_c_cvasgn(tree, result_var = nil)
+      if result_var
+        "
+          {
+            VALUE recv = CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self;
+
+            #{to_c tree[2], result_var};
+            
+            #{if RUBY_VERSION =~ /^1\.9/
+              "rb_cvar_set(recv,#{intern_num tree[1]},#{result_var});"
+              elsif RUBY_VERSION =~ /^1\.8/
+              "rb_cvar_set(recv,#{intern_num tree[1]},#{result_var},Qfalse);"
+              else
+                raise RuntimeError, "unsupported ruby version #{RUBY_VERSION}"
+              end 
+            }
+          }
+       "
+      else
       "__rb_cvar_set(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]},#{to_c tree[2]},Qfalse)"
+      end
     end
 
     def to_c_gvar(tree)
@@ -39,48 +58,81 @@ module FastRuby
       end
     end
 
-    def to_c_gasgn(tree)
+    def to_c_gasgn(tree, result_var = nil)
+      if result_var
+          "
+          {
+          #{to_c tree[2], result_var}; 
+          rb_gvar_set((void*)#{global_entry(tree[1])},#{result_var});
+          }
+          "
+      else
       "_rb_gvar_set((void*)#{global_entry(tree[1])}, #{to_c tree[2]})"
+      end
     end
 
     def to_c_ivar(tree)
       "rb_ivar_get(#{locals_accessor}self,#{intern_num tree[1]})"
     end
 
-    def to_c_iasgn(tree)
-      "_rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{to_c tree[2]})"
+    def to_c_iasgn(tree, result_var = nil)
+      if result_var
+          "
+          {
+          #{to_c tree[2], result_var}; 
+          rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{result_var});
+          }
+          "
+      else
+        "_rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{to_c tree[2]})"
+      end
     end
 
     def to_c_const(tree)
       "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
     end
     
-    def to_c_cdecl(tree)
+    def to_c_cdecl(tree, result_var_ = nil)
+      
+      result_var = result_var_ || "value"
+      
       if tree[1].instance_of? Symbol
-        inline_block "
-          // set constant #{tree[1].to_s}
-          VALUE val = #{to_c tree[2]};
-          rb_const_set(rb_cObject, #{intern_num tree[1]}, val);
-          return val;
+        code = "
+          {
+            // set constant #{tree[1].to_s}
+            #{to_c tree[2], result_var};
+            rb_const_set(rb_cObject, #{intern_num tree[1]}, #{result_var});
+          }
           "
       elsif tree[1].instance_of? FastRuby::FastRubySexp
 
         if tree[1].node_type == :colon2
-          inline_block "
-            // set constant #{tree[1].to_s}
-            VALUE val = #{to_c tree[2]};
-            VALUE klass = #{to_c tree[1][1]};
-            rb_const_set(klass, #{intern_num tree[1][2]}, val);
-            return val;
+          code = "
+            {
+              // set constant #{tree[1].to_s}
+              #{to_c tree[2], result_var};
+              VALUE klass = Qnil;
+              #{to_c tree[1][1], "klass"};
+              rb_const_set(klass, #{intern_num tree[1][2]}, #{result_var});
+            }
             "
         elsif tree[1].node_type == :colon3
-          inline_block "
+          code = "
+            {
             // set constant #{tree[1].to_s}
-            VALUE val = #{to_c tree[2]};
-            rb_const_set(rb_cObject, #{intern_num tree[1][1]}, val);
-            return val;
+            #{to_c tree[2], result_var};
+            rb_const_set(rb_cObject, #{intern_num tree[1][1]}, #{result_var});
+            }
             "
         end
+        
+        if result_var_
+          code
+        else
+           inline_block "VALUE #{result_var} = Qnil;\n" + code + "
+            return #{result_var};
+           "
+        end
       end
     end
 
@@ -88,15 +140,29 @@ module FastRuby
       "rb_const_get_from(rb_cObject, #{intern_num tree[1]})"
     end
     
-    def to_c_colon2(tree)
-      inline_block "
-        VALUE klass = #{to_c tree[1]};
+    def to_c_colon2(tree, result_var = nil)
+      code = "
+        {
+        VALUE klass = Qnil;
+        
+        #{to_c tree[1],"klass"};
+            #{
+            if result_var
+              "#{result_var} = Qnil;"
+            end
+          }
 
       if (rb_is_const_id(#{intern_num tree[2]})) {
         switch (TYPE(klass)) {
           case T_CLASS:
           case T_MODULE:
-            return rb_const_get_from(klass, #{intern_num tree[2]});
+            #{
+            if result_var
+              "#{result_var} = rb_const_get_from(klass, #{intern_num tree[2]});"
+            else
+              "return rb_const_get_from(klass, #{intern_num tree[2]});"
+            end
+            }
             break;
           default:
             #{_raise("rb_eTypeError","not a class/module")};
@@ -104,35 +170,78 @@ module FastRuby
         }
       }
       else {
-        return rb_funcall(klass, #{intern_num tree[2]}, 0, 0);
+            #{
+            if result_var
+              "#{result_var} = rb_funcall(klass, #{intern_num tree[2]}, 0, 0);"
+            else
+              "return rb_funcall(klass, #{intern_num tree[2]}, 0, 0);"
+            end
+            }
       }
-
-        return Qnil;
+        
+            #{
+            unless result_var
+              "return Qnil;"
+            end
+            }
+        }
       "
+      
+      if result_var
+        code
+      else
+        inline_block code
+      end
     end
 
-    def to_c_lasgn(tree)
-      if options[:validate_lvar_types]
-        klass = @infer_lvar_map[tree[1]]
-        if klass
+    def to_c_lasgn(tree, result_var = nil)
+      code = "
+          {
+            #{to_c tree[2], result_var};
+            #{locals_accessor}#{tree[1]} = #{result_var};
+           }
+           "
 
-          verify_type_function = proc { |name| "
-            static VALUE #{name}(VALUE arg, void* pframe ) {
-              if (CLASS_OF(arg)!=#{literal_value klass}) {
+      if result_var
+        if options[:validate_lvar_types]
+          klass = @infer_lvar_map[tree[1]]
+          if klass
+            "
+            {
+              #{to_c tree[2], result_var};
+              if (CLASS_OF(#{result_var})!=#{literal_value klass}) {
                 #{_raise(literal_value(FastRuby::TypeMismatchAssignmentException), "Illegal assignment at runtime (type mismatch)")};
               }
-              return arg;
+              #{locals_accessor}#{tree[1]} = #{result_var};
             }
-          "
-          }
-
-
-          "_lvar_assing(&#{locals_accessor}#{tree[1]}, #{anonymous_function(&verify_type_function)}(#{to_c tree[2]},pframe))"
+           "
+          else
+            code
+          end
         else
-          "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+          code
         end
       else
-        "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+        if options[:validate_lvar_types]
+          klass = @infer_lvar_map[tree[1]]
+          if klass
+            verify_type_function = proc { |name| "
+              static VALUE #{name}(VALUE arg, void* pframe ) {
+                if (CLASS_OF(arg)!=#{literal_value klass}) {
+                  #{_raise(literal_value(FastRuby::TypeMismatchAssignmentException), "Illegal assignment at runtime (type mismatch)")};
+                }
+                return arg;
+              }
+            "
+            }
+            
+            "_lvar_assing(&#{locals_accessor}#{tree[1]}, #{anonymous_function(&verify_type_function)}(#{to_c tree[2]},pframe))"
+          else
+            "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+          end
+        else
+          "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+        end
       end
     end
 

data/lib/fastruby/translator/scope_mode_helper.rb

@@ -0,0 +1,161 @@
+=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 when_array_to_if(array)
+      if array.size == 1
+        array[0] || s(:nil)
+      else
+        first_when_tree = array[0]
+        comparers = first_when_tree[1][1..-1]
+
+        condition_tree = s(:or)
+        comparers.each do |st|
+          condition_tree << s(:call, st, :===, s(:arglist, s(:lvar, :temporal_case_var))) 
+        end
+
+        s(:if, condition_tree, first_when_tree[2], when_array_to_if(array[1..-1]) )
+      end
+    end
+    
+    def get_scope_mode(tree_)
+      tree = FastRuby::FastRubySexp.from_sexp(tree_).transform do |subtree|
+        if subtree.node_type == :for
+          s(:iter,s(:call, subtree[1],:each, s(:arglist)),subtree[2], subtree[3] )
+        elsif subtree.node_type == :case
+          ifs = when_array_to_if(subtree[2..-1])
+
+          s(:block, s(:lasgn, :temporal_case_var, subtree[1]), ifs)
+        else
+          nil
+        end
+      end
+
+      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
+
+      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|
+            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