fastruby 0.0.19 → 0.0.20

data/lib/fastruby/{translator/modules/static.rb → modules/translator/static.rb~}

@@ -23,8 +23,8 @@ module FastRuby
     define_translator_for(:iter, :arity => 1, :priority => 1) { |*x|
       ret = nil
       tree = x.first
-      
       enable_handler_group(:static_call) do
+              require "pry"; binding.pry
         ret = x.size == 1 ? to_c(tree[3]) : to_c(tree[3], x.last)
       end
       ret
@@ -47,20 +47,47 @@ module FastRuby
     }
     
     handler_scope(:group => :static_call, :priority => 1000) do
-      define_translator_for(:call) do |tree, result=nil|
+      define_translator_for(:call) do |*x|
+      tree, result = x
+
         method_name = tree[2].to_s
         recv_tree = tree[1]
         
-        if recv_tree
+        if method_name == "c_address_of"
+          arg = tree[3][1]
+          return "&"+to_c(arg)
+        end
+        
+        if method_name == "inline_c"
+          arg = tree[3][1]
+          
+          if arg.node_type != :str
+            raise RuntimeError, "invalid node for inline_c directive #{arg}"
+          end
+
+          next arg[1]
+        end
+
+        if recv_tree and recv_tree.node_type != :self
           if (not tree[2].to_s =~ /^[a-zA-Z]/) and tree[2].to_s.size <= 3
             c_op = tree[2].to_s
             c_op = '==' if tree[2] == :===
             code = "( ( #{to_c(tree[1])} )#{c_op}(#{to_c(tree[3][1])}) )"
+          elsif tree[2] == :_invariant
+            name = self.add_global_name("VALUE", "Qnil");
+            
+            init_extra << "
+                #{name} = #{to_c tree[1]};
+                rb_funcall(#{name},#{intern_num :gc_register_object},0);
+              "
+              
+            code = name;
           else
-            raise "invalid static call #{method_name}"
+            args = tree[3][1..-1].map{|st| to_c(st)}.join(",")
+            code = "#{method_name}( #{args} )"
           end
         else
-          args = tree[3][1..-1].map(&method(:to_c)).join(",")
+          args = tree[3][1..-1].map{|st| to_c(st)}.join(",")
           code = "#{method_name}( #{args} )"
         end
 
@@ -71,7 +98,9 @@ module FastRuby
         end
       end
       
-      define_translator_for(:lit) do |tree, result=nil|
+      define_translator_for(:lit) do |*x|
+      tree, result = x
+
         if result
           "#{result} = #{tree[1]};"
         else
@@ -79,7 +108,9 @@ module FastRuby
         end
       end
       
-      define_translator_for(:if) do |tree, result_variable_ = nil|
+      define_translator_for(:if) do |*x|
+      tree, result_variable_  = x
+
         condition_tree = tree[1]
         impl_tree = tree[2]
         else_tree = tree[3]
@@ -108,7 +139,19 @@ module FastRuby
         end      
       end
       
-      define_translator_for(:while) do |tree, result_var = nil|
+      define_translator_for(:const) do |*x|
+      tree, result_var  = x
+
+        if result_var
+          "#{result_var} = #{tree[1].to_s};"
+        else
+          "#{tree[1].to_s}"
+        end
+      end
+      
+      define_translator_for(:while) do |*x|
+      tree, result_var  = x
+
         begin_while = "begin_while_"+rand(10000000).to_s
         end_while = "end_while_"+rand(10000000).to_s
         aux_varname = "_aux_" + rand(10000000).to_s
@@ -142,7 +185,9 @@ module FastRuby
         
       end
            
-      define_translator_for(:and) do |tree, return_var = nil|
+      define_translator_for(:and) do |*x|
+      tree, return_var  = x
+
         if return_var
           "
             {
@@ -159,7 +204,9 @@ module FastRuby
         
       end
       
-      define_translator_for(:or) do |tree, return_var = nil|
+      define_translator_for(:or) do |*x|
+      tree, return_var  = x
+
         if return_var
           "
             {
@@ -176,7 +223,9 @@ module FastRuby
         
       end
       
-      define_translator_for(:not) do |tree, return_var = nil|
+      define_translator_for(:not) do |*x|
+      tree, return_var  = x
+
         if return_var
           "
             {
@@ -197,11 +246,11 @@ module FastRuby
     end
     
 
-    define_method_handler(:infer_value) { |tree|
+    define_method_handler(:infer_value) { |*x| tree = x.first; 
       Value.new(eval(tree[1].to_s))
-    }.condition{|tree| tree.node_type == :const}
+    }.condition{|*x| tree = x.first;  tree.node_type == :const}
     
-    define_method_handler(:infer_value) { |tree|
+    define_method_handler(:infer_value) { |*x| tree = x.first; 
       args_tree = tree[3]
       receiver_tree = tree[1]
       
@@ -211,7 +260,7 @@ module FastRuby
       next false unless (value_1 and value_2)
       
       Value.new(value_1.value == value_2.value)
-    }.condition{|tree|
+    }.condition{|*x| tree = x.first; 
       next false unless tree.node_type == :call
       
       args_tree = tree[3]
@@ -222,7 +271,7 @@ module FastRuby
 
       true
     }
-    define_method_handler(:infer_value) { |tree|
+    define_method_handler(:infer_value) { |*x| tree = x.first; 
       args_tree = tree[3]
       receiver_tree = tree[1]
       infered_type = infer_type(receiver_tree)
@@ -232,7 +281,7 @@ module FastRuby
       else
         nil
       end
-    }.condition{|tree|
+    }.condition{|*x| tree = x.first; 
       next false unless tree.node_type == :call
       method_name = tree[2]
       next false unless method_name == :_class

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

@@ -0,0 +1,280 @@
+=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
+module FastRuby
+  class Context
+    define_translator_for(:cvar, :method => :to_c_cvar, :arity => 1)
+    def to_c_cvar(tree)
+      "rb_cvar_get(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]})"
+    end
+
+    define_translator_for(:cvasgn, :method => :to_c_cvasgn)
+    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
+
+    define_translator_for(:gvar, :method => :to_c_gvar, :arity => 1)
+    def to_c_gvar(tree)
+      if (tree[1] == :$!)
+        "pframe->thread_data->exception"
+      else
+        "rb_gvar_get((struct global_entry*)#{global_entry(tree[1])})"
+      end
+    end
+
+    define_translator_for(:gasgn, :method => :to_c_gasgn)
+    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
+
+    define_translator_for(:ivar, :method => :to_c_ivar, :arity => 1)
+    def to_c_ivar(tree)
+      "rb_ivar_get(#{locals_accessor}self,#{intern_num tree[1]})"
+    end
+
+    define_translator_for(:iasgn, :method => :to_c_iasgn)
+    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
+
+    define_translator_for(:const, :arity => 1) do |*x| tree = x.first;
+      "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
+    end
+    
+    define_translator_for(:cdecl, :method => :to_c_cdecl)
+    def to_c_cdecl(tree, result_var_ = nil)
+      
+      result_var = result_var_ || "value"
+      
+      if tree[1].instance_of? Symbol
+        code = proc{"
+          {
+            // 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
+          code = proc{"
+            {
+              // 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
+          code = proc{"
+            {
+            // set constant #{tree[1].to_s}
+            #{to_c tree[2], result_var};
+            rb_const_set(rb_cObject, #{intern_num tree[1][1]}, #{result_var});
+            }
+            "}
+        end
+      end
+
+        if result_var_
+          code.call
+        else
+           inline_block{"VALUE #{result_var} = Qnil;\n" + code.call + "
+            return #{result_var};
+           "}
+        end
+    end
+
+    define_translator_for(:colon3, :method => :to_c_colon3, :arity => 1)
+    def to_c_colon3(tree)
+      "rb_const_get_from(rb_cObject, #{intern_num tree[1]})"
+    end
+   
+    define_translator_for(:colon2, :method => :to_c_colon2) 
+    def to_c_colon2(tree, result_var = nil)
+      code = proc{ "
+        {
+        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:
+            #{
+            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")};
+            break;
+        }
+      }
+      else {
+            #{
+            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
+            }
+      }
+        
+            #{
+            unless result_var
+              "return Qnil;"
+            end
+            }
+        }
+      "}
+      
+      if result_var
+        code.call
+      else
+        inline_block &code
+      end
+    end
+
+    define_translator_for(:lasgn, :method => :to_c_lasgn)
+    def to_c_lasgn(tree, result_var = nil)
+      code = "
+          {
+            #{to_c tree[2], result_var};
+            #{locals_accessor}#{tree[1]} = #{result_var};
+           }
+           "
+
+      if result_var
+        code
+      else
+        "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
+      end
+    end
+    
+    define_translator_for(:lvar, :arity => 1) do |*x| tree = x.first;
+      locals_accessor + tree[1].to_s
+    end
+
+    define_translator_for(:defined, :method => :to_c_defined, :arity => 1)
+    def to_c_defined(tree)
+      obj_tree = tree[1] 
+      
+      if obj_tree[0] == :call && obj_tree[2] == :infer
+        obj_tree = obj_tree[1]
+      end
+      
+      nt = obj_tree.node_type
+
+      if nt == :self
+      'rb_str_new2("self")'
+      elsif nt == :true
+      'rb_str_new2("true")'
+      elsif nt == :false
+      'rb_str_new2("false")'
+      elsif nt == :nil
+      'rb_str_new2("nil")'
+      elsif nt == :lvar
+      'rb_str_new2("local-variable")'
+      elsif nt == :gvar
+      "rb_gvar_defined((struct global_entry*)#{global_entry(obj_tree[1])}) ? #{literal_value "global-variable"} : Qnil"
+      elsif nt == :const
+      "rb_const_defined(rb_cObject, #{intern_num obj_tree[1]}) ? #{literal_value "constant"} : Qnil"
+      elsif nt == :call
+        if RUBY_VERSION =~ /^1\.8/
+        "rb_method_node(CLASS_OF(#{to_c obj_tree[1]}), #{intern_num obj_tree[2]}) ? #{literal_value "method"} : Qnil"
+        else
+        "rb_method_entry(CLASS_OF(#{to_c obj_tree[1]}), #{intern_num obj_tree[2]}) ? #{literal_value "method"} : Qnil"
+        end
+      elsif nt == :yield
+        "rb_block_given_p() ? #{literal_value "yield"} : Qnil"
+      elsif nt == :ivar
+      "rb_ivar_defined(plocals->self,#{intern_num obj_tree[1]}) ? #{literal_value "instance-variable"} : Qnil"
+      elsif nt == :attrset or
+            nt == :op_asgn1 or
+            nt == :op_asgn2 or
+            nt == :op_asgn_or or
+            nt == :op_asgn_and or
+            nt == :op_asgn_masgn or
+            nt == :masgn or
+            nt == :lasgn or
+            nt == :dasgn or
+            nt == :dasgn_curr or
+            nt == :gasgn or
+            nt == :iasgn or
+            nt == :cdecl or
+            nt == :cvdecl or
+            nt == :cvasgn
+        literal_value "assignment"
+      else
+        literal_value "expression"
+      end
+    end
+
+    
+  end
+end

data/lib/fastruby/{translator/modules/variable.rb → modules/translator/variable.rb~}

@@ -210,45 +210,9 @@ module FastRuby
            "
 
       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)")};
-              }
-              #{locals_accessor}#{tree[1]} = #{result_var};
-            }
-           "
-          else
-            code
-          end
-        else
-          code
-        end
+        code
       else
-        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
+        "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
       end
     end
     
@@ -258,7 +222,13 @@ module FastRuby
 
     define_translator_for(:defined, :method => :to_c_defined, :arity => 1)
     def to_c_defined(tree)
-      nt = tree[1].node_type
+      obj_tree = tree[1] 
+      
+      if obj_tree[0] == :call && obj_tree[2] == :infer
+        obj_tree = obj_tree[1]
+      end
+      
+      nt = obj_tree.node_type
 
       if nt == :self
       'rb_str_new2("self")'
@@ -271,19 +241,19 @@ module FastRuby
       elsif nt == :lvar
       'rb_str_new2("local-variable")'
       elsif nt == :gvar
-      "rb_gvar_defined((struct global_entry*)#{global_entry(tree[1][1])}) ? #{literal_value "global-variable"} : Qnil"
+      "rb_gvar_defined((struct global_entry*)#{global_entry(obj_tree[1])}) ? #{literal_value "global-variable"} : Qnil"
       elsif nt == :const
-      "rb_const_defined(rb_cObject, #{intern_num tree[1][1]}) ? #{literal_value "constant"} : Qnil"
+      "rb_const_defined(rb_cObject, #{intern_num obj_tree[1]}) ? #{literal_value "constant"} : Qnil"
       elsif nt == :call
         if RUBY_VERSION =~ /^1\.8/
-        "rb_method_node(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
+        "rb_method_node(CLASS_OF(#{to_c obj_tree[1]}), #{intern_num obj_tree[2]}) ? #{literal_value "method"} : Qnil"
         else
-        "rb_method_entry(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
+        "rb_method_entry(CLASS_OF(#{to_c obj_tree[1]}), #{intern_num obj_tree[2]}) ? #{literal_value "method"} : Qnil"
         end
       elsif nt == :yield
         "rb_block_given_p() ? #{literal_value "yield"} : Qnil"
       elsif nt == :ivar
-      "rb_ivar_defined(plocals->self,#{intern_num tree[1][1]}) ? #{literal_value "instance-variable"} : Qnil"
+      "rb_ivar_defined(plocals->self,#{intern_num obj_tree[1]}) ? #{literal_value "instance-variable"} : Qnil"
       elsif nt == :attrset or
             nt == :op_asgn1 or
             nt == :op_asgn2 or

data/lib/fastruby/modules.rb

@@ -0,0 +1,30 @@
+=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
+
+module FastRuby
+  module Modules
+    def self.load_all(name = "")
+      Dir.glob(FastRuby.fastruby_load_path + "/fastruby/modules/#{name}/**/*.rb").each do |path|
+        require path
+      end
+    end
+  end
+end

data/lib/fastruby/object.rb

@@ -22,6 +22,7 @@ require "fastruby/builder"
 require "fastruby/getlocals"
 require "fastruby/method_extension"
 require "fastruby/cache/cache"
+require "fastruby/sexp_extension"
 require "fastruby"
 require "digest"
 require "method_source"
@@ -58,10 +59,44 @@ module FastRuby
   end
 end
 
+class Object
+  def fastruby?
+    false
+  end
+end
+
 class Object
   
   def infer(a); self; end
-  def fastruby(argument, *options_hashes)
+  def fastruby(*arguments, &blk)
+    if blk
+      method_container = Class.new
+      class << method_container 
+        attr_accessor :_self
+        attr_accessor :fastruby_options
+      end
+      
+      method_container._self = self
+      method_container.fastruby_options = arguments.inject({},&:merge)
+      
+      def method_container.method_added(mname)
+        m = instance_method(mname)
+        if fastruby_options[:fastruby_only]
+          tree = FastRuby::FastRubySexp.parse m.source
+          FastRuby.set_tree(_self, tree[1], tree, fastruby_options)
+        else
+          @_self.fastruby m.source, fastruby_options
+        end
+      end
+            
+      method_container.class_eval(&blk)
+
+      return nil
+    end
+    
+    options_hashes = arguments[1..-1]
+    argument = arguments.first
+    
     options_hash = {:validate_lvar_types => true}
     options_hashes.each do |opt|
       options_hash.merge!(opt)
@@ -69,13 +104,14 @@ class Object
     
       tree = nil
 
-      require "fastruby/fastruby_sexp"
+      require "fastruby/fastruby_sexp" unless defined? FastRuby::FastRubySexp
       if argument.instance_of? FastRuby::FastRubySexp
         tree = argument
       elsif argument.instance_of? String
-        require "rubygems"
-        require "ruby_parser"
-        require "fastruby/sexp_extension"
+        unless defined? RubyParser
+          require "rubygems"
+          require "ruby_parser"
+        end
         tree = RubyParser.new.parse(argument).to_fastruby_sexp
       else
         raise ArgumentError
@@ -100,7 +136,7 @@ class Object
     self_ = options_hash[:self]
     self_ = self unless self_.instance_of? Class
 
-    FastRuby.set_tree(self_, method_name, tree, options_hash[:snippet_hash], options_hash)
+    FastRuby.set_tree(self_, method_name, tree, options_hash)
 
     class << self
       $metaclass = self