fastruby 0.0.17 → 0.0.18

data/lib/fastruby/translator/translator.rb

@@ -26,6 +26,7 @@ require "fastruby/set_tree"
 require "fastruby/exceptions"
 require "fastruby/translator/translator_modules"
 require "fastruby/translator/scope_mode_helper"
+require "define_method_handler"
 
 module FastRuby
   class Context
@@ -39,12 +40,66 @@ module FastRuby
     attr_reader :init_extra
     attr_reader :extra_code
     
-    TranslatorModules.instance.load_under(FastRuby.fastruby_load_path + "/fastruby/translator/modules/")
-    TranslatorModules.instance.modls.each do |modl|
-      include modl
+    class Value
+      attr_accessor :value
+      def initialize(v); @value = v; end
+    end
+    
+    def self.define_translator_for(ntype, options = {}, &blk)
+      condition_blk = proc do |*x|
+        tree = x.first; tree.node_type == ntype
+      end
+      
+      if options[:arity]
+        if options[:arity] == 1
+          condition_blk = proc do |*x|
+            tree = x.first; x.size == 1 and tree.node_type == ntype
+          end
+        end
+      end
+      
+      define_method_handler(:to_c, options, &blk).condition &condition_blk
+    end
+
+    define_method_handler(:to_c, :priority => 10000){|*x|
+        "Qnil"
+      }.condition{|*x| x.size == 1 and (not x.first)}
+
+    define_method_handler(:to_c, :priority => 1000){|tree, result_var|
+        "#{result_var} = #{to_c(tree)};"
+      }.condition{|*x| x.size == 2 and (not x.first)}
+
+    define_method_handler(:to_c, :priority => -9000){ |tree, result_var|
+      "#{result_var} = #{to_c(tree)};"
+    }.condition{|*x| x.size == 2 }
+    
+    define_method_handler(:to_c, :priority => -10000) do |tree, result_var=nil|
+      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|
+      tree[2] = :fastruby_require
+      to_c(tree)
+    }.condition{|*x|
+      tree = x.first; tree.node_type == :call && tree[2] == :require
+    }
+    
+    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
 
     def initialize(common_func = true)
+      initialize_to_c
+      
       @infer_lvar_map = Hash.new
       @no_cache = false
       @extra_code = ""
@@ -183,22 +238,32 @@ module FastRuby
       end
     end
 
-    def to_c(tree, result_variable = nil)
-      return "Qnil" unless tree
-      
-      mname = "to_c_" + tree[0].to_s
-      
-      if result_variable
-        if method(mname).arity == 1
-          "#{result_variable} = #{send(mname, tree)};\n"
-        else
-          send(mname, tree, result_variable)
-        end 
+
+    def _raise(class_tree, message_tree = nil)
+      class_tree = to_c class_tree unless class_tree.instance_of? String
+
+      if message_tree.instance_of? String
+        message_tree = "rb_str_new2(#{message_tree.inspect})"
       else
-        send(mname, tree)
+        message_tree = to_c message_tree
+      end
+
+      if message_tree
+        return inline_block("
+            pframe->thread_data->exception = rb_funcall(#{class_tree}, #{intern_num :exception},1,#{message_tree});
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+            return Qnil;
+            ")
+      else
+        return inline_block("
+            pframe->thread_data->exception = rb_funcall(#{class_tree}, #{intern_num :exception},0);
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+            return Qnil;
+            ")
       end
-    end
 
+    end
+    
     def anonymous_function(*x)
 
       name = "anonymous" + rand(10000000).to_s
@@ -280,7 +345,7 @@ module FastRuby
 
         extra_code << "
           static VALUE #{@alt_method_name}(VALUE self__);
-          static VALUE main_proc_call(VALUE self__, VALUE class_self_) {
+          static VALUE main_proc_call(VALUE self__, VALUE signature, VALUE class_self_) {
             #{@alt_method_name}(class_self_);
             return Qnil;
           }
@@ -290,23 +355,22 @@ module FastRuby
         init_extra << "
             {
             VALUE newproc = rb_funcall(rb_cObject,#{intern_num :new},0);
-            rb_define_singleton_method(newproc, \"call\", main_proc_call, 1);
+            rb_define_singleton_method(newproc, \"call\", main_proc_call, 2);
             rb_gv_set(\"$last_obj_proc\", newproc);
-
             }
           "
       end
     end
 
-    def define_method_at_init(klass,method_name, size, signature)
-      init_extra << "
-        {
+    def define_method_at_init(method_name, size, signature)
+      extra_code << "
+        static VALUE main_proc_call(VALUE self__, VALUE signature, VALUE class_self_) {
           VALUE method_name = rb_funcall(
                 #{literal_value FastRuby},
                 #{intern_num :make_str_signature},
                 2,
                 #{literal_value method_name},
-                #{literal_value signature}
+                signature
                 );
 
           ID id = rb_intern(RSTRING_PTR(method_name));
@@ -315,12 +379,12 @@ module FastRuby
                 #{literal_value FastRuby},
                 #{intern_num :set_builder_module},
                 1,
-                #{literal_value klass}
+                class_self_
                 );
           
           VALUE rb_method_hash;
           void** address = 0;
-          rb_method_hash = rb_funcall(#{literal_value klass}, #{intern_num :method_hash},1,#{literal_value method_name});
+          rb_method_hash = rb_funcall(class_self_, #{intern_num :method_hash},1,#{literal_value method_name});
 
           if (rb_method_hash != Qnil) {
             VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
@@ -335,15 +399,25 @@ module FastRuby
           *address = #{alt_method_name};
           
           rb_funcall(
-              #{literal_value klass},
+              class_self_,
               #{intern_num :register_method_value}, 
               3,
               #{literal_value method_name},
               PTR2NUM(id),
               PTR2NUM(address)
               );
+              
+              return Qnil;
         }
       "
+      
+      init_extra << "
+            {
+            VALUE newproc = rb_funcall(rb_cObject,#{intern_num :new},0);
+            rb_define_singleton_method(newproc, \"call\", main_proc_call, 2);
+            rb_gv_set(\"$last_obj_proc\", newproc);
+            }
+          "
     end
 
     def to_c_method(tree, signature = nil)
@@ -359,7 +433,7 @@ module FastRuby
         block_argument = tree[3].find{|x| x.to_s[0] == ?&}
         impl_tree = tree[4][1]
       end
-
+      
       args_tree = original_args_tree.select{|x| x.to_s[0] != ?&}
 
         initialize_method_structs(original_args_tree)
@@ -1073,22 +1147,31 @@ fastruby_local_next:
       end
       
       pureruby_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
+        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv){
           #{@frame_struct}* pframe = frame;
-          VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
-  
+          VALUE method_arguments[3];
+          
+          method_arguments[0] = (VALUE)argc;
+          method_arguments[1] = (VALUE)argv;
+          method_arguments[2] = (VALUE)self;
+          
           return #{
-            protected_block "last_expression = rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
+            protected_block "last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", false, "method_arguments"
             };
         }
       "
       }
       
       generic_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
+        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv){
         
           #{@frame_struct}* pframe = frame;
-          VALUE method_arguments[#{args_tree.size+1}] = {#{toprocstrargs},(VALUE)block};
+          VALUE method_arguments[4];
+          
+          method_arguments[0] = (VALUE)argc;
+          method_arguments[1] = (VALUE)argv;
+          method_arguments[2] = (VALUE)self;
+          method_arguments[3] = (VALUE)block;
           
           void* fptr = 0;
           
@@ -1106,40 +1189,30 @@ fastruby_local_next:
           
           fptr = *#{address_name};
           
-          #{
-            if args_tree.size < 25
-            "
             if (fptr == 0) {
               fptr = *#{cfunc_address_name};
               if (fptr != 0) {
-                VALUE params[2] = {self,PTR2NUM(#{args_tree.size-1})};
-                return ( (VALUE(*)(#{value_cast})) (fptr) )((VALUE)params,(VALUE)block,(VALUE)frame#{inprocstrargs});  
+                return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*) ) (fptr) )(self,(VALUE)block,(VALUE)frame, argc, argv);  
               }
             }
-            "
-            end
-          } 
-          
+
           if (fptr == 0) {
             if (block==0) {
               return #{
-                protected_block "last_expression = rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
+                protected_block "last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", false, "method_arguments"
                 };
 
             } else {
               return #{
                   protected_block "
                         #{@block_struct} *pblock;
-                        pblock = (typeof(pblock))( ((VALUE*)method_arguments)[#{args_tree.size}] );
+                        pblock = (typeof(pblock))( ((VALUE*)method_arguments)[3] );
                         last_expression = rb_iterate(
                         #{anonymous_function{|name|
                           "
                             static VALUE #{name} (VALUE data) {
                               VALUE* method_arguments = (VALUE*)data;
-                              return rb_funcall(
-                                ((VALUE*)method_arguments)[0], 
-                                #{intern_num mname.to_sym}, 
-                                #{args_tree.size-1}#{inprocstrargs});
+                              return rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);
                             }
                           "
                         }},
@@ -1180,19 +1253,20 @@ fastruby_local_next:
             }
 
           } else {
-            return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*)) (fptr) )(self,(VALUE)block,(VALUE)frame,#{args_tree.size-1},method_arguments+1);  
+            return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*)) (fptr) )(self,(VALUE)block,(VALUE)frame,argc,argv);  
           }
         }
         "
       }
 
 
+      cfuncall1inprocargs = (0..args_tree.size-2).map{|x| "argv[#{x}]"}.join(",")
+      cfuncall1inprocargs = ","+cfuncall1inprocargs if cfuncall1inprocargs != ""
+      
       cfunc_value_cast = (["VALUE"]*args_tree.size).join(",")
       cfunc_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE* params, void* block,void* frame#{strargs_signature}){
-            VALUE self = params[0];
-            VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
-            return ( (VALUE(*)(#{cfunc_value_cast})) (#{cfunc_real_address_name}) )(self#{inprocstrargs});
+        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
+            return ( (VALUE(*)(#{cfunc_value_cast})) (#{cfunc_real_address_name}) )(self#{cfuncall1inprocargs});
         }
         "
       }
@@ -1201,18 +1275,15 @@ fastruby_local_next:
       strargs_signature = (0..25).map{|x| "VALUE arg#{x}"}.join(",")
 
       cfunc_wrapper_1 = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE* params, void* block,void* frame, #{strargs_signature}){
-            VALUE self = params[0];
-            VALUE method_arguments[26] = {#{toprocstrargs}};
-            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(NUM2ULONG(params[1]),method_arguments,self);
+        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
+            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(argc,argv,self);
         }
         "
       }
 
       cfunc_wrapper_2 = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE* params, void* block,void* frame, #{strargs_signature}){
-            VALUE self = params[0];
-            VALUE args = rb_ary_new3(NUM2ULONG(params[1]),#{toprocstrargs});
+        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
+            VALUE args = rb_ary_new3(argc, argv);
             return ( (VALUE(*)(VALUE,VALUE)) (#{cfunc_real_address_name}) )(self,args);
         }
         "

data/lib/fastruby/translator/translator_modules.rb

@@ -34,11 +34,15 @@ module FastRuby
       @modls << modl  
     end
     
-    def load_under(dir)
+    def each_under(dir)
       Dir.glob(dir + "/*.rb") do |x|
-        require x
+        yield x
       end
     end
+
+    def load_under(dir)
+      each_under(dir, &method(:require))
+    end
   end
 end
 

data/lib/fastruby.rb

@@ -32,5 +32,5 @@ class Object
 end
 
 module FastRuby
-  VERSION = "0.0.17" unless defined? FastRuby::VERSION
+  VERSION = "0.0.18" unless defined? FastRuby::VERSION
 end

data/spec/reductor/base_spec.rb

@@ -0,0 +1,46 @@
+require "fastruby"
+require "fastruby/reductor/reductor"
+require "fastruby/sexp_extension"
+require "ruby_parser"
+
+describe FastRuby, "fastruby" do
+  
+  def self.test_normal_tree(code)
+    unmodified_tree = FastRuby::FastRubySexp.from_sexp RubyParser.new.parse code
+    it "tree for source #{code} should not be changed by reductor" do
+      obtained_tree = FastRuby::Reductor.new.reduce unmodified_tree
+      obtained_tree.should be == unmodified_tree
+    end
+  end
+   
+  it "should reduce for statements into each calls" do
+   reductor = FastRuby::Reductor.new
+   
+   original_tree = fs(:for, fs(:call, nil, :b, fs(:arglist)), fs(:lasgn, :a), fs(:call, nil, :c, fs(:arglist)))
+   expected_tree = fs(:iter, fs(:call, fs(:call, nil, :b, fs(:arglist)), :each, fs(:arglist)), fs(:lasgn, :a), fs(:call, nil, :c, fs(:arglist)))
+   obtained_tree = reductor.reduce original_tree
+   
+   obtained_tree.should be == expected_tree
+  end
+ 
+  test_normal_tree "a.foo(b)"
+  test_normal_tree "if (x); y; else; z; end"
+  
+  it "should reduce call statements into if arrays" do
+   reductor = FastRuby::Reductor.new
+   
+   original_tree = fs(:case, 
+      fs(:call, nil, :a, fs(:arglist)), 
+      fs(:when, fs(:array, fs(:call, nil, :b, fs(:arglist))), fs(:call, nil, :c, fs(:arglist))), 
+      nil)
+
+   obtained_tree = reductor.reduce original_tree
+   
+   obtained_tree.node_type.should be == :block
+   obtained_tree[1].node_type.should be == :lasgn
+   obtained_tree[1].last.should be == s(:call, nil, :a, s(:arglist)).to_fastruby_sexp
+   obtained_tree[2].node_type.should be == :if
+   obtained_tree[2][1].node_type.should be == :or
+   obtained_tree[2][2].should be == original_tree.find_tree(:when).last
+  end
+end