fastruby 0.0.17 → 0.0.18

data/lib/fastruby/cache/cache.rb

@@ -41,12 +41,16 @@ module FastRuby
     end
 
     def insert(hash,path)
-      create_hash_dir(hash)
-      dest = hash_dir(hash)
-      cp_r path, dest
+      unless ENV['FASTRUBY_NO_CACHE'] == '1'
+        create_hash_dir(hash)
+        dest = hash_dir(hash)
+        cp_r path, dest
+      end
     end
 
     def retrieve(hash)
+      return [] if ENV['FASTRUBY_NO_CACHE'] == '1'
+      
       create_hash_dir(hash)
       dest = hash_dir(hash)
       Dir[dest + "*.so"]
@@ -57,10 +61,10 @@ module FastRuby
       @proc_hash[obj] = value
     end
 
-    def execute(obj, param)
+    def execute(obj, *params)
       @proc_hash = Hash.new unless @proc_hash
       if @proc_hash[obj]
-        @proc_hash[obj].call(param)
+        @proc_hash[obj].call(*params)
       end
     end
 private

data/lib/fastruby/fastruby_sexp.rb

@@ -22,6 +22,24 @@ module FastRuby
   class FastRubySexp < Array
     alias node_type first
     
+    def duplicate
+      map { |subtree|
+        if subtree.respond_to?(:node_type)
+          subtree.duplicate
+        else
+          subtree
+        end
+      }
+    end
+    
+    def map
+      sexp = FastRubySexp.new
+      self.each do |subtree|
+        sexp << yield(subtree)
+      end
+      sexp
+    end
+    
     def walk_tree(&block)
       each do |subtree|
         if subtree.instance_of? FastRubySexp

data/lib/fastruby/inliner/inliner.rb

@@ -0,0 +1,68 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+
+module FastRuby
+  class Inliner
+    attr_accessor :infer_lvar_map
+    attr_accessor :infer_self
+    attr_reader :extra_locals
+    attr_reader :extra_inferences
+    attr_reader :inlined_methods
+    
+    def initialize
+      @extra_locals = Set.new
+      @extra_inferences = Hash.new
+      @inlined_methods = Array.new
+    end
+    
+    define_method_handler(:inline, :priority => -1000) do |tree|
+      FastRubySexp.from_sexp(tree)
+    end
+    
+    Dir.glob(FastRuby.fastruby_load_path + "/fastruby/inliner/modules/**/*.rb").each do |path|
+      require path
+    end
+    
+    def add_local(local)
+      @extra_locals << local
+    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
+      else
+        nil
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,150 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+ 
+module FastRuby
+  class Inliner
+    def inline_local_name(method_name, local_name)
+      "__inlined_#{method_name}_#{local_name}".to_sym
+    end
+    
+    define_method_handler(:inline) { |tree|
+        ret_tree = fs(:iter)
+        ret_tree << tree[1].duplicate
+        
+        tree[2..-1].each do |subtree|
+          ret_tree << inline(subtree)
+        end
+        
+        ret_tree
+        
+      }.condition{|tree| tree.node_type == :iter}
+    
+    define_method_handler(:inline) { |tree|
+      
+      next tree if tree.find_tree(:block_pass)
+      
+      recv_tree = tree[1] || fs(:self)
+      method_name = tree[2]
+      args_tree = tree[3]
+      
+      if method_name == :lvar_type
+        lvar_name = args_tree[1][1] || args_tree[1][2]
+        lvar_type = eval(args_tree[2][1].to_s)
+
+        @infer_lvar_map[lvar_name] = lvar_type
+        next tree
+      end
+      
+      recvtype = infer_type(recv_tree)
+ 
+      if recvtype
+        # search the tree of target method
+        next tree unless recvtype.respond_to?(:fastruby_method)
+
+        mobject = recvtype.fastruby_method(method_name)
+        
+        next tree unless mobject
+        
+        target_method_tree = mobject.tree
+
+        next tree unless target_method_tree
+        next tree if target_method_tree.find_tree(:iter)
+        target_method_tree_args = target_method_tree[2]
+        
+        next tree if target_method_tree_args.find{|subtree| subtree.to_s =~ /^\*/}
+
+
+        target_method_tree_block = target_method_tree.find_tree(:scope)[1].duplicate
+        
+        target_method_tree_block.walk_tree do |subtree|
+          if subtree.node_type == :lvar or subtree.node_type == :lasgn
+            subtree[1] = inline_local_name(method_name, subtree[1])
+            add_local subtree[1]
+          end
+        end
+        
+        newblock = fs(:block)
+        
+        (1..args_tree.size-1).each do |i|
+          itype = infer_type(args_tree[i])
+          inlined_name = inline_local_name(method_name, target_method_tree_args[i])
+
+          add_local inlined_name
+
+          self.extra_inferences[inlined_name] = itype if itype
+          newblock << fs(:lasgn, inlined_name, args_tree[i].duplicate)
+        end
+        
+        inlined_name = inline_local_name(method_name, :self)
+        add_local inlined_name
+        newblock << fs(:lasgn, inlined_name, recv_tree.duplicate)
+        
+        target_method_tree_block.walk_tree do |subtree|
+          if subtree.node_type == :call
+            if subtree[1] == nil
+              if subtree[2] == :block_given?
+                subtree[0..-1] = fs(:false)
+              else
+                subtree[1] = recv_tree.duplicate
+              end
+            end
+          end
+          if subtree.node_type == :self
+            subtree[0] = :lvar
+            subtree[1] = inline_local_name(method_name, :self)
+          end
+        end
+        
+        (1..target_method_tree_block.size-1).each do |i|
+          subtree = target_method_tree_block[i]
+          
+          if subtree.find_tree(:return)
+            if i == target_method_tree_block.size-1
+              if subtree.node_type == :return
+                if subtree[1]
+                  if subtree[1].find_tree(:return)
+                    next tree
+                  end
+                end
+                
+                subtree[0..-1] = subtree[1]
+              end
+            else
+              # methods with return cannot be inlined
+              next tree
+            end
+          end
+          
+          newblock << subtree
+        end
+        
+        @inlined_methods << mobject
+        newblock
+      else
+        # nothing to do, we don't know what is the method
+        tree
+      end
+    }.condition{|tree| tree.node_type == :call}
+  end
+end

data/lib/fastruby/inliner/modules/recursive.rb

@@ -0,0 +1,35 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+
+module FastRuby
+  class Inliner
+    define_method_handler(:inline, :priority => -100) {|tree|
+        tree.map &method(:inline)
+      }.condition{|tree| tree.respond_to?(:node_type)}
+
+    define_method_handler(:inline, :priority => 1000) {|tree|
+        tree
+      }.condition{|tree| not tree.respond_to?(:node_type)}
+  end
+end

data/lib/fastruby/object.rb

@@ -23,12 +23,22 @@ require "fastruby/getlocals"
 require "fastruby/method_extension"
 require "fastruby/cache/cache"
 require "fastruby"
+require "digest"
+require "method_source"
 
 # clean rubyinline cache
 system("rm -fr #{ENV["HOME"]}/.ruby_inline/*")
 
 $top_level_binding = binding
 
+def lvar_type(*x); end
+
+class Class
+  def optimize(method_name)
+    fastruby instance_method(method_name).source  
+  end
+end
+
 module FastRuby
   def self.encapsulate_tree(tree, method_name)
       generated_tree = tree
@@ -49,22 +59,14 @@ module FastRuby
 end
 
 class Object
+  
+  def infer(a); self; end
   def fastruby(argument, *options_hashes)
     options_hash = {:validate_lvar_types => true}
-    options_hash[:no_cache] = true if ENV['FASTRUBY_NO_CACHE'] == "1"
     options_hashes.each do |opt|
       options_hash.merge!(opt)
     end
-
-    objs = Array.new
-
-    unless options_hash[:no_cache]
-      snippet_hash = FastRuby.cache.hash_snippet(argument,options_hash[:validate_lvar_types].to_s + "^" + FastRuby::VERSION)
-      objs = FastRuby.cache.retrieve(snippet_hash)
-    end
-
-    if objs.empty?
-
+    
       tree = nil
 
       require "fastruby/fastruby_sexp"
@@ -80,27 +82,10 @@ class Object
       end
 
       return unless tree
-        method_name = "_anonymous_" + rand(100000000000).to_s
-        Object.execute_tree(FastRuby.encapsulate_tree(tree,method_name), {:main => method_name, :self => self, :snippet_hash => snippet_hash}.merge(options_hash))
-
-    else
-
-      objs.sort{|x,y|
-          File.new(x).ctime <=> File.new(y).ctime
-        }.each do |obj|
-
-        begin
-          $last_obj_proc = nil
-          require obj
-          if $last_obj_proc
-            FastRuby.cache.register_proc(obj, $last_obj_proc)
-          end
-          FastRuby.cache.execute(obj, self.kind_of?(Class) ? self : Object)
-        rescue Exception => e
-          p e
-        end
-      end
-    end
+        method_name = "_anonymous_" + Digest::SHA1.hexdigest(tree.inspect)
+        Object.execute_tree(FastRuby.encapsulate_tree(tree,method_name), {:main => method_name, :self => self}.merge(options_hash))
+
+
   end
 
   def self.execute_tree(tree,*options_hashes)

data/lib/fastruby/reductor/modules/case.rb

@@ -0,0 +1,49 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+
+module FastRuby
+  class Reductor
+    def when_array_to_if(array, temporal_var_name)
+      if array.size == 1
+        array[0] || fs(:nil)
+      else
+        first_when_tree = array[0]
+        comparers = first_when_tree[1][1..-1]
+
+        condition_tree = fs(:or)
+        comparers.each do |st|
+          condition_tree << fs(:call, st, :===, fs(:arglist, fs(:lvar, temporal_var_name))) 
+        end
+
+        fs(:if, condition_tree, first_when_tree[2], when_array_to_if(array[1..-1], temporal_var_name) )
+      end
+    end
+        
+    reduce_for(:case) do |tree|
+      temporal_var_name = "temporal_case_var_#{rand(1000000000)}".to_sym
+      ifs = when_array_to_if(tree[2..-1], temporal_var_name)
+      fs(:block, fs(:lasgn, temporal_var_name, tree[1]), ifs)
+    end
+  end
+end

data/lib/{fastruby.rb~ → fastruby/reductor/modules/for.rb}

@@ -18,19 +18,17 @@ 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/exceptions"
-require "fastruby/object"
-require "fastruby/exceptions"
-require "fastruby/custom_require"
-require "fastruby/set_tree"
-require "base64"
-
-class Object
-  def self.decode64(value)
-    Base64.decode64(value)
-  end
-end
+require "set"
+require "sexp"
+require "define_method_handler"
 
 module FastRuby
-  VERSION = "0.0.16" unless defined? FastRuby::VERSION
+  class Reductor
+    reduce_for(:for) do |tree|
+      alter_tree = tree.dup
+      alter_tree[0] = :iter
+      alter_tree[1] = fs(:call, alter_tree[1], :each, fs(:arglist))
+      alter_tree
+    end
+  end
 end

data/lib/fastruby/reductor/modules/nontree.rb

@@ -0,0 +1,31 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+
+module FastRuby
+  class Reductor
+    define_method_handler(:reduce, :priority => -100) {|tree|
+        tree
+      }.condition{|tree| not tree.respond_to?(:node_type)}
+  end
+end

data/lib/fastruby/reductor/modules/recursive.rb

@@ -0,0 +1,31 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+
+module FastRuby
+  class Reductor
+    define_method_handler(:reduce, :priority => -100) {|tree|
+        tree.map &method(:reduce)
+      }.condition{|tree| tree.respond_to?(:node_type)}
+  end
+end

data/lib/fastruby/reductor/reductor.rb

@@ -0,0 +1,39 @@
+=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 "set"
+require "sexp"
+require "define_method_handler"
+
+module FastRuby
+  class Reductor
+    def self.reduce_for(ntype, options = {}, &blk)
+      define_method_handler(:reduce, options, &blk).condition{|tree| tree.respond_to?(:node_type) && tree.node_type == ntype}
+    end
+    
+    define_method_handler(:reduce, :priority => -1000) do |tree|
+      FastRubySexp.from_sexp(tree)
+    end
+    
+    Dir.glob(FastRuby.fastruby_load_path + "/fastruby/reductor/modules/**/*.rb").each do |path|
+      require path
+    end
+  end
+end

data/lib/fastruby/set_tree.rb

@@ -21,6 +21,7 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 require "fastruby/builder"
 require "fastruby/getlocals"
 require "fastruby/method_extension"
+require "fastruby/reductor/reductor"
 
 module FastRuby
 
@@ -39,13 +40,16 @@ module FastRuby
   def self.unset_tree(klass, method_name)
     fastrubym = klass.fastruby_method(method_name)
     fastrubym.tree = nil
+    fastrubym.tree_changed
     nil
   end
 
   def self.set_tree(klass, method_name, tree, snippet_hash, options = {})
     locals = Set.new
     locals << :self
-
+    
+    tree = Reductor.new.reduce tree
+    
     FastRuby::GetLocalsProcessor.get_locals(tree).each do |local|
       locals << local
     end
@@ -57,10 +61,12 @@ module FastRuby
     end
 
     fastrubym = klass.fastruby_method(method_name)
+    
     fastrubym.tree = tree
     fastrubym.locals = locals
     fastrubym.options = options
     fastrubym.snippet_hash = snippet_hash
+    fastrubym.tree_changed
 
     nil
   end

data/lib/fastruby/sexp_extension.rb

@@ -29,6 +29,12 @@ class Object
   end
 end
 
+def fs(*args)
+  sexp = FastRuby::FastRubySexp.new
+  args.each &sexp.method(:<<)
+  sexp
+end
+
 module FastRuby
   class Graph
     attr_reader :edges

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

@@ -19,10 +19,9 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
 module FastRuby
-  module BlockTranslator
-    
-    register_translator_module self
-    
+  class Context
+
+    define_translator_for(:yield, :method => :to_c_yield, :arity => 1)
     def to_c_yield(tree)
 
       block_code = proc { |name| "
@@ -94,6 +93,7 @@ module FastRuby
       protected_block(ret, false)
     end
 
+    define_translator_for(:block, :method => :to_c_block)
     def to_c_block(tree, result_variable = nil)
       if tree.size == 1
         return inline_block("return Qnil;")