fastruby 0.0.16 → 0.0.17

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

@@ -34,35 +34,81 @@ module FastRuby
       literal_value tree[1]
     end
 
-    def to_c_hash(tree)
+    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
 
       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 << "rb_hash_aset(hash, #{strkey}, #{strvalue});"
+        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
+      
+        code = "
+          {
+          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
+      else
+        inline_block code
       end
-
-      anonymous_function{ |name| "
-        static VALUE #{name}(VALUE value_params) {
-          #{@frame_struct} *pframe;
-          #{@locals_struct} *plocals;
-          pframe = (void*)value_params;
-          plocals = (void*)pframe->plocals;
-
-          VALUE hash = rb_hash_new();
-          #{hash_aset_code}
-          return hash;
-        }
-      " } + "((VALUE)pframe)"
     end
 
-    def to_c_array(tree)
+    def to_c_array(tree, result_var = nil)
       if tree.size > 1
-        strargs = tree[1..-1].map{|subtree| to_c subtree}.join(",")
-        "rb_ary_new3(#{tree.size-1}, #{strargs})"
+        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
 
@@ -78,8 +124,39 @@ module FastRuby
       "Qtrue"
     end
 
-    def to_c_dot2(tree)
-      "rb_range_new(#{to_c tree[1]}, #{to_c tree[2]},0)"
+    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

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

@@ -22,16 +22,51 @@ module FastRuby
   module LogicalOperatorTranslator
     register_translator_module self
 
-    def to_c_and(tree)
-      "(RTEST(#{to_c tree[1]}) && RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
+    def to_c_and(tree, return_var = nil)
+      if return_var
+        "
+          {
+            VALUE op1 = Qnil;
+            VALUE op2 = Qnil;
+            #{to_c tree[1], "op1"};
+            #{to_c tree[2], "op2"};
+            #{return_var} = (RTEST(op1) && RTEST(op2)) ? Qtrue : Qfalse;
+          }
+        "
+      else
+        "(RTEST(#{to_c tree[1]}) && RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
+      end
+      
     end
 
-    def to_c_or(tree)
+    def to_c_or(tree, return_var = nil)
+      if return_var
+        "
+          {
+            VALUE op1 = Qnil;
+            VALUE op2 = Qnil;
+            #{to_c tree[1], "op1"};
+            #{to_c tree[2], "op2"};
+            #{return_var} = (RTEST(op1) || RTEST(op2)) ? Qtrue : Qfalse;
+          }
+        "
+      else
       "(RTEST(#{to_c tree[1]}) || RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
+      end
     end
 
-    def to_c_not(tree)
-      "RTEST(#{to_c tree[1]}) ? Qfalse : Qtrue"
+    def to_c_not(tree, return_var = nil)
+      if return_var
+        "
+          {
+            VALUE op1 = Qnil;
+            #{to_c tree[1], "op1"};
+            #{return_var} = (RTEST(op1)) ? Qfalse: Qtrue;
+          }
+        "
+      else
+        "RTEST(#{to_c tree[1]}) ? Qfalse : Qtrue"
+      end
     end
     
   end

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

@@ -22,47 +22,64 @@ module FastRuby
   module BlockTranslator
     register_translator_module self
     
-    def to_c_class(tree)
+    def to_c_class(tree, result_var = nil)
       str_class_name = get_class_name(tree[1])
       container_tree = get_container_tree(tree[1])
 
       if container_tree == s(:self)
         method_group("
+                    VALUE superklass = rb_cObject;
+                    #{
+                    if tree[2] 
+                      to_c tree[2], "superklass"
+                    end
+                    };
                     VALUE tmpklass = rb_define_class(
                       #{str_class_name.inspect},
-                      #{tree[2] ? to_c(tree[2]) : "rb_cObject"}
+                      superklass
                   );
-        ", tree[3])
+        ", tree[3], result_var)
       else
         method_group("
-                    VALUE container_klass = #{to_c(container_tree)};
+                    VALUE container_klass = Qnil;
+                    VALUE superklass = rb_cObject;
+                    
+                    #{
+                    if tree[2] 
+                      to_c tree[2], "superklass"
+                    end
+                    };
+                    
+                    #{to_c(container_tree, "container_klass")};
                     VALUE tmpklass = rb_define_class_under(
                       container_klass,
                       #{str_class_name.inspect},
-                      #{tree[2] ? to_c(tree[2]) : "rb_cObject"}
+                      superklass
                   );
-        ", tree[3])
+        ", tree[3], result_var)
       end
     end
 
-    def to_c_module(tree)
+    def to_c_module(tree, result_var = nil)
       str_class_name = get_class_name(tree[1])
       container_tree = get_container_tree(tree[1])
 
       if container_tree == s(:self)
         method_group("
                       VALUE tmpklass = rb_define_module(#{str_class_name.inspect});
-        ", tree[2])
+        ", tree[2], result_var)
       else
         method_group("
-                      VALUE container_klass = #{to_c(container_tree)};
+                      VALUE container_klass = Qnil;
+                      
+                      #{to_c(container_tree, "container_klass")};
                       VALUE tmpklass = rb_define_module_under(container_klass,#{str_class_name.inspect});
-        ", tree[2])
+        ", tree[2], result_var)
       end
     end
     
 private
-    def method_group(init_code, tree)
+    def method_group(init_code, tree, result_var)
 
       alt_locals = Set.new
       alt_locals << :self
@@ -112,7 +129,7 @@ private
 
             plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
 
-            plocals->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
+            plocals->parent_locals = frame.thread_data->last_plocals;
             void* old_parent_locals = frame.thread_data->last_plocals;
             frame.thread_data->last_plocals = plocals;
 
@@ -120,7 +137,7 @@ private
             plocals->active = Qtrue;
             plocals->self = self;
             plocals->targetted = Qfalse;
-            plocals->call_frame = LONG2FIX(0);
+            plocals->call_frame = 0;
 
             #{to_c tree};
 
@@ -141,17 +158,22 @@ private
         }
       end
 
-      inline_block("
+      code = "
+        {
         #{init_code}
 
         rb_funcall(tmpklass, #{intern_num :__id__},0);
 
         #{fun}(tmpklass);
-        return Qnil;
-
-
-      ")
-
+        }
+      "
+      
+      if result_var
+        code + "\n#{result_var} = Qnil;\n"
+      else  
+        inline_block code + "\nreturn Qnil;\n"
+      end
+      
     end
 
     def get_class_name(argument)

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

@@ -22,70 +22,115 @@ module FastRuby
   module NonLocalTranslator
     register_translator_module self
 
-    def to_c_return(tree)
-      inline_block "
-        plocals->return_value = #{to_c(tree[1])};
-        plocals->targetted = 1;
-        longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
+    def to_c_return(tree, return_variable = nil)
+      code = "
+        #{to_c(tree[1],"last_expression")};
+        goto local_return;
         return Qnil;
         "
+      if return_variable
+        code
+      else
+        inline_block code
+      end
     end
 
-    def to_c_break(tree)
-        inline_block(
-         "
+    def to_c_break(tree, result_var = nil)
+      
+        value_tmp_var = "value_" + rand(10000000).to_s
+      
+        code = "
 
-         VALUE value = #{tree[1] ? to_c(tree[1]) : "Qnil"};
+          {
+         VALUE #{value_tmp_var} = Qnil; 
+         #{
+         if tree[1]
+           to_c(tree[1], value_tmp_var)
+         end
+         };
 
          typeof(pframe) target_frame_;
-         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+         target_frame_ = (void*)plocals->call_frame;
 
          if (target_frame_ == 0) {
             #{_raise("rb_eLocalJumpError","illegal break")};
          }
 
-         plocals->call_frame = LONG2FIX(0);
+         plocals->call_frame = 0;
 
-         target_frame_->return_value = value;
+         target_frame_->return_value = #{value_tmp_var};
          target_frame_->targetted = 1;
          pframe->thread_data->exception = Qnil;
-         longjmp(pframe->jmp,FASTRUBY_TAG_BREAK);"
-        )
+         longjmp(pframe->jmp,FASTRUBY_TAG_BREAK);
+         
+         }
+         "
+         
+         if result_var
+           code
+         else
+           inline_block code
+         end
     end
 
-    def to_c_retry(tree)
-        inline_block(
-         "
+    def to_c_retry(tree, result_var = nil)
+        code = "
+          {
          typeof(pframe) target_frame_;
-         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+         target_frame_ = (void*)plocals->call_frame;
 
          if (target_frame_ == 0) {
             #{_raise("rb_eLocalJumpError","illegal retry")};
          }
 
          target_frame_->targetted = 1;
-         longjmp(pframe->jmp,FASTRUBY_TAG_RETRY);"
-        )
+         longjmp(pframe->jmp,FASTRUBY_TAG_RETRY);
+         }
+         "
+       if result_var
+         code
+       else
+         inline_block code
+       end
     end
 
-    def to_c_redo(tree)
+    def to_c_redo(tree, result_var = nil)
       if @on_block
-         inline_block "
-          longjmp(pframe->jmp,FASTRUBY_TAG_REDO);
-          return Qnil;
+         code = "
+            goto fastruby_local_redo;
           "
+          
+          if result_var
+            code
+          else
+            inline_block code
+          end
       else
           _raise("rb_eLocalJumpError","illegal redo");
       end
     end
 
-    def to_c_next(tree)
+    def to_c_next(tree, result_var = nil)
+      tmp_varname = "_acc_" + rand(10000000).to_s
       if @on_block
-       inline_block "
-        pframe->thread_data->accumulator = #{tree[1] ? to_c(tree[1]) : "Qnil"};
-        longjmp(pframe->jmp,FASTRUBY_TAG_NEXT);
-        return Qnil;
+       code = "
+        {
+          last_expression = Qnil;
+          
+          #{
+          if tree[1]
+            to_c(tree[1],"last_expression")
+          end
+          }
+        pframe->thread_data->accumulator = last_expression;
+        goto fastruby_local_next;
+        }
         "
+        if result_var
+          code
+        else
+          inline_block code
+        end
       else
         _raise("rb_eLocalJumpError","illegal next");
       end