fastruby 0.0.18 → 0.0.19

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

@@ -42,55 +42,55 @@ module FastRuby
       }
 
       splat_arg = tree.find{|x| x == :yield ? false : x[0] == :splat}
-      ret = nil      
-      if splat_arg
-        ret = "
-          VALUE splat_array = Qnil;
-          VALUE block_aux = Qnil;
-           #{to_c(splat_arg[1], "splat_array")};
-          
-          if (CLASS_OF(splat_array) == rb_cArray) {
-            VALUE block_args[_RARRAY_LEN(splat_array) + #{tree.size}];
-            int i;
-            #{ 
-              (0..tree.size-3).map{|i|
-                "
-                #{to_c(tree[i+1], "block_aux")};
-                block_args[#{i}] = block_aux;
-                "
-              }.join(";\n")
-            };
+
+      protected_block(false) do
+        if splat_arg
+          "
+            VALUE splat_array = Qnil;
+            VALUE block_aux = Qnil;
+             #{to_c(splat_arg[1], "splat_array")};
             
-            for (i=0; i<_RARRAY_LEN(splat_array); i++) {
-              block_args[i+#{tree.size-2}] = rb_ary_entry(splat_array,i);
+            if (CLASS_OF(splat_array) == rb_cArray) {
+              VALUE block_args[_RARRAY_LEN(splat_array) + #{tree.size}];
+              int i;
+              #{ 
+                (0..tree.size-3).map{|i|
+                  "
+                  #{to_c(tree[i+1], "block_aux")};
+                  block_args[#{i}] = block_aux;
+                  "
+                }.join(";\n")
+              };
+              
+              for (i=0; i<_RARRAY_LEN(splat_array); i++) {
+                block_args[i+#{tree.size-2}] = rb_ary_entry(splat_array,i);
+              }
+              
+              last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, _RARRAY_LEN(splat_array) + #{tree.size-2});
+            } else {
+              VALUE block_args[1+#{tree.size}];
+              #{ 
+                (0..tree.size-3).map{|i|
+                  "
+                  #{to_c(tree[i+1], "block_aux")};
+                  block_args[#{i}] = block_aux;
+                  "
+                }.join(";\n")
+              };
+              
+              block_args[#{tree.size-2}] = splat_array;
+              last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, #{tree.size-1});
             }
             
-            last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, _RARRAY_LEN(splat_array) + #{tree.size-2});
-          } else {
-            VALUE block_args[1+#{tree.size}];
-            #{ 
-              (0..tree.size-3).map{|i|
-                "
-                #{to_c(tree[i+1], "block_aux")};
-                block_args[#{i}] = block_aux;
-                "
-              }.join(";\n")
-            };
-            
-            block_args[#{tree.size-2}] = splat_array;
-            last_expression = #{anonymous_function(&block_code)}((VALUE)pframe, block_args, #{tree.size-1});
-          }
-          
-        "
-      else
-        ret = if tree.size > 1
-            "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}},#{tree.size-1})"
-          else
-            "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){}, #{tree.size-1})"
-          end
+          "
+        else
+          if tree.size > 1
+              "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}},#{tree.size-1})"
+            else
+              "last_expression = " + anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){}, #{tree.size-1})"
+            end
+        end
       end
-      
-      protected_block(ret, false)
     end
 
     define_translator_for(:block, :method => :to_c_block)
@@ -98,24 +98,30 @@ module FastRuby
       if tree.size == 1
         return inline_block("return Qnil;")
       end
-      
-      str = ""
-      str = tree[1..-2].map{ |subtree|
-        to_c(subtree,"last_expression")
-      }.join(";")
 
-      if tree[-1]
-          str = str + ";#{to_c(tree[-1],"last_expression")};"
-      end
-
-      if result_variable
-        str << "#{result_variable} = last_expression;"
+      code = proc{
+        
+        str = tree[1..-2].map{ |subtree|
+          to_c(subtree,"last_expression")
+        }.join(";")
+  
+        if tree[-1]
+            str = str + ";#{to_c(tree[-1],"last_expression")};"
+        end
+  
+        if result_variable
+          str << "#{result_variable} = last_expression;"
+        else
+          str << "return last_expression;"
+        end
         str
+      }
+  
+      if result_variable
+        code.call
       else
-        str << "return last_expression;"
-        inline_block str
+        inline_block &code
       end
     end
-    
   end
 end

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

@@ -170,7 +170,7 @@ module FastRuby
 
 
               if block_pass_arg or result_var
-                code = "
+                code = proc{ "
                 {
                 VALUE recv = Qnil;
                 #{to_c recv, "recv"};
@@ -213,8 +213,9 @@ module FastRuby
                 }
                 }
                 "
+                }
               
-                result_var ? code : inline_block(code)
+                result_var ? code.call : inline_block(&code)
               else
                  "((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, 0, (VALUE[]){})"               
               end          
@@ -225,7 +226,7 @@ module FastRuby
 
                 strargs = (0..args_tree.size-2).map{|i| "#{suffix}arg#{i}"}.join(",")
               if block_pass_arg or result_var
-                code = "
+                code = proc{ "
                 {
                 VALUE recv = Qnil;
                 
@@ -281,7 +282,9 @@ module FastRuby
                 
                 }
                 "
-                result_var ? code : inline_block(code)
+                }
+                
+                result_var ? code.call : inline_block(&code)
               else
                 strargs = args[1..-1].map{|arg| to_c arg}.join(",")
                 "((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{args.size-1}, (VALUE[]){#{strargs}})"

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

@@ -23,73 +23,75 @@ module FastRuby
     
     define_translator_for(:rescue, :method => :to_c_rescue, :arity => 1)
     def to_c_rescue(tree)
-      if tree[1][0] == :resbody
-        else_tree = tree[2]
-
-        if else_tree
-          to_c else_tree
-        else
-          "Qnil"
-        end
-      else
-        resbody_tree = tree[2]
-        else_tree = nil
-        if tree[-1]
-          if tree[-1][0] != :resbody
-            else_tree = tree[-1]
+      catch_on_throw do
+        if tree[1][0] == :resbody
+          else_tree = tree[2]
+  
+          if else_tree
+            to_c else_tree
+          else
+            "Qnil"
           end
-        end
-
-        catch_condition_array = []
-        lasgn_code = ""
-        resbody_code = to_c(resbody_tree[2])
-
-        rescue_code = ""
-
-        tree[1..-1].each do |resbody_tree|
-          next if resbody_tree[0] != :resbody
-
-          if resbody_tree[1].size == 1
-            resbody_tree[1][1] = s(:const, :Exception)
-          end
-
-          if resbody_tree[1].last[0] == :lasgn
-            lasgn_code = to_c(resbody_tree[1].last)
+        else
+          resbody_tree = tree[2]
+          else_tree = nil
+          if tree[-1]
+            if tree[-1][0] != :resbody
+              else_tree = tree[-1]
+            end
           end
-
-          resbody_tree[1][1..-1].each do |xtree|
-            if xtree[0] != :lasgn
-              trapcode = "rb_eException";
-
-              if xtree
-                trapcode = to_c(xtree)
+  
+          catch_condition_array = []
+          lasgn_code = ""
+          resbody_code = to_c(resbody_tree[2])
+  
+          rescue_code = ""
+  
+          tree[1..-1].each do |resbody_tree|
+            next if resbody_tree[0] != :resbody
+  
+            if resbody_tree[1].size == 1
+              resbody_tree[1][1] = s(:const, :Exception)
+            end
+  
+            if resbody_tree[1].last[0] == :lasgn
+              lasgn_code = to_c(resbody_tree[1].last)
+            end
+  
+            resbody_tree[1][1..-1].each do |xtree|
+              if xtree[0] != :lasgn
+                trapcode = "rb_eException";
+  
+                if xtree
+                  trapcode = to_c(xtree)
+                end
+  
+                catch_condition_array << "(rb_obj_is_kind_of(frame.thread_data->exception,#{trapcode}) == Qtrue)"
               end
-
-              catch_condition_array << "(rb_obj_is_kind_of(frame.thread_data->exception,#{trapcode}) == Qtrue)"
             end
-          end
-
-          rescue_code << "
-            if (aux == FASTRUBY_TAG_RAISE) {
-              if (#{catch_condition_array.join(" || ")})
-              {
-                // trap exception
-                frame.targetted = 1;
-
-                #{lasgn_code};
-
-                 #{resbody_code};
+  
+            rescue_code << "
+              if (aux == FASTRUBY_TAG_RAISE) {
+                if (#{catch_condition_array.join(" || ")})
+                {
+                  // trap exception
+                  frame.targetted = 1;
+  
+                  #{lasgn_code};
+  
+                   #{resbody_code};
+                }
               }
-            }
-          "
+            "
+          end
+  
+          frame_call(
+            "ret = " + frame(to_c(tree[1])+";","
+              #{rescue_code}
+            ", else_tree ? to_c(else_tree) : nil, 1)
+  
+            )
         end
-
-        frame_call(
-          "ret = " + frame(to_c(tree[1])+";","
-            #{rescue_code}
-          ", else_tree ? to_c(else_tree) : nil, 1)
-
-          )
       end
     end
 
@@ -99,9 +101,9 @@ module FastRuby
         to_c tree[1]
       else
         ensured_code = to_c tree[2]
-        inline_block "
-          #{frame(to_c(tree[1]),ensured_code,ensured_code,1)};
-        "
+        inline_block {
+          "#{frame(to_c(tree[1]),ensured_code,ensured_code,1)};"
+        }
       end
     end
 

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

@@ -31,7 +31,7 @@ module FastRuby
       infered_value = infer_value(condition_tree)
       unless infered_value
         
-        code = "
+        code = proc{"
           {
             VALUE condition_result;
             #{to_c condition_tree, "condition_result"};
@@ -44,12 +44,12 @@ module FastRuby
               " : ""
             }
           }
-        "
+        "}
   
         if result_variable_
-          code
+          code.call
         else
-          inline_block code + "; return last_expression;"
+          inline_block { code.call + "; return last_expression;" }
         end
       else
         if infered_value.value
@@ -70,7 +70,7 @@ module FastRuby
       begin_while = "begin_while_"+rand(10000000).to_s
       end_while = "end_while_"+rand(10000000).to_s
       aux_varname = "_aux_" + rand(10000000).to_s
-      code = "
+      code = proc{ "
         {
           VALUE while_condition;
           VALUE #{aux_varname};
@@ -90,12 +90,12 @@ module FastRuby
           end
           }
         }
-      "
+      "}
       
       if result_var
-        code
+        code.call
       else
-        inline_block code
+        inline_block &code
       end
       
     end

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

@@ -32,6 +32,7 @@ module FastRuby
       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]
@@ -49,7 +50,7 @@ module FastRuby
         "
       end
       
-        code = "
+          "
           {
           VALUE #{hash_tmp_var} = rb_hash_new();
           #{hash_aset_code};
@@ -61,12 +62,12 @@ module FastRuby
           end
           };
           }
-        "
+        "}
         
       if result_var
-        code
+        code.call
       else
-        inline_block code
+        inline_block &code
       end
     end
 

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

@@ -89,8 +89,8 @@ private
         alt_locals << local
       end
 
+      code = proc{ 
       fun = nil
-
       locals_scope(alt_locals) do
         fun = anonymous_function { |method_name| "static VALUE #{method_name}(VALUE self) {
 
@@ -158,8 +158,8 @@ private
         "
         }
       end
-
-      code = "
+      
+      "
         {
         #{init_code}
 
@@ -168,11 +168,12 @@ private
         #{fun}(tmpklass);
         }
       "
+      }
       
       if result_var
-        code + "\n#{result_var} = Qnil;\n"
+        code.call + "\n#{result_var} = Qnil;\n"
       else  
-        inline_block code + "\nreturn Qnil;\n"
+        inline_block &code + "\nreturn Qnil;\n"
       end
       
     end

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

@@ -23,15 +23,16 @@ module FastRuby
     
     define_translator_for(:return, :method => :to_c_return)
     def to_c_return(tree, return_variable = nil)
-      code = "
+      code = proc{"
         #{to_c(tree[1],"last_expression")};
         goto local_return;
         return Qnil;
-        "
+        "}
+        
       if return_variable
-        code
+        code.call
       else
-        inline_block code
+        inline_block &code
       end
     end
 
@@ -40,7 +41,7 @@ module FastRuby
       
         value_tmp_var = "value_" + rand(10000000).to_s
       
-        code = "
+        code = proc{"
 
           {
          VALUE #{value_tmp_var} = Qnil; 
@@ -65,10 +66,10 @@ module FastRuby
          longjmp(pframe->jmp,FASTRUBY_TAG_BREAK);
          
          }
-         "
+         "}
          
          if result_var
-           code
+           code.call
          else
            inline_block code
          end
@@ -117,7 +118,7 @@ module FastRuby
     def to_c_next(tree, result_var = nil)
       tmp_varname = "_acc_" + rand(10000000).to_s
       if @on_block
-       code = "
+       code =proc {"
         {
           last_expression = Qnil;
           
@@ -129,15 +130,156 @@ module FastRuby
         pframe->thread_data->accumulator = last_expression;
         goto fastruby_local_next;
         }
-        "
+        "}
+        
         if result_var
-          code
+          code.call
         else
-          inline_block code
+          inline_block &code
         end
       else
         _raise("rb_eLocalJumpError","illegal next");
       end
     end
+    
+    define_method_handler(:to_c, :priority => 100) { |tree, result_var = nil|
+
+      call_tree = tree[1]
+      catch_tag_id = call_tree[3][1][1]
+      included_catch_jmp = false
+
+      @catch_jmp = @catch_jmp || Set.new
+      
+      begin
+        inner_code = catch_block(catch_tag_id) do
+          to_c(tree[3],result_var)
+        end
+        
+        included_catch_jmp = true if @catch_jmp.include?(catch_tag_id) 
+      ensure
+        @catch_jmp.delete(catch_tag_id)
+      end
+      
+      if included_catch_jmp
+        new_frame = anonymous_function{ |name| "
+          static VALUE #{name}(VALUE param) {
+            volatile VALUE last_expression = Qnil;
+            #{@frame_struct} frame;
+  
+            typeof(frame)* volatile pframe;
+            typeof(frame)* volatile parent_frame;
+            #{@locals_struct}* volatile plocals;
+  
+            parent_frame = (void*)param;
+  
+            frame.parent_frame = (void*)param;
+            frame.plocals = parent_frame->plocals;
+            frame.rescue = parent_frame->rescue;
+            frame.targetted = 0;
+            frame.thread_data = parent_frame->thread_data;
+            frame.return_value = Qnil;
+            frame.thread_data->accumulator = Qnil;
+            if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
+  
+            plocals = frame.plocals;
+            pframe = &frame;
+  
+            volatile int aux = setjmp(frame.jmp);
+            if (aux != 0) {
+              // restore previous frame
+              typeof(pframe) original_frame = pframe;
+              pframe = parent_frame;
+
+              if (aux == (int)#{intern_num catch_tag_id.to_s + "_end"}) {
+                return frame.thread_data->accumulator;
+              } else if (aux == (int)#{intern_num catch_tag_id.to_s + "_start"}) {
+              } else {
+                longjmp(pframe->jmp,aux);
+              }
+  
+              return last_expression;
+            }
+            
+         #{catch_tag_id.to_s}_start:
+                #{inner_code};
+          #{catch_tag_id.to_s}_end:
+            return last_expression;
+#{@catch_blocks.map { |cb|
+  "#{cb.to_s}_end:
+
+   plocals->return_value = last_expression;
+   plocals->targetted = 1;
+   longjmp(pframe->jmp, #{intern_num( cb.to_s + "_end")});
+    
+   #{cb.to_s}_start:
+  
+   plocals->return_value = last_expression;
+   plocals->targetted = 1;
+   longjmp(pframe->jmp, #{intern_num( cb.to_s + "_start")});
+  
+  "
+
+}.join("\n")
+}
+  
+            }
+          "
+        } + "((VALUE)pframe)"
+        
+        if result_var
+          "#{result_var} = #{new_frame};"
+        else
+          new_frame
+        end
+      else
+          "
+         #{catch_tag_id.to_s}_start:
+                #{inner_code};
+          #{catch_tag_id.to_s}_end:
+          
+          "
+      end
+
+    }.condition{|tree, result_var = nil| 
+      tree.node_type == :iter && tree[1][2] == :_catch
+    }
+
+    define_method_handler(:to_c, :priority => 100) { |tree, result_var = nil|
+      code = ""
+      
+      catch_tag_id = tree[3][1][1]
+      
+      if @catch_jmp_on_throw
+        @catch_jmp << catch_tag_id
+      end
+      
+      code << to_c(tree[3][2] || fs(:nil), "last_expression")
+      code << "pframe->thread_data->accumulator = last_expression;"
+      code << "goto #{catch_tag_id.to_s}_end;"
+      
+      if result_var
+        code
+      else
+        inline_block code
+      end
+    }.condition{|tree, result_var = nil| 
+      tree.node_type == :call && tree[2] == :_throw
+    }
+    
+    define_method_handler(:to_c, :priority => 100) { |tree, result_var = nil|
+      code = ""
+      
+      catch_tag_id = tree[3][1][1]
+      code << "goto #{catch_tag_id.to_s}_start;"
+      
+      if result_var
+        code
+      else
+        inline_block code
+      end
+    }.condition{|tree, result_var = nil| 
+      tree.node_type == :call && tree[2] == :_loop
+    }
+
   end
 end