fastruby 0.0.5 → 0.0.6

data/lib/fastruby/object.rb

@@ -18,14 +18,10 @@ 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/translator"
 require "fastruby/builder"
 require "fastruby/getlocals"
 require "fastruby/method_extension"
-require "fastruby/translator"
-require "ruby_parser"
-require "inline"
-
+require "fastruby/cache/cache"
 
 # clean rubyinline cache
 system("rm -fr #{ENV["HOME"]}/.ruby_inline/*")
@@ -47,313 +43,106 @@ module FastRuby
                     s(:scope, s(:block, generated_tree)))
       end
 
-      generated_tree
+      generated_tree.to_fastruby_sexp
   end
 end
 
 class Object
-
   def fastruby(argument, *options_hashes)
-    tree = nil
-
-    if argument.instance_of? Sexp
-      tree = argument
-    elsif argument.instance_of? String
-      tree = RubyParser.new.parse(argument)
-    else
-      raise ArgumentError
+    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
 
-    return unless tree
+    objs = Array.new
 
-    if tree[0] == :class
-      classname = Object.to_class_name tree[1]
+    unless options_hash[:no_cache]
+      snippet_hash = FastRuby.cache.hash_snippet(argument,options_hash[:validate_lvar_types].to_s)
+      objs = FastRuby.cache.retrieve(snippet_hash)
+    end
 
-      if tree[2]
-        superclassname = Object.to_class_name tree[2]
+    if objs.empty?
 
-        eval("
-        class #{classname} < #{superclassname}
-        end
-        ", $top_level_binding)
+      tree = nil
 
+      require "fastruby/fastruby_sexp"
+      if argument.instance_of? FastRuby::FastRubySexp
+        tree = argument
+      elsif argument.instance_of? String
+        require "rubygems"
+        require "ruby_parser"
+        require "fastruby/sexp_extension"
+        tree = RubyParser.new.parse(argument).to_fastruby_sexp
       else
-        eval("
-        class #{classname}
-        end
-        ", $top_level_binding)
-      end
-
-      klass = eval(classname)
-
-      method_name = "_anonymous_" + rand(100000000000).to_s
-      $generated_tree = FastRuby.encapsulate_tree(tree[3],method_name)
-      $options_hashes = options_hashes
-
-      klass.class_eval do
-        class << self
-           fastruby $generated_tree, *$options_hashes
-        end
+        raise ArgumentError
       end
 
-      klass.send(method_name)
-    elsif tree[0] == :module
-      modulename = Object.to_class_name tree[1]
-
-      eval("
-      module #{modulename}
-      end
-      ", $top_level_binding)
-
-      klass = eval(modulename)
-
-      method_name = "_anonymous_" + rand(100000000000).to_s
-      $generated_tree = FastRuby.encapsulate_tree(tree[2],method_name)
-      $options_hashes = options_hashes
+      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, *[options_hash])
 
-      klass.class_eval do
-        class << self
-           fastruby $generated_tree, *$options_hashes
-        end
-      end
-
-      klass.send(method_name)
-    elsif tree[0] == :defn
-      Object.fastruby_defn(tree, *options_hashes)
     else
-      method_name = "_anonymous_" + rand(100000000000).to_s
-      Object.fastruby(FastRuby.encapsulate_tree(tree,method_name), *options_hashes)
-      send(method_name)
-    end
-  end
-
-  def self.fastruby_defs(*args)
-    raise NoMethodError, "not implemented yet"
-  end
-
-  def self.fastruby(argument,*options_hashes)
 
-    tree = nil
+      objs.sort{|x,y|
+          (y =~ /Inline_Object/ ? 1 : 0) - (x =~ /Inline_Object/ ? 1 : 0)
+        }.each do |obj|
 
-    if argument.instance_of? Sexp
-      tree = argument
-    elsif argument.instance_of? String
-      tree = RubyParser.new.parse(argument)
-    else
-      raise ArgumentError
-    end
-
-    return unless tree
-
-    if tree.node_type == :defn
-      fastruby_defn(tree,*options_hashes)
-    else
-       method_name = "_anonymous_" + rand(100000000000).to_s
-      $generated_tree = FastRuby.encapsulate_tree(tree,method_name)
-      $options_hashes = options_hashes
-
-      klass = self
-      klass.class_eval do
-        class << self
-          fastruby_defn($generated_tree,*$options_hashes)
+        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)
+        rescue
         end
       end
-
-      send(method_name)
     end
-
   end
 
-  def self.fastruby_defn(tree, *options_hashes)
-
+  def self.execute_tree(argument,*options_hashes)
     options_hash = {:validate_lvar_types => true}
     options_hashes.each do |opt|
       options_hash.merge!(opt)
     end
 
-    if tree[0] == :block
-      (1..tree.size-1).each do |i|
-        fastruby(tree[i], *options_hashes)
-      end
-
-      return
-    elsif tree[0] != :defn
-      raise ArgumentError, "Only definition of methods are accepted"
+    require "fastruby/fastruby_sexp"
+    if argument.instance_of? FastRuby::FastRubySexp
+      tree = argument
+    elsif argument.instance_of? String
+      require "rubygems"
+      require "ruby_parser"
+      require "fastruby/sexp_extension"
+      tree = RubyParser.new.parse(argument).to_fastruby_sexp
+    else
+      require "pry"
+      binding.pry
+      raise ArgumentError
     end
 
     method_name = tree[1]
-    args_tree = tree[2]
-
-    hashname = "$hash" + rand(1000000).to_s
 
-    hash = Hash.new
+    self_ = options_hash[:self]
+    self_ = self unless self_.instance_of? Class
 
-    locals = Set.new
-    locals << :self
+    FastRuby.set_tree(self_, method_name, tree, options_hash[:snippet_hash], options_hash)
 
-    FastRuby::GetLocalsProcessor.get_locals(tree).each do |local|
-      locals << local
+    class << self
+      $metaclass = self
     end
 
-    self_ = self
-    hash.instance_eval{@klass = self_}
-    hash.instance_eval{@method_name = method_name}
-
-    class_eval do
-      class << self
-        include FastRuby::BuilderModule
-      end
-    end
-
-    fastrubym = self_.fastruby_method(method_name)
-    fastrubym.tree = tree
-    fastrubym.locals = locals
-    fastrubym.options = options_hash
-
-    def hash.build(key)
-      @klass.build(key, @method_name)
-    end
-
-    eval("#{hashname} = hash")
-
-    value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
-
-    main_signature_argument = args_tree[1..-1].first || "self"
-
-    strmethodargs = ""
-    strmethodargs_class = (["self"] + args_tree[1..-1]).map{|arg| "CLASS_OF(#{arg.to_s})"}.join(",")
-
-    if args_tree.size > 1
-      strmethodargs = "self,block,(VALUE)&frame,#{args_tree[1..-1].map(&:to_s).join(",") }"
-    else
-      strmethodargs = "self,block,(VALUE)&frame"
-    end
-
-    strmethod_signature = (["self"] + args_tree[1..-1]).map { |arg|
-      "sprintf(method_name+strlen(method_name), \"%lu\", CLASS_OF(#{arg}));\n"
-    }.join
-
-    c_code = "VALUE #{method_name}(#{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",")}) {
-      VALUE method_hash = (VALUE)#{hash.internal_value};
-      VALUE klass = (VALUE)#{self.internal_value};
-
-      char method_name[0x100];
-
-      method_name[0] = '_';
-      method_name[1] = 0;
-
-      sprintf(method_name+1, \"#{method_name}\");
-      #{strmethod_signature}
-
-      NODE* body;
-      ID id;
-
-      id = rb_intern(method_name);
-      body = rb_method_node(klass,id);
-
-      if (body == 0) {
-        VALUE argv_class[] = {#{strmethodargs_class} };
-        VALUE signature = rb_ary_new4(#{args_tree.size},argv_class);
-
-        rb_funcall(method_hash, #{:build.to_i}, 1, signature);
-        body = rb_method_node(klass,id);
-      }
-
-        if (nd_type(body) == NODE_CFUNC) {
-          struct {
-            void* parent_frame;
-            void* target_frame;
-            void* plocals;
-            jmp_buf jmp;
-            VALUE return_value;
-            VALUE exception;
-            int rescue;
-          } frame;
-
-          frame.target_frame = 0;
-          frame.parent_frame = 0;
-          frame.rescue = 0;
-          frame.exception = Qnil;
-          frame.return_value = Qnil;
-
-          int argc = body->nd_argc;
-
-          VALUE block = Qfalse;
-
-          if (rb_block_given_p()) {
-            struct {
-              void *block_function_address;
-              void *block_function_param;
-            } block_struct;
-
-            block_struct.block_function_address = re_yield;
-            block_struct.block_function_param = 0;
-
-            block = (VALUE)&block_struct;
-          }
-
-          int aux = setjmp(frame.jmp);
-          if (aux != 0) {
-            if (frame.target_frame == (void*)-1) {
-              rb_funcall(self, #{:raise.to_i}, 1, frame.exception);
-            }
-
-            if (frame.target_frame != &frame) {
-                VALUE ex = rb_funcall(
-                        (VALUE)#{FastRuby::Context::UnwindFastrubyFrame.internal_value},
-                        #{:new.to_i},
-                        3,
-                        frame.exception,
-                        LONG2FIX(frame.target_frame),
-                        frame.return_value
-                        );
-
-                rb_funcall(self, #{:raise.to_i}, 1, ex);
-            }
-
-            return Qnil;
-          }
-
-          if (argc == #{args_tree.size+1}) {
-            return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
-          } else if (argc == -1) {
-            VALUE argv[] = {#{(["block,(VALUE)&frame"]+args_tree[1..-1]).map(&:to_s).join(",")} };
-            return ((VALUE(*)(int,VALUE*,VALUE))body->nd_cfnc)(#{args_tree.size},argv,self);
-          } else if (argc == -2) {
-            VALUE argv[] = {#{(["block,(VALUE)&frame"]+args_tree[1..-1]).map(&:to_s).join(",")} };
-            return ((VALUE(*)(VALUE,VALUE))body->nd_cfnc)(self, rb_ary_new4(#{args_tree.size},argv));
-          } else {
-            rb_raise(rb_eArgError, \"wrong number of arguments (#{args_tree.size-1} for %d)\", argc);
-          }
-        }
-
-      return Qnil;
-    }"
-
-    inline :C  do |builder|
-      builder.include "<node.h>"
-      builder.inc << "static VALUE re_yield(int argc, VALUE* argv, VALUE param, VALUE _parent_frame) {
-        return rb_yield_splat(rb_ary_new4(argc,argv));
-      }"
-      builder.c c_code
-    end
+    self_.build([$class_self],method_name,true)
   end
 
-  def internal_value
+  def gc_register_object
     $refered_from_code_array = Array.new unless $refered_from_code_array
     $refered_from_code_array << self
-
-    internal_value_
-  end
-
-  inline :C do |builder|
-    builder.c "VALUE internal_value_() {
-      return INT2FIX(self);
-    }"
   end
 
   private
       def self.to_class_name(argument)
+        require "sexp"
         if argument.instance_of? Symbol
           argument.to_s
         elsif argument.instance_of? Sexp

data/lib/fastruby/set_tree.rb

@@ -0,0 +1,61 @@
+=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/builder"
+require "fastruby/getlocals"
+require "fastruby/method_extension"
+
+module FastRuby
+
+  def self.make_str_signature(method_name, signature)
+    "_" + method_name.to_s + signature.map(&:__id__).map(&:to_s).join
+  end
+
+  def self.set_builder_module(klass)
+    klass.class_eval do
+      class << self
+        include FastRuby::BuilderModule
+      end
+    end
+  end
+
+  def self.set_tree(klass, method_name, tree, snippet_hash, options = {})
+    locals = Set.new
+    locals << :self
+
+    FastRuby::GetLocalsProcessor.get_locals(tree).each do |local|
+      locals << local
+    end
+
+    klass.class_eval do
+      class << self
+        include FastRuby::BuilderModule
+      end
+    end
+
+    fastrubym = klass.fastruby_method(method_name)
+    fastrubym.tree = tree
+    fastrubym.locals = locals
+    fastrubym.options = options
+    fastrubym.snippet_hash = snippet_hash
+
+    nil
+  end
+end

data/lib/fastruby/sexp_extension.rb

@@ -0,0 +1,37 @@
+=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/fastruby_sexp"
+
+class Object
+  def to_fastruby_sexp
+    self
+  end
+end
+
+class Sexp
+  def to_fastruby_sexp
+    ary = FastRuby::FastRubySexp.new
+    each do |x|
+      ary << x.to_fastruby_sexp
+    end
+    ary
+  end
+end