fastruby 0.0.9 → 0.0.10

data/lib/fastruby/translator.rb

@@ -46,15 +46,14 @@ module FastRuby
       @init_extra = Array.new
       @frame_struct = "struct {
         void* parent_frame;
-        void* target_frame;
         void* plocals;
         jmp_buf jmp;
         VALUE return_value;
-        VALUE exception;
         int rescue;
         VALUE last_error;
-        void* stack_chunk;
         VALUE next_recv;
+        int targetted;
+        struct FASTRUBYTHREADDATA* thread_data;
       }"
 
       @block_struct = "struct {
@@ -66,6 +65,14 @@ module FastRuby
       extra_code << "
         #include \"node.h\"
 
+        #define FASTRUBY_TAG_RETURN 0x80
+        #define FASTRUBY_TAG_NEXT 0x81
+        #define FASTRUBY_TAG_BREAK 0x82
+        #define FASTRUBY_TAG_RAISE 0x83
+        #define FASTRUBY_TAG_REDO 0x84
+        #define FASTRUBY_TAG_RETRY 0x85
+        #define TAG_RAISE 0x6
+
         #ifndef __INLINE_FASTRUBY_BASE
         #include \"#{FastRuby.fastruby_load_path}/../ext/fastruby_base/fastruby_base.inl\"
         #define __INLINE_FASTRUBY_BASE
@@ -130,63 +137,10 @@ module FastRuby
        #{caller.join("\n")}
 */
 
-        "
-        extra_code << "static struct STACKCHUNKREFRENCE* get_stack_chunk_reference_from_context() {
-            struct STACKCHUNKREFERENCE* stack_chunk_reference;
-            VALUE current_thread = rb_thread_current();
-            VALUE rb_stack_chunk_reference = rb_ivar_get(current_thread,#{intern_num :_fastruby_stack_chunk_reference});
-            if (rb_stack_chunk_reference == Qnil) {
-              rb_stack_chunk_reference = rb_stack_chunk_reference_create();
-              rb_ivar_set(current_thread,#{intern_num :_fastruby_stack_chunk_reference},rb_stack_chunk_reference);
-            }
-
-            Data_Get_Struct(rb_stack_chunk_reference,struct STACKCHUNKREFERENCE,stack_chunk_reference);
-
-            return (void*)stack_chunk_reference;
-        }
-
-        static struct STACKCHUNK* get_stack_chunk_from_context(
-                  struct STACKCHUNKREFERENCE** stack_chunk_reference,
-                  VALUE* rb_stack_chunk
-              ) {
-          struct STACKCHUNK* stack_chunk = 0;
-          *stack_chunk_reference = (void*)get_stack_chunk_reference_from_context();
-          *rb_stack_chunk = stack_chunk_reference_retrieve(*stack_chunk_reference);
-          if (*rb_stack_chunk != Qnil) {
-            Data_Get_Struct(*rb_stack_chunk,void,stack_chunk);
-          }
-
-          return stack_chunk;
-        }
-
-        static struct STACKCHUNK* create_stack_chunk_from_context(
-              struct STACKCHUNKREFERENCE** stack_chunk_reference,
-              VALUE* rb_stack_chunk_p
-          ) {
-
-            struct STACKCHUNK* stack_chunk;
-            VALUE rb_stack_chunk = rb_stack_chunk_create(Qnil);
-
-            if (*stack_chunk_reference == 0) {
-              *stack_chunk_reference = (void*)get_stack_chunk_reference_from_context();
-            }
-
-            stack_chunk_reference_assign(*stack_chunk_reference, rb_stack_chunk);
-            Data_Get_Struct(rb_stack_chunk,void,stack_chunk);
-
-            *rb_stack_chunk_p = rb_stack_chunk;
-
-            return stack_chunk;
-        }
-
         "
       end
     end
 
-    def on_block
-      yield
-    end
-
     def to_c(tree)
       return "Qnil" unless tree
       send("to_c_" + tree[0].to_s, tree);
@@ -368,14 +322,10 @@ module FastRuby
               VALUE ret = rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, 0);
 
               // freeze all stacks
-              VALUE current_thread = rb_thread_current();
-              VALUE rb_stack_chunk_reference = rb_ivar_get(current_thread,#{intern_num :_fastruby_stack_chunk_reference});
+              struct FASTRUBYTHREADDATA* thread_data = rb_current_thread_data();
 
-              if (rb_stack_chunk_reference != Qnil) {
-                struct STACKCHUNKREFERENCE* stack_chunk_reference;
-                Data_Get_Struct(rb_stack_chunk_reference, struct STACKCHUNKREFERENCE, stack_chunk_reference);
-
-                VALUE rb_stack_chunk = stack_chunk_reference_retrieve(stack_chunk_reference);
+              if (thread_data != 0) {
+                VALUE rb_stack_chunk = thread_data->rb_stack_chunk;
 
                 // add reference to stack chunk to lambda object
                 rb_ivar_set(ret,#{intern_num :_fastruby_stack_chunk},rb_stack_chunk);
@@ -408,39 +358,44 @@ module FastRuby
             #{@locals_struct} *plocals = (void*)_plocals;
 
             frame.plocals = plocals;
-            frame.stack_chunk = 0;
             frame.parent_frame = 0;
             frame.return_value = Qnil;
-            frame.target_frame = &frame;
-            frame.exception = Qnil;
             frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = rb_current_thread_data();
 
               // create a fake parent frame representing the lambda method frame and a fake locals scope
               VALUE old_call_frame = ((typeof(plocals))(pframe->plocals))->call_frame;
               ((typeof(plocals))(pframe->plocals))->call_frame = LONG2FIX(pframe);
 
-              if (setjmp(frame.jmp) != 0) {
-
-                if (pframe->target_frame != pframe) {
-                  if (pframe->target_frame == (void*)-3) {
-                     return pframe->return_value;
-                  } else if (pframe->target_frame == (void*)-1) {
-                     rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.exception);
-                     return Qnil;
-                  } else {
-                    if (pframe->target_frame == (void*)FIX2LONG(plocals->pframe)) {
+              int aux = setjmp(frame.jmp);
+              if (aux != 0) {
+                if (aux == FASTRUBY_TAG_BREAK) {
+                  return frame.return_value;
+                } else 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 if (aux == FASTRUBY_TAG_RAISE) {
+                   rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.thread_data->exception);
+                   return Qnil;
+                } else {
+                  if (aux == FASTRUBY_TAG_RETURN) {
+                    if (((typeof(pframe))(FIX2LONG(plocals->pframe)))->targetted == 1) {
                       ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
-                      return pframe->return_value;
+                      return ((typeof(plocals))(pframe->plocals))->return_value;
                     } else {
                       rb_raise(rb_eLocalJumpError, \"unexpected return\");
                     }
+                  } else {
+                    rb_raise(rb_eLocalJumpError, \"unexpected return\");
                   }
-                }
-                ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
-                return frame.return_value;
-              }
 
+                  ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
+                  return frame.return_value;
 
+                }
+              }
 
             #{str_arg_initialization}
             #{str_impl}
@@ -461,49 +416,38 @@ module FastRuby
             #{@locals_struct} *plocals = (void*)_plocals;
 
             frame.plocals = plocals;
-            frame.stack_chunk = 0;
             frame.parent_frame = 0;
             frame.return_value = Qnil;
-            frame.target_frame = &frame;
-            frame.exception = Qnil;
             frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = rb_current_thread_data();
 
               // create a fake parent frame representing the lambda method frame and a fake locals scope
               VALUE old_call_frame = ((typeof(plocals))(pframe->plocals))->call_frame;
               ((typeof(plocals))(pframe->plocals))->call_frame = LONG2FIX(pframe);
 
-              if (setjmp(frame.jmp) != 0) {
-                if (pframe->target_frame != pframe) {
-                  if (pframe->target_frame == (void*)-3) {
-                     return pframe->return_value;
-                  } else if (pframe->target_frame == (void*)-1) {
-                     rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.exception);
-                     return Qnil;
-                  } else {
-                    if (pframe->target_frame == (void*)FIX2LONG(plocals->pframe)) {
-
-                      if (plocals->active == Qfalse) {
-                        rb_raise(rb_eLocalJumpError,\"return from proc-closure\");
+              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 if (aux == FASTRUBY_TAG_RAISE) {
+                       rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.thread_data->exception);
+                       return Qnil;
+                    } else {
+                      if (((typeof(pframe))(FIX2LONG(plocals->pframe)))->targetted == 1) {
+
+                        if (plocals->active == Qfalse) {
+                          rb_raise(rb_eLocalJumpError,\"return from proc-closure\");
+                        } else {
+                          ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
+                          rb_jump_tag(aux);
+                        }
                       } else {
-                        ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
-                        VALUE ex = rb_funcall(
-                                #{literal_value FastRuby::Context::UnwindFastrubyFrame},
-                                #{intern_num :new},
-                                3,
-                                pframe->exception,
-                                LONG2FIX(pframe->target_frame),
-                                pframe->return_value
-                                );
-
-                        rb_funcall(plocals->self, #{intern_num :raise}, 1, ex);
+                        rb_raise(rb_eLocalJumpError, \"unexpected return\");
                       }
-                    } else {
-                      rb_raise(rb_eLocalJumpError, \"unexpected return\");
                     }
-                  }
-                }
-
-                rb_raise(rb_eLocalJumpError, \"break from proc-closure\");
               }
 
             #{str_arg_initialization}
@@ -527,32 +471,24 @@ module FastRuby
             #{@locals_struct} *plocals = (void*)_plocals;
 
             frame.plocals = plocals;
-            frame.stack_chunk = 0;
             frame.parent_frame = 0;
             frame.return_value = Qnil;
-            frame.target_frame = &frame;
-            frame.exception = Qnil;
             frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = rb_current_thread_data();
 
-            if (setjmp(frame.jmp) != 0) {
-              if (pframe->target_frame != pframe) {
-                if (pframe->target_frame == (void*)-3) {
-                   return pframe->return_value;
-                }
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
 
-                VALUE ex = rb_funcall(
-                        #{literal_value FastRuby::Context::UnwindFastrubyFrame},
-                        #{intern_num :new},
-                        3,
-                        pframe->exception,
-                        LONG2FIX(pframe->target_frame),
-                        pframe->return_value
-                        );
-
-                rb_funcall(plocals->self, #{intern_num :raise}, 1, ex);
+                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 {
+                  rb_jump_tag(aux);
+                  return frame.return_value;
                 }
-                return frame.return_value;
-              }
+            }
 
 
             #{str_arg_initialization}
@@ -589,25 +525,24 @@ module FastRuby
 
             frame.plocals = (void*)_locals;
             frame.parent_frame = parent_frame;
-            frame.stack_chunk = parent_frame->stack_chunk;
             frame.return_value = Qnil;
-            frame.target_frame = &frame;
-            frame.exception = Qnil;
             frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = parent_frame->thread_data;
+            if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
             plocals = frame.plocals;
 
-            if (setjmp(frame.jmp) != 0) {
-                if (pframe->target_frame != pframe) {
-                  if (pframe->target_frame == (void*)-3) {
-                     return pframe->return_value;
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
+                if (pframe->targetted == 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 {
+                    longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
                   }
-                  // raise exception
-                  ((typeof(pframe))_parent_frame)->exception = pframe->exception;
-                  ((typeof(pframe))_parent_frame)->target_frame = pframe->target_frame;
-                  ((typeof(pframe))_parent_frame)->return_value = pframe->return_value;
-
-                  longjmp(((typeof(pframe))_parent_frame)->jmp,1);
                 }
 
             }
@@ -629,29 +564,7 @@ module FastRuby
         caller_code = nil
         convention_global_name = add_global_name("int",0)
 
-        if call_args_tree.size > 1
-          value_cast = ( ["VALUE"]*(call_tree[3].size) ).join(",") + ", VALUE, VALUE"
-
-          str_called_code_args = call_tree[3][1..-1].map{|subtree| to_c subtree}.join(",")
-
-            caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param, VALUE pframe) {
-                #{@block_struct} block;
-                #{@locals_struct} *plocals = (void*)param;
-
-                block.block_function_address = (void*)#{anonymous_function(&block_code)};
-                block.block_function_param = (void*)param;
-
-                // call to #{call_tree[2]}
-
-                return ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)})(#{str_recv}, (VALUE)&block, (VALUE)pframe, #{str_called_code_args});
-              }
-            "
-            }
-
-        else
-            caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param, VALUE pframe) {
+        call_frame_struct_code = "
                 #{@block_struct} block;
                 #{@locals_struct} *plocals = (void*)param;
 
@@ -662,27 +575,52 @@ module FastRuby
                 #{@frame_struct} call_frame;
 
                 call_frame.parent_frame = (void*)pframe;
-                call_frame.target_frame = 0;
                 call_frame.plocals = plocals;
                 call_frame.return_value = Qnil;
-                call_frame.exception = Qnil;
-                call_frame.stack_chunk = ((typeof(&call_frame))pframe)->stack_chunk;
+                call_frame.targetted = 0;
+                call_frame.thread_data = rb_current_thread_data();
 
                 VALUE old_call_frame = plocals->call_frame;
                 plocals->call_frame = LONG2FIX(&call_frame);
 
-                if (setjmp(call_frame.jmp) != 0) {
+                int aux = setjmp(call_frame.jmp);
+                if (aux != 0) {
                   #{@frame_struct}* pframe_ = (void*)pframe;
 
-                  if (call_frame.target_frame != &call_frame) {
-                    pframe_->target_frame = call_frame.target_frame;
-                    pframe_->exception = call_frame.exception;
-                    longjmp(pframe_->jmp,1);
-                  }
+                  if (aux == FASTRUBY_TAG_RETRY ) {
+                    // do nothing and let the call execute again
+                  } else {
+                    if (call_frame.targetted == 0) {
+                      longjmp(pframe_->jmp,aux);
+                    }
 
-                  plocals->call_frame = old_call_frame;
-                  return call_frame.return_value;
+                    plocals->call_frame = old_call_frame;
+                    return call_frame.return_value;
+                  }
                 }
+        "
+
+        if call_args_tree.size > 1
+          value_cast = ( ["VALUE"]*(call_tree[3].size) ).join(",") + ", VALUE, VALUE"
+
+          str_called_code_args = call_tree[3][1..-1].map{|subtree| to_c subtree}.join(",")
+
+            caller_code = proc { |name| "
+              static VALUE #{name}(VALUE param, VALUE pframe) {
+                // call to #{call_tree[2]}
+                #{call_frame_struct_code}
+
+                VALUE ret = ((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame, #{str_called_code_args});
+                plocals->call_frame = old_call_frame;
+                return ret;
+              }
+            "
+            }
+
+        else
+            caller_code = proc { |name| "
+              static VALUE #{name}(VALUE param, VALUE pframe) {
+                #{call_frame_struct_code}
 
                 // call to #{call_tree[2]}
                 VALUE ret = ((VALUE(*)(VALUE,VALUE,VALUE))#{encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame);
@@ -746,24 +684,30 @@ module FastRuby
         pframe = (typeof(pframe))&call_frame;
 
         call_frame.parent_frame = (void*)pframe;
-        call_frame.target_frame = 0;
         call_frame.plocals = plocals;
         call_frame.return_value = Qnil;
-        call_frame.exception = Qnil;
-        call_frame.stack_chunk = ((typeof(&call_frame))pframe)->stack_chunk;
+        call_frame.targetted = 0;
+        call_frame.thread_data = old_pframe->thread_data;
+        if (call_frame.thread_data == 0) call_frame.thread_data = rb_current_thread_data();
 
         VALUE old_call_frame = plocals->call_frame;
         plocals->call_frame = LONG2FIX(&call_frame);
 
-                if (setjmp(call_frame.jmp) != 0) {
-                  if (call_frame.target_frame != &call_frame) {
-                    old_pframe->target_frame = call_frame.target_frame;
-                    old_pframe->exception = call_frame.exception;
-                    longjmp(old_pframe->jmp,1);
+                int aux = setjmp(call_frame.jmp);
+                if (aux != 0) {
+                  if (call_frame.targetted == 0) {
+                    longjmp(old_pframe->jmp,aux);
                   }
 
-                  plocals->call_frame = old_call_frame;
-                  return call_frame.return_value;
+                  if (aux == FASTRUBY_TAG_BREAK) {
+                    plocals->call_frame = old_call_frame;
+                    return call_frame.return_value;
+                  } else if (aux == FASTRUBY_TAG_RETRY ) {
+                    // do nothing and let the call execute again
+                  } else {
+                    plocals->call_frame = old_call_frame;
+                    return call_frame.return_value;
+                  }
                 }
 
         VALUE ret = #{inner_code};
@@ -847,16 +791,14 @@ module FastRuby
 
     def to_c_return(tree)
       inline_block "
-        pframe->target_frame = ((typeof(pframe))FIX2LONG(plocals->pframe));
         plocals->return_value = #{to_c(tree[1])};
-        pframe->return_value = plocals->return_value;
-        longjmp(pframe->jmp, 1);
+        ((typeof(pframe))FIX2LONG(plocals->pframe))->targetted = 1;
+        longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
         return Qnil;
         "
     end
 
     def to_c_break(tree)
-      if @on_block
         inline_block(
          "
 
@@ -866,35 +808,63 @@ module FastRuby
          target_frame_ = (void*)FIX2LONG(plocals->call_frame);
 
          if (target_frame_ == 0) {
-           rb_raise(rb_eLocalJumpError, \"illegal break\");
+            pframe->thread_data->exception = #{literal_value LocalJumpError.exception};
+            longjmp(pframe->jmp,FASTRUBY_TAG_RAISE);
+            return Qnil;
          }
 
          plocals->call_frame = LONG2FIX(0);
 
-         pframe->target_frame = target_frame_;
-         pframe->return_value = value;
-         pframe->exception = Qnil;
-         longjmp(pframe->jmp,1);"
-         )
-      else
-        inline_block("
-            pframe->target_frame = (void*)-1;
-            pframe->exception = #{literal_value LocalJumpError.exception};
-            longjmp(pframe->jmp,1);
+         target_frame_->return_value = value;
+         target_frame_->targetted = 1;
+         pframe->thread_data->exception = Qnil;
+         longjmp(pframe->jmp,FASTRUBY_TAG_BREAK);"
+        )
+    end
+
+    def to_c_retry(tree)
+        inline_block(
+         "
+         typeof(pframe) target_frame_;
+         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+
+         if (target_frame_ == 0) {
+            pframe->thread_data->exception = rb_funcall(rb_eLocalJumpError, #{intern_num :exception},0);
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
             return Qnil;
-            ")
+         }
+
+         target_frame_->targetted = 1;
+         longjmp(pframe->jmp,FASTRUBY_TAG_RETRY);"
+        )
+    end
 
+    def to_c_redo(tree)
+      if @on_block
+         inline_block "
+          longjmp(pframe->jmp,FASTRUBY_TAG_REDO);
+          return Qnil;
+          "
+      else
+         inline_block "
+            pframe->thread_data->exception = #{literal_value LocalJumpError.exception};
+            longjmp(pframe->jmp,FASTRUBY_TAG_RAISE);
+            return Qnil;
+          "
       end
     end
 
     def to_c_next(tree)
       if @on_block
-       "Qnil; pframe->target_frame = (void*)-3; pframe->return_value = #{tree[1] ? to_c(tree[1]) : "Qnil"}; longjmp(pframe->jmp,1)"
+       inline_block "
+        pframe->thread_data->accumulator = #{tree[1] ? to_c(tree[1]) : "Qnil"};
+        longjmp(pframe->jmp,FASTRUBY_TAG_NEXT);
+        return Qnil;
+        "
       else
         inline_block("
-            pframe->target_frame = (void*)-1;
-            pframe->exception = #{literal_value LocalJumpError.exception};
-            longjmp(pframe->jmp,1);
+            pframe->thread_data->exception = #{literal_value LocalJumpError.exception};
+            longjmp(pframe->jmp,FASTRUBY_TAG_RAISE);
             return Qnil;
             ")
 
@@ -988,19 +958,19 @@ module FastRuby
 
       code = tree[2..-2].map{|subtree|
 
-              # this subtree is a when
-            subtree[1][1..-1].map{|subsubtree|
-              c_calltree = s(:call, nil, :inline_c, s(:arglist, s(:str, tmpvarname), s(:false)))
-              calltree = s(:call, subsubtree, :===, s(:arglist, c_calltree))
+        # this subtree is a when
+        subtree[1][1..-1].map{|subsubtree|
+          c_calltree = s(:call, nil, :inline_c, s(:arglist, s(:str, tmpvarname), s(:false)))
+          calltree = s(:call, subsubtree, :===, s(:arglist, c_calltree))
               "
                 if (RTEST(#{to_c_call(calltree, tmpvarname)})) {
                    return #{to_c(subtree[2])};
                 }
 
               "
-            }.join("\n")
+        }.join("\n")
 
-          }.join("\n")
+      }.join("\n")
 
       inline_block "
 
@@ -1082,22 +1052,21 @@ module FastRuby
             if (nd_type(body) == NODE_CFUNC) {
               struct {
                 void* parent_frame;
-                void* target_frame;
                 void* plocals;
                 jmp_buf jmp;
                 VALUE return_value;
-                VALUE exception;
                 int rescue;
                 VALUE last_error;
-                void* stack_chunk;
+                VALUE next_recv;
+                int targetted;
+                struct FASTRUBYTHREADDATA* thread_data;
               } frame;
 
-              frame.stack_chunk = 0;
-              frame.target_frame = 0;
               frame.parent_frame = 0;
               frame.rescue = 0;
-              frame.exception = Qnil;
               frame.return_value = Qnil;
+              frame.thread_data = rb_current_thread_data();
+              frame.targetted = 0;
 
               int argc = body->nd_argc;
 
@@ -1117,21 +1086,12 @@ module FastRuby
 
               int aux = setjmp(frame.jmp);
               if (aux != 0) {
-                if (frame.target_frame == (void*)-1) {
-                  rb_funcall(self, #{intern_num :raise}, 1, frame.exception);
+                if (aux == FASTRUBY_TAG_RAISE) {
+                  rb_funcall(self, #{intern_num :raise}, 1, frame.thread_data->exception);
                 }
 
-                if (frame.target_frame != &frame) {
-                    VALUE ex = rb_funcall(
-                            #{literal_value FastRuby::Context::UnwindFastrubyFrame},
-                            #{intern_num :new},
-                            3,
-                            frame.exception,
-                            LONG2FIX(frame.target_frame),
-                            frame.return_value
-                            );
-
-                    rb_funcall(self, #{intern_num :raise}, 1, ex);
+                if (frame.targetted == 0) {
+                    rb_jump_tag(aux);
                 }
 
                 return Qnil;
@@ -1299,13 +1259,12 @@ module FastRuby
           void* block_address = 0;
           VALUE block_param = Qnil;
 
-          frame.stack_chunk = 0;
           frame.plocals = 0;
           frame.parent_frame = 0;
           frame.return_value = Qnil;
-          frame.target_frame = &frame;
-          frame.exception = Qnil;
           frame.rescue = 0;
+          frame.targetted = 0;
+          frame.thread_data = rb_current_thread_data();
 
           if (rb_block_given_p()) {
             block_address = #{
@@ -1321,7 +1280,7 @@ module FastRuby
 
           int aux = setjmp(frame.jmp);
           if (aux != 0) {
-            rb_funcall(self, #{intern_num :raise}, 1, frame.exception);
+            rb_funcall(self, #{intern_num :raise}, 1, frame.thread_data->exception);
           }
 
 
@@ -1389,35 +1348,38 @@ module FastRuby
           #{@frame_struct} frame;
           #{@frame_struct} *pframe;
 
-          frame.stack_chunk = 0;
           frame.parent_frame = 0;
           frame.return_value = Qnil;
-          frame.target_frame = &frame;
-          frame.exception = Qnil;
           frame.rescue = 0;
+          frame.targetted = 0;
+          frame.thread_data = rb_current_thread_data();
 
 
           int stack_chunk_instantiated = 0;
           VALUE rb_previous_stack_chunk = Qnil;
-          VALUE current_thread = rb_thread_current();
-          VALUE rb_stack_chunk = Qnil;
-          struct STACKCHUNKREFERENCE* stack_chunk_reference = 0;
+          VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
+          struct STACKCHUNK* stack_chunk = 0;
 
-          if (frame.stack_chunk == 0) {
-            frame.stack_chunk = get_stack_chunk_from_context(&stack_chunk_reference,&rb_stack_chunk);
+          if (rb_stack_chunk != Qnil) {
+            Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
           }
 
-          if (frame.stack_chunk == 0 || (frame.stack_chunk == 0 ? 0 : stack_chunk_frozen(frame.stack_chunk)) ) {
+          if (stack_chunk == 0 || (stack_chunk == 0 ? 0 : stack_chunk_frozen(stack_chunk)) ) {
             rb_previous_stack_chunk = rb_stack_chunk;
             rb_gc_register_address(&rb_stack_chunk);
             stack_chunk_instantiated = 1;
 
-            frame.stack_chunk = create_stack_chunk_from_context(&stack_chunk_reference,&rb_stack_chunk);
+            rb_stack_chunk = rb_stack_chunk_create(Qnil);
+            frame.thread_data->rb_stack_chunk = rb_stack_chunk;
+
+            rb_ivar_set(rb_stack_chunk, #{intern_num :_parent_stack_chunk}, rb_previous_stack_chunk);
+
+            Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
           }
 
-          int previous_stack_position = stack_chunk_get_current_position(frame.stack_chunk);
+          int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
 
-          plocals = (typeof(plocals))stack_chunk_alloc(frame.stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
+          plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
           plocals->active = Qtrue;
           plocals->pframe = LONG2FIX(&frame);
           frame.plocals = plocals;
@@ -1428,17 +1390,11 @@ module FastRuby
 
           int aux = setjmp(pframe->jmp);
           if (aux != 0) {
-            stack_chunk_set_current_position(frame.stack_chunk, previous_stack_position);
+            stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
             if (stack_chunk_instantiated) {
               rb_gc_unregister_address(&rb_stack_chunk);
-              stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
-            }
-
-            if (pframe->target_frame != pframe) {
-              // raise exception
-              plocals->active = Qfalse;
-              return Qnil;
+              frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
             }
 
             plocals->active = Qfalse;
@@ -1456,11 +1412,11 @@ module FastRuby
           plocals->call_frame = LONG2FIX(0);
 
           VALUE ret = #{to_c impl_tree};
-          stack_chunk_set_current_position(frame.stack_chunk, previous_stack_position);
+          stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
           if (stack_chunk_instantiated) {
             rb_gc_unregister_address(&rb_stack_chunk);
-            stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
+            frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
           }
 
           plocals->active = Qfalse;
@@ -1486,36 +1442,40 @@ module FastRuby
           #{@frame_struct} *pframe;
 
           frame.parent_frame = (void*)_parent_frame;
-          frame.stack_chunk = ((typeof(pframe))_parent_frame)->stack_chunk;
           frame.return_value = Qnil;
-          frame.target_frame = &frame;
-          frame.exception = Qnil;
           frame.rescue = 0;
+          frame.targetted = 0;
+          frame.thread_data = ((typeof(pframe))_parent_frame)->thread_data;
+          if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
           int stack_chunk_instantiated = 0;
           VALUE rb_previous_stack_chunk = Qnil;
-          VALUE current_thread = rb_thread_current();
-          VALUE rb_stack_chunk = Qnil;
-          struct STACKCHUNKREFERENCE* stack_chunk_reference = 0;
+          VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
+          struct STACKCHUNK* stack_chunk = 0;
 
-          if (frame.stack_chunk == 0) {
-            frame.stack_chunk = get_stack_chunk_from_context(&stack_chunk_reference,&rb_stack_chunk);
+          if (rb_stack_chunk != Qnil) {
+            Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
           }
 
-          if (frame.stack_chunk == 0 || (frame.stack_chunk == 0 ? 0 : stack_chunk_frozen(frame.stack_chunk)) ) {
+          if (stack_chunk == 0 || (stack_chunk == 0 ? 0 : stack_chunk_frozen(stack_chunk)) ) {
             rb_previous_stack_chunk = rb_stack_chunk;
             rb_gc_register_address(&rb_stack_chunk);
             stack_chunk_instantiated = 1;
 
-            frame.stack_chunk = create_stack_chunk_from_context(&stack_chunk_reference,&rb_stack_chunk);
+            rb_stack_chunk = rb_stack_chunk_create(Qnil);
+            frame.thread_data->rb_stack_chunk = rb_stack_chunk;
+
+            rb_ivar_set(rb_stack_chunk, #{intern_num :_parent_stack_chunk}, rb_previous_stack_chunk);
+
+            Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
           }
 
 
           #{@locals_struct} *plocals;
 
-          int previous_stack_position = stack_chunk_get_current_position(frame.stack_chunk);
+          int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
 
-          plocals = (typeof(plocals))stack_chunk_alloc(frame.stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
+          plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
           frame.plocals = plocals;
           plocals->active = Qtrue;
           plocals->pframe = LONG2FIX(&frame);
@@ -1530,20 +1490,15 @@ module FastRuby
           if (aux != 0) {
             plocals->active = Qfalse;
 
-            stack_chunk_set_current_position(frame.stack_chunk, previous_stack_position);
+            stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
             if (stack_chunk_instantiated) {
               rb_gc_unregister_address(&rb_stack_chunk);
-              stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
+              frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
             }
 
-            if (pframe->target_frame != pframe) {
-              // raise exception
-              ((typeof(pframe))_parent_frame)->exception = pframe->exception;
-              ((typeof(pframe))_parent_frame)->target_frame = pframe->target_frame;
-              ((typeof(pframe))_parent_frame)->return_value = pframe->return_value;
-
-              longjmp(((typeof(pframe))_parent_frame)->jmp,1);
+            if (pframe->targetted == 0) {
+              longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
             }
 
             return plocals->return_value;
@@ -1565,11 +1520,11 @@ module FastRuby
           }
 
           VALUE __ret = #{to_c impl_tree};
-          stack_chunk_set_current_position(frame.stack_chunk, previous_stack_position);
+          stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
           if (stack_chunk_instantiated) {
             rb_gc_unregister_address(&rb_stack_chunk);
-            stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
+            frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
           }
 
           plocals->active = Qfalse;
@@ -1711,14 +1666,25 @@ module FastRuby
         resbody_tree = tree[2]
         else_tree = tree[3]
 
-        frame(to_c(tree[1])+";","
-          if (CLASS_OF(frame.exception) == #{to_c(resbody_tree[1][1])})
-          {
-            // trap exception
-            ;original_frame->target_frame = &frame;
-             #{to_c(resbody_tree[2])};
+        trapcode = "rb_eException";
+        if resbody_tree[1][1]
+          trapcode = to_c(resbody_tree[1][1])
+        end
+
+        frame_call(
+          frame(to_c(tree[1])+";","
+          if (aux == FASTRUBY_TAG_RAISE) {
+            if (rb_obj_is_kind_of(frame.thread_data->exception,#{trapcode}) == Qtrue)
+            {
+              // trap exception
+              frame.targetted = 1;
+
+               #{to_c(resbody_tree[2])};
+            }
           }
           ", else_tree ? to_c(else_tree) : nil, 1)
+
+          )
       end
     end
 
@@ -1746,9 +1712,8 @@ module FastRuby
         args = tree[3]
 
         return inline_block("
-            pframe->target_frame = (void*)-1;
-            pframe->exception = rb_funcall(#{to_c args[1]}, #{intern_num :exception},0);
-            longjmp(pframe->jmp, 1);
+            pframe->thread_data->exception = rb_funcall(#{to_c args[1]}, #{intern_num :exception},0);
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
             return Qnil;
             ")
       end
@@ -1874,34 +1839,37 @@ module FastRuby
             typeof(&frame) pframe = &frame;
             #{@locals_struct} *plocals;
 
-            frame.stack_chunk = 0;
             frame.parent_frame = 0;
             frame.return_value = Qnil;
-            frame.target_frame = &frame;
-            frame.exception = Qnil;
             frame.rescue = 0;
+            frame.targetted = 0;
+            frame.thread_data = rb_current_thread_data();
 
             int stack_chunk_instantiated = 0;
             VALUE rb_previous_stack_chunk = Qnil;
-            VALUE current_thread = rb_thread_current();
-            VALUE rb_stack_chunk = Qnil;
-            struct STACKCHUNKREFERENCE* stack_chunk_reference = 0;
+            VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
+            struct STACKCHUNK* stack_chunk = 0;
 
-            if (frame.stack_chunk == 0) {
-              frame.stack_chunk = get_stack_chunk_from_context(&stack_chunk_reference,&rb_stack_chunk);
+            if (rb_stack_chunk != Qnil) {
+              Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
             }
 
-            if (frame.stack_chunk == 0 || (frame.stack_chunk == 0 ? 0 : stack_chunk_frozen(frame.stack_chunk)) ) {
+            if (stack_chunk == 0 || (stack_chunk == 0 ? 0 : stack_chunk_frozen(stack_chunk)) ) {
               rb_previous_stack_chunk = rb_stack_chunk;
               rb_gc_register_address(&rb_stack_chunk);
               stack_chunk_instantiated = 1;
 
-              frame.stack_chunk = create_stack_chunk_from_context(&stack_chunk_reference,&rb_stack_chunk);
+              rb_stack_chunk = rb_stack_chunk_create(Qnil);
+              frame.thread_data->rb_stack_chunk = rb_stack_chunk;
+
+              rb_ivar_set(rb_stack_chunk, #{intern_num :_parent_stack_chunk}, rb_previous_stack_chunk);
+
+              Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
             }
 
-            int previous_stack_position = stack_chunk_get_current_position(frame.stack_chunk);
+            int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
 
-            plocals = (typeof(plocals))stack_chunk_alloc(frame.stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
+            plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
 
             frame.plocals = plocals;
             plocals->active = Qtrue;
@@ -1910,11 +1878,11 @@ module FastRuby
 
             #{to_c tree};
 
-            stack_chunk_set_current_position(frame.stack_chunk, previous_stack_position);
+            stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
             if (stack_chunk_instantiated) {
               rb_gc_unregister_address(&rb_stack_chunk);
-              stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
+              frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
             }
 
             plocals->active = Qfalse;
@@ -1978,6 +1946,13 @@ module FastRuby
       end
     end
 
+    def to_c_for(tree)
+      alter_tree = tree.dup
+      alter_tree[0] = :iter
+      alter_tree[1] = [:call, alter_tree[1], :each, [:arglist]]
+      to_c alter_tree
+    end
+
     def to_c_while(tree)
       inline_block("
           while (#{to_c tree[1]}) {
@@ -2101,36 +2076,6 @@ module FastRuby
     end
 
     def protected_block(inner_code, always_rescue = false,repass_var = nil, nolocals = false)
-      wrapper_code = "
-         if (pframe->last_error != Qnil) {
-              if (CLASS_OF(pframe->last_error)==#{literal_value FastRuby::Context::UnwindFastrubyFrame}) {
-                #{@frame_struct} *pframe = (void*)param;
-
-                pframe->target_frame = (void*)FIX2LONG(rb_ivar_get(pframe->last_error, #{intern_num :@target_frame}));
-                pframe->exception = rb_ivar_get(pframe->last_error, #{intern_num :@ex});
-                pframe->return_value = rb_ivar_get(pframe->last_error, #{intern_num :@return_value});
-
-                longjmp(pframe->jmp, 1);
-                return Qnil;
-
-              } else {
-
-                // raise emulation
-                  #{@frame_struct} *pframe = (void*)param;
-                  pframe->target_frame = (void*)-1;
-                  pframe->exception = pframe->last_error;
-                  longjmp(pframe->jmp, 1);
-                  return Qnil;
-              }
-
-          } else {
-             if (pframe->target_frame != pframe) {
-               longjmp(pframe->jmp, 1);
-             }
-          }
-      "
-
-
       body = nil
       rescue_args = nil
       if repass_var
@@ -2143,12 +2088,12 @@ module FastRuby
             typeof(frame)* parent_frame = ((typeof(pframe))((void**)param)[0]);
 
             frame.parent_frame = 0;
-            frame.target_frame = 0;
             frame.return_value = Qnil;
-            frame.exception = Qnil;
             frame.rescue = 0;
             frame.last_error = Qnil;
-            frame.stack_chunk = 0;
+            frame.targetted = 0;
+            frame.thread_data = parent_frame->thread_data;
+            if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
             pframe = &frame;
 
@@ -2158,12 +2103,14 @@ module FastRuby
             "
             }
 
-            if (setjmp(frame.jmp) != 0) {
-              parent_frame->target_frame = frame.target_frame;
-              parent_frame->exception = frame.exception;
-              parent_frame->return_value = frame.return_value;
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
 
-              return frame.return_value;
+              if (frame.targetted == 1) {
+                return frame.return_value;
+              } else {
+                rb_jump_tag(aux);
+              }
             }
 
             VALUE #{repass_var} = (VALUE)((void**)param)[1];
@@ -2184,12 +2131,12 @@ module FastRuby
             typeof(frame)* parent_frame = (typeof(pframe))param;
 
             frame.parent_frame = 0;
-            frame.target_frame = 0;
             frame.return_value = Qnil;
-            frame.exception = Qnil;
             frame.rescue = 0;
             frame.last_error = Qnil;
-            frame.stack_chunk = 0;
+            frame.targetted = 0;
+            frame.thread_data = parent_frame->thread_data;
+            if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
             pframe = &frame;
 
@@ -2199,12 +2146,14 @@ module FastRuby
             "
             }
 
-            if (setjmp(frame.jmp) != 0) {
-              parent_frame->target_frame = frame.target_frame;
-              parent_frame->exception = frame.exception;
-              parent_frame->return_value = frame.return_value;
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
 
-              return frame.return_value;
+              if (frame.targetted == 1) {
+                return frame.return_value;
+              } else {
+                rb_jump_tag(aux);
+              }
             }
 
             return #{inner_code};
@@ -2215,18 +2164,30 @@ module FastRuby
         rescue_args = "(VALUE)pframe"
       end
 
-      rescue_code = "rb_rescue2(#{body},#{rescue_args},#{anonymous_function{|name| "
-        static VALUE #{name}(VALUE param, VALUE error) {
-            #{@frame_struct} *pframe = (void*)param;
-            pframe->last_error = error;
+      wrapper_code = "        if (state != 0) {
+          if (state < 0x80) {
+
+            if (state == TAG_RAISE) {
+                // raise emulation
+                pframe->thread_data->exception = rb_eval_string(\"$!\");
+                longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+                return Qnil;
+            } else {
+              rb_jump_tag(state);
+            }
+          } else {
+            longjmp(pframe->jmp, state);
           }
-      "}}
-      ,(VALUE)pframe, rb_eException,(VALUE)0)"
+
+        }
+        "
+
+      rescue_code = "rb_protect(#{body},#{rescue_args},&state)"
 
       if always_rescue
         inline_block "
+          int state;
           pframe->last_error = Qnil;
-          pframe->target_frame = pframe;
           VALUE result = #{rescue_code};
 
           #{wrapper_code}
@@ -2236,23 +2197,21 @@ module FastRuby
       else
         inline_block "
           VALUE result;
+          int state;
           pframe->last_error = Qnil;
 
           if (pframe->rescue) {
             result = #{rescue_code};
+            #{wrapper_code}
           } else {
             return #{inner_code};
           }
 
-          #{wrapper_code}
-
           return result;
         ", repass_var, nolocals
       end
-
     end
 
-
     def func_frame
       "
         #{@locals_struct} *plocals = malloc(sizeof(typeof(*plocals)));
@@ -2261,11 +2220,11 @@ module FastRuby
 
         frame.plocals = plocals;
         frame.parent_frame = (void*)_parent_frame;
-        frame.stack_chunk = ((typeof(pframe))_parent_frame)->stack_chunk;
         frame.return_value = Qnil;
-        frame.target_frame = &frame;
-        frame.exception = Qnil;
         frame.rescue = 0;
+        frame.targetted = 0;
+        frame.thread_data = ((typeof(pframe))_parent_frame)->thread_data;
+        if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
         plocals->pframe = LONG2FIX(&frame);
 
@@ -2277,12 +2236,8 @@ module FastRuby
         int aux = setjmp(pframe->jmp);
         if (aux != 0) {
 
-          if (pframe->target_frame != pframe) {
-            // raise exception
-            ((typeof(pframe))_parent_frame)->exception = pframe->exception;
-            ((typeof(pframe))_parent_frame)->target_frame = pframe->target_frame;
-            ((typeof(pframe))_parent_frame)->return_value = pframe->return_value;
-            longjmp(((typeof(pframe))_parent_frame)->jmp,1);
+          if (pframe->targetted == 0) {
+            longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
           }
 
           return plocals->return_value;
@@ -2547,12 +2502,12 @@ module FastRuby
 
           parent_frame = (void*)param;
 
-          frame.stack_chunk = parent_frame->stack_chunk;
           frame.parent_frame = (void*)param;
           frame.plocals = parent_frame->plocals;
-          frame.target_frame = &frame;
-          frame.exception = Qnil;
           frame.rescue = #{rescued ? rescued : "parent_frame->rescue"};
+          frame.targetted = 0;
+          frame.thread_data = parent_frame->thread_data;
+          if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
           plocals = frame.plocals;
           pframe = &frame;
@@ -2567,12 +2522,8 @@ module FastRuby
 
             #{jmp_code};
 
-            if (original_frame->target_frame != original_frame) {
-              pframe->exception = original_frame->exception;
-              pframe->target_frame = original_frame->target_frame;
-              pframe->return_value = original_frame->return_value;
-
-              longjmp(pframe->jmp,1);
+            if (original_frame->targetted == 0) {
+              longjmp(pframe->jmp,aux);
             }
 
             return last_expression;