fastruby 0.0.19 → 0.0.20

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

@@ -71,8 +71,7 @@ module FastRuby
 
       str_lvar_initialization = "#{@frame_struct} *pframe;
                                  #{@locals_struct} *plocals;
-                                pframe = (void*)param;
-                                plocals = (void*)pframe->plocals;
+
                                 "
 
       str_arg_initialization = ""
@@ -150,8 +149,11 @@ module FastRuby
               static VALUE #{name}(VALUE param) {
                 // call to #{call_tree[2]}
                  VALUE last_expression = Qnil;
+                 VALUE* args_array = (VALUE*)param;
   
                 #{str_lvar_initialization}
+                pframe = (void*)args_array[0];
+                plocals = (void*)pframe->plocals;
                 #{str_evaluate_args};
                 
               VALUE ret = rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, #{call_args_tree.size-1} #{strargs});
@@ -193,40 +195,16 @@ module FastRuby
                 static VALUE #{name}(VALUE param) {
                   // call to #{call_tree[2]}
   
+                  VALUE* args_array = (VALUE*)param;
+                  int argc = args_array[1];
+                  VALUE* argv = args_array[2];
+
                   VALUE last_expression = Qnil;
                   #{str_lvar_initialization}
-                  
-                  VALUE array = Qnil;
-                  
-                  #{to_c call_args_tree.last[1], "array"};
-                  
-                  if (TYPE(array) != T_ARRAY) {
-                    array = rb_ary_new4(1,&array);
-                  }
-                  
-                  int argc = #{call_args_tree.size-2};
-                  VALUE argv[#{call_args_tree.size} + _RARRAY_LEN(array)];
-                  
-                  VALUE aux_ = Qnil;;
-                  #{
-                    i = -1
-                    call_args_tree[1..-2].map {|arg|
-                      i = i + 1
-                      "
-                      #{to_c arg, "aux_"};
-                      argv[#{i}] = aux_;
-                      "
-                    }.join(";\n")
-                  };
-                  
-                  int array_len = _RARRAY_LEN(array);
-                  
-                  int i;
-                  for (i=0; i<array_len;i++) {
-                    argv[argc] = rb_ary_entry(array,i);
-                    argc++; 
-                  }
-                  
+
+                  pframe = (void*)args_array[0];
+                  plocals = (void*)pframe->plocals;
+
                   return rb_funcall2(#{str_recv}, #{intern_num call_tree[2]}, argc, argv);
                 }
               "
@@ -235,15 +213,10 @@ module FastRuby
               str_evaluate_args = "
                   #{
                     (0..call_args_tree.size-2).map{|i|
-                      "VALUE arg#{i} = Qnil;"
-                    }.join("\n")
-                  }
-                  
-                  #{
-                    (0..call_args_tree.size-2).map{|i|
-                      to_c(call_args_tree[i+1], "arg#{i}")+";"
+                      "VALUE arg#{i} = args_array[#{i+1}];"
                     }.join("\n")
                   }
+
               "
             end
           end
@@ -313,7 +286,17 @@ if call_type == :lambda
 
                 } else if (aux == FASTRUBY_TAG_BREAK) {
                   last_expression = frame.return_value;
-                  goto fastruby_local_next;
+                  typeof(pframe) target_frame_ = (void*)plocals->call_frame;
+                  
+                  if (target_frame_ == 0) {
+                    goto fastruby_local_next;
+                  } else {
+                    if (target_frame_->targetted == 1) {
+                      goto fastruby_local_next;
+                    } else {
+                      #{_raise("rb_eLocalJumpError","illegal break")};
+                    }
+                  }
 "
 end
 }
@@ -586,12 +569,73 @@ fastruby_local_next:
               }
               
 
+#{if call_args_tree.size > 1 and call_args_tree.last[0] == :splat
+"              
+                  VALUE args_array[3];
+                  VALUE array = Qnil;
+                  
+                  #{to_c call_args_tree.last[1], "array"};
+                  
+                  if (TYPE(array) != T_ARRAY) {
+                    array = rb_ary_new4(1,&array);
+                  }
+                  
+                  int argc = #{call_args_tree.size-2};
+                  VALUE argv[#{call_args_tree.size} + _RARRAY_LEN(array)];
+                  
+                  VALUE aux_ = Qnil;;
+                  #{
+                    i = -1
+                    call_args_tree[1..-2].map {|arg|
+                      i = i + 1
+                      "
+                      #{to_c arg, "aux_"};
+                      argv[#{i}] = aux_;
+                      "
+                    }.join(";\n")
+                  };
+                  
+                  int array_len = _RARRAY_LEN(array);
+                  
+                  int i;
+                  for (i=0; i<array_len;i++) {
+                    argv[argc] = rb_ary_entry(array,i);
+                    argc++; 
+                  }
+
+                args_array[0] = (VALUE)pframe;
+                args_array[1] = (VALUE)argc;
+                args_array[2] = (VALUE)argv;
+
               last_expression = rb_iterate(
                 caller_func,
-                (VALUE)pframe,
+                (VALUE)args_array,
                 block_func,
                 (VALUE)plocals);
 
+"
+else
+"                 
+
+              VALUE args_array[#{call_args_tree.size+2}];
+              VALUE aux___ = Qnil;
+              args_array[0] = (VALUE)pframe;
+                  
+              #{
+                (0..call_args_tree.size-2).map{|i|
+                  to_c(call_args_tree[i+1], "aux___")+";"+
+                  "args_array[#{i+1}] = aux___;"
+                }.join("\n")
+              }              
+
+              last_expression = rb_iterate(
+                caller_func,
+                (VALUE)args_array,
+                block_func,
+                (VALUE)plocals);
+"
+end
+}
               if (node == #{@callcc_node_gvar}) {
   
                 // remove active flags of abandoned stack
@@ -625,7 +669,7 @@ fastruby_local_next:
           funcall_call_code
         end
       else
-        encoded_address = encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)
+        encoded_address = encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name, true)
 
         if call_args_tree.size > 1
           strargs = (0..call_args_tree.size-2).map{|i| "arg#{i}"}.join(",")
@@ -635,10 +679,21 @@ fastruby_local_next:
 
         fastruby_call_code = "
                 // call to #{call_tree[2]}
-                #{
-                if call_args_tree.size > 1
-                  str_evaluate_args
-                end
+              #{
+              if call_args_tree.size > 1
+"                   #{
+                   (0..call_args_tree.size-2).map{|i|
+                      "VALUE arg#{i} = Qnil;"
+                    }.join("\n")
+                  }
+                  
+                  #{
+                    (0..call_args_tree.size-2).map{|i|
+                      to_c(call_args_tree[i+1], "arg#{i}")+";"
+                     }.join("\n")
+                   }
+"
+               end
                 };
                 
                 VALUE recv = plocals->self;

data/lib/fastruby/modules/translator/literal.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
+module FastRuby
+  class Context
+    
+    define_translator_for(:lit, :arity => 1){|*x| tree = x.first; literal_value tree[1]}
+    define_translator_for(:nil, :arity => 1){|*x| tree = x.first; "Qnil"}
+    define_translator_for(:str, :arity => 1){|*x| tree = x.first; literal_value tree[1]}
+
+    define_translator_for(:hash, :method => :to_c_hash)
+    def to_c_hash(tree, result_var = nil)
+      
+      hash_tmp_var = "_hash_"+rand(1000000).to_s
+      key_tmp_var = "_key_"+rand(1000000).to_s
+      value_tmp_var = "_value_"+rand(1000000).to_s
+
+      code = proc{ 
+      hash_aset_code = ""
+      (0..(tree.size-3)/2).each do |i|
+        strkey = to_c tree[1 + i * 2]
+        strvalue = to_c tree[2 + i * 2]
+        hash_aset_code << "
+          {
+            VALUE #{key_tmp_var} = Qnil;
+            VALUE #{value_tmp_var} = Qnil;
+            
+            #{to_c tree[1 + i * 2], key_tmp_var};
+            #{to_c tree[2 + i * 2], value_tmp_var};
+            
+            rb_hash_aset(#{hash_tmp_var}, #{key_tmp_var}, #{value_tmp_var});
+          }
+        "
+      end
+      
+          "
+          {
+          VALUE #{hash_tmp_var} = rb_hash_new();
+          #{hash_aset_code};
+          #{
+          if result_var
+            "#{result_var} = #{hash_tmp_var}"
+          else
+            "return #{hash_tmp_var}"
+          end
+          };
+          }
+        "}
+        
+      if result_var
+        code.call
+      else
+        inline_block &code
+      end
+    end
+
+    define_translator_for(:array, :method => :to_c_array)
+    def to_c_array(tree, result_var = nil)
+      if tree.size > 1
+        if result_var
+          prefix = "_array_element_" + rand(10000000).to_s + "_"
+          "
+          {
+            #{ 
+              (0..tree.size-2).map{|x|
+                "VALUE #{prefix}#{x};"
+              }.join("\n");
+            }
+            
+            #{
+              (0..tree.size-2).map{|x|
+                to_c(tree[x+1], prefix+x.to_s)
+              }.join("\n");
+            }
+            
+            #{result_var} = rb_ary_new3(#{tree.size-1}, #{(0..tree.size-2).map{|x| prefix+x.to_s}.join(",")} );
+          }
+          "
+        else
+          strargs = tree[1..-1].map{|subtree| to_c subtree}.join(",")
+          "rb_ary_new3(#{tree.size-1}, #{strargs})"
+        end
+      else
+        if result_var
+        "#{result_var} = rb_ary_new3(0);"
+        else
+        "rb_ary_new3(0)"
+        end
+      end
+    end
+
+    define_translator_for(:self, :arity => 1){|*x| tree = x.first; locals_accessor + "self"}
+    define_translator_for(:false, :arity => 1){|*x| "Qfalse"}
+    define_translator_for(:true, :arity => 1){|*x| "Qtrue"}
+
+    define_translator_for(:dot2, :method => :to_c_dot2)
+    def to_c_dot2(tree, result_var = nil)
+      
+      begin_var = "_begin"+rand(10000000).to_s
+      end_var = "_end"+rand(10000000).to_s
+      
+      if result_var
+        "
+        {
+          VALUE #{begin_var} = Qnil;
+          VALUE #{end_var} = Qnil;
+          
+          #{to_c tree[1], begin_var};
+          #{to_c tree[2], end_var};
+          
+          #{result_var} = rb_range_new(#{begin_var}, #{end_var},0);
+        }
+        "
+      else
+        if result_var
+        "
+          {
+          VALUE #{begin_var} = Qnil;
+          VALUE #{end_var} = Qnil;
+          #{to_c tree[1], begin_var};
+          #{to_c tree[2], end_var};
+          
+          #{result_var} = rb_range_new(#{begin_var}, #{end_var},0)
+          }
+        "
+        else
+        "rb_range_new(#{to_c tree[1]}, #{to_c tree[2]},0)"
+        end
+      end
+    end
+    
+  end
+end

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

@@ -21,9 +21,9 @@ along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
 module FastRuby
   class Context
     
-    define_translator_for(:lit, :arity => 1){|tree| literal_value tree[1]}
-    define_translator_for(:nil, :arity => 1){|tree| "Qnil"}
-    define_translator_for(:str, :arity => 1){|tree| literal_value tree[1]}
+    define_translator_for(:lit, :arity => 1){|*x| tree = x.first; literal_value tree[1]}
+    define_translator_for(:nil, :arity => 1){|*x| tree = x.first; "Qnil"}
+    define_translator_for(:str, :arity => 1){|*x| tree = x.first; literal_value tree[1]}
 
     define_translator_for(:hash, :method => :to_c_hash)
     def to_c_hash(tree, result_var = nil)

data/lib/fastruby/{translator/modules → modules/translator}/nonlocal.rb

@@ -142,7 +142,9 @@ module FastRuby
       end
     end
     
-    define_method_handler(:to_c, :priority => 100) { |tree, result_var = nil|
+    define_method_handler(:to_c, :priority => 100) { |*x|
+      tree, result_var  = x
+
 
       call_tree = tree[1]
       catch_tag_id = call_tree[3][1][1]
@@ -240,11 +242,15 @@ module FastRuby
           "
       end
 
-    }.condition{|tree, result_var = nil| 
+    }.condition{|*x|
+      tree, result_var  = x
+ 
       tree.node_type == :iter && tree[1][2] == :_catch
     }
 
-    define_method_handler(:to_c, :priority => 100) { |tree, result_var = nil|
+    define_method_handler(:to_c, :priority => 100) { |*x|
+      tree, result_var  = x
+
       code = ""
       
       catch_tag_id = tree[3][1][1]
@@ -262,11 +268,15 @@ module FastRuby
       else
         inline_block code
       end
-    }.condition{|tree, result_var = nil| 
+    }.condition{|*x|
+      tree, result_var  = x
+ 
       tree.node_type == :call && tree[2] == :_throw
     }
     
-    define_method_handler(:to_c, :priority => 100) { |tree, result_var = nil|
+    define_method_handler(:to_c, :priority => 100) { |*x|
+      tree, result_var  = x
+
       code = ""
       
       catch_tag_id = tree[3][1][1]
@@ -277,7 +287,9 @@ module FastRuby
       else
         inline_block code
       end
-    }.condition{|tree, result_var = nil| 
+    }.condition{|*x|
+      tree, result_var  = x
+ 
       tree.node_type == :call && tree[2] == :_loop
     }