fastruby 0.0.14 → 0.0.15

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

@@ -49,8 +49,6 @@ module FastRuby
       mobject = nil
       len = nil
 
-      extra_inference = {}
-
       if recvtype
 
         inference_complete = true
@@ -64,31 +62,6 @@ module FastRuby
             inference_complete = false
           end
         end
-
-        if recvtype.respond_to? :fastruby_method and inference_complete
-          method_tree = nil
-          begin
-            method_tree = recvtype.instance_method(call_tree[2]).fastruby.tree
-          rescue NoMethodError
-          end
-
-          if method_tree
-            mobject = recvtype.build(signature, call_tree[2])
-            yield_signature = mobject.yield_signature
-
-            if not args_tree
-            elsif args_tree.first == :lasgn
-              if yield_signature[0]
-              extra_inference[args_tree.last] = yield_signature[0]
-              end
-            elsif args_tree.first == :masgn
-              yield_args = args_tree[1][1..-1].map(&:last)
-              (0...yield_signature.size-1).each do |i|
-                extra_inference[yield_args[i]] = yield_signature[i]
-              end
-            end
-          end
-        end
       end
 
       anonymous_impl = tree[3]
@@ -103,8 +76,6 @@ module FastRuby
 
       str_impl = ""
 
-      with_extra_inference(extra_inference) do
-
         on_block do
           # if impl_tree is a block, implement the last node with a return
           if anonymous_impl
@@ -129,18 +100,41 @@ module FastRuby
             str_impl = "last_expression = Qnil;"
           end
         end
-      end
-
 
         if not args_tree
-          str_arg_initialization = ""
         elsif args_tree.first == :lasgn
-          str_arg_initialization = "plocals->#{args_tree[1]} = arg;"
+          str_arg_initialization << "plocals->#{args_tree[1]} = arg;"
         elsif args_tree.first == :masgn
-          arguments = args_tree[1][1..-1].map(&:last)
-
+          
+          str_arg_initialization << "
+              {
+                if (TYPE(arg) != T_ARRAY) {
+                  if (arg != Qnil) {
+                    arg = rb_ary_new4(1,&arg);
+                  } else {
+                    arg = rb_ary_new2(0);
+                  }
+                } else if (RARRAY(arg)->len <= 1) {
+                  arg = rb_ary_new4(1,&arg);
+                }
+              }
+              "          
+          
+          arguments = args_tree[1][1..-1]
+          
           (0..arguments.size-1).each do |i|
-            str_arg_initialization << "plocals->#{arguments[i]} = rb_ary_entry(arg,#{i});\n"
+            arg = arguments[i]
+            if arg[0] == :lasgn 
+              str_arg_initialization << "plocals->#{arguments[i].last} = rb_ary_entry(arg,#{i});\n"
+            elsif arg[0] == :splat
+              str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(RARRAY(arg)->len-#{i});\n
+              
+                int i;
+                for (i=#{i};i<RARRAY(arg)->len;i++){
+                  rb_ary_store(plocals->#{arg.last.last},i-#{i},rb_ary_entry(arg,i));
+                }
+               "
+            end
           end
         end
         rb_funcall_caller_code = nil
@@ -339,7 +333,7 @@ module FastRuby
                           rb_raise(rb_eLocalJumpError,\"return from proc-closure\");
                         } else {
                           ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
-                          rb_jump_tag(aux);
+                          frb_jump_tag(aux);
                         }
                       } else {
                         rb_raise(rb_eLocalJumpError, \"unexpected return\");
@@ -382,7 +376,7 @@ module FastRuby
                 } else if (aux == FASTRUBY_TAG_REDO) {
                   // do nothing and let execute the block again
                 } else {
-                  rb_jump_tag(aux);
+                  frb_jump_tag(aux);
                   return frame.return_value;
                 }
             }
@@ -396,6 +390,48 @@ module FastRuby
         "
         }
 
+        rb_funcall_block_code_callcc = proc { |name| "
+          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+            // block for call to #{call_tree[2]}
+            VALUE last_expression = Qnil;
+
+            #{@frame_struct} frame;
+            #{@frame_struct} *pframe = (void*)&frame;
+            #{@locals_struct} *plocals = (void*)_plocals;
+
+            frame.plocals = plocals;
+            frame.parent_frame = 0;
+            frame.return_value = Qnil;
+            frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = rb_current_thread_data();
+
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
+
+                if (aux == FASTRUBY_TAG_NEXT) {
+                  return pframe->thread_data->accumulator;
+                } else if (aux == FASTRUBY_TAG_REDO) {
+                  // do nothing and let execute the block again
+                } else {
+                  frb_jump_tag(aux);
+                  return frame.return_value;
+                }
+            }
+            
+            if (rb_obj_is_kind_of(arg,rb_cCont)) {
+              struct FASTRUBYTHREADDATA* thread_data = frame.thread_data;
+              rb_ivar_set(arg,#{intern_num :__stack_chunk},thread_data->rb_stack_chunk);
+            }
+
+            #{str_arg_initialization}
+            #{str_impl}
+
+            return last_expression;
+          }
+        "
+        }
+
 
         fastruby_str_arg_initialization = ""
 
@@ -404,10 +440,22 @@ module FastRuby
         elsif args_tree.first == :lasgn
           fastruby_str_arg_initialization = "plocals->#{args_tree[1]} = argv[0];"
         elsif args_tree.first == :masgn
-          arguments = args_tree[1][1..-1].map(&:last)
-
+          arguments = args_tree[1][1..-1]
+          
           (0..arguments.size-1).each do |i|
-            fastruby_str_arg_initialization << "plocals->#{arguments[i]} = #{i} < argc ? argv[#{i}] : Qnil;\n"
+            arg = arguments[i]
+            if arg[0] == :lasgn 
+              fastruby_str_arg_initialization << "plocals->#{arg.last} = #{i} < argc ? argv[#{i}] : Qnil;\n"
+            elsif arg[0] == :splat
+              fastruby_str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(#{arguments.size-1-i});\n
+              {
+                int i;
+                for (i=#{i};i<argc;i++){
+                  rb_ary_store(plocals->#{arg.last.last},i-#{i},argv[i]);
+                }
+              }
+               "
+            end 
           end
         end
 
@@ -496,16 +544,55 @@ module FastRuby
                 }
         "
         
+          precode = "
+              struct FASTRUBYTHREADDATA* thread_data = 0;
+              VALUE saved_rb_stack_chunk = Qnil; 
+
+              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
+
+              NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
+
+              if (node == #{@callcc_node_gvar}) {
+                
+                // freeze all stacks
+                thread_data = rb_current_thread_data();
+  
+                if (thread_data != 0) {
+                  VALUE rb_stack_chunk = thread_data->rb_stack_chunk;
+                  saved_rb_stack_chunk = rb_stack_chunk;
+
+                  // freeze the complete chain of stack chunks
+                  while (rb_stack_chunk != Qnil) {
+                    struct STACKCHUNK* stack_chunk;
+                    Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
+  
+                    stack_chunk_freeze(stack_chunk);
+  
+                    rb_stack_chunk = rb_ivar_get(rb_stack_chunk,#{intern_num :_parent_stack_chunk});
+                  }
+                }
+              }
+            "
+          
+          postcode = "
+              if (node == #{@callcc_node_gvar}) {
+                thread_data->rb_stack_chunk = saved_rb_stack_chunk;  
+              }
+          "              
+          
+        
           funcall_call_code = "
           return #{
             frame_call(
               protected_block(inline_block("
-
-              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
-
+              
               NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
               void* caller_func;
               void* block_func;
+              typeof(plocals) current_plocals;
+              
+              if (pframe->thread_data == 0) pframe->thread_data = rb_current_thread_data();
+              void* last_plocals = pframe->thread_data->last_plocals;
 
               if (
                 node == #{@proc_node_gvar} ||
@@ -517,18 +604,44 @@ module FastRuby
               } else if (node == #{@procnew_node_gvar} && pframe->next_recv == rb_cProc) {
                 caller_func = #{anonymous_function(&rb_funcall_caller_code_with_lambda)};
                 block_func = #{anonymous_function(&rb_funcall_block_code_proc_new)};
+              } else if (node == #{@callcc_node_gvar}) {
+                caller_func = #{anonymous_function(&rb_funcall_caller_code)};
+                block_func = #{anonymous_function(&rb_funcall_block_code_callcc)};
               } else {
                 caller_func = #{anonymous_function(&rb_funcall_caller_code)};
                 block_func = #{anonymous_function(&rb_funcall_block_code)};
               }
+              
 
-              return rb_iterate(
+              VALUE ret = rb_iterate(
                 caller_func,
                 (VALUE)pframe,
                 block_func,
                 (VALUE)plocals);
 
-              "), true)
+              if (node == #{@callcc_node_gvar}) {
+  
+                // remove active flags of abandoned stack
+                current_plocals = pframe->thread_data->last_plocals;
+                while (current_plocals) {
+                  current_plocals->active = Qfalse;
+                  current_plocals = (typeof(current_plocals))FIX2LONG(current_plocals->parent_locals); 
+                }
+                
+                // restore last_plocals
+                pframe->thread_data->last_plocals = last_plocals;
+                
+                // mark all scopes as active
+                current_plocals = last_plocals;
+                
+                while (current_plocals) {
+                  current_plocals->active = Qtrue;
+                  current_plocals = (typeof(current_plocals))FIX2LONG(current_plocals->parent_locals); 
+                }
+              }
+
+              return ret;
+              "), true), precode, postcode
             )
           };
           "        

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

@@ -112,6 +112,10 @@ private
 
             plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
 
+            plocals->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
+            void* old_parent_locals = frame.thread_data->last_plocals;
+            frame.thread_data->last_plocals = plocals;
+
             frame.plocals = plocals;
             plocals->active = Qtrue;
             plocals->self = self;
@@ -128,6 +132,9 @@ private
             }
 
             plocals->active = Qfalse;
+            
+            frame.thread_data->last_plocals = old_parent_locals;
+            
             return Qnil;
           }
         "