fastruby 0.0.3 → 0.0.4

data/lib/fastruby/translator.rb

@@ -26,6 +26,14 @@ require "fastruby/method_extension"
 module FastRuby
   class Context
 
+    class UnwindFastrubyFrame < Exception
+      def initialize(ex,target_frame,return_value)
+        @ex = ex
+        @target_frame = target_frame
+        @return_value = return_value
+      end
+    end
+
     attr_accessor :infer_lvar_map
     attr_accessor :alt_method_name
     attr_accessor :locals
@@ -34,32 +42,48 @@ module FastRuby
     attr_reader :extra_code
     attr_reader :yield_signature
 
-    def initialize
+    def initialize(common_func = true)
       @infer_lvar_map = Hash.new
       @extra_code = ""
       @options = {}
+      @frame_struct = "struct {
+        void* parent_frame;
+        void* target_frame;
+        void* plocals;
+        jmp_buf jmp;
+        VALUE return_value;
+        VALUE exception;
+        int rescue;
+        VALUE last_error;
+      }"
+
+      @block_struct = "struct {
+        void* block_function_address;
+        void* block_function_param;
+      }"
 
       extra_code << '#include "node.h"
       '
 
-      extra_code << "static VALUE _rb_gvar_set(void* ge,VALUE value) {
-        rb_gvar_set((struct global_entry*)ge,value);
-        return value;
-      }
-      "
-
-      extra_code << "static VALUE _rb_ivar_set(VALUE recv,ID idvar, VALUE value) {
-        rb_ivar_set(recv,idvar,value);
-        return value;
-      }
-      "
+      if common_func
+        extra_code << "static VALUE _rb_gvar_set(void* ge,VALUE value) {
+          rb_gvar_set((struct global_entry*)ge,value);
+          return value;
+        }
+        "
 
-      extra_code << "static VALUE _lvar_assing(VALUE* destination,VALUE value) {
-        *destination = value;
-        return value;
-      }
-      "
+        extra_code << "static VALUE _rb_ivar_set(VALUE recv,ID idvar, VALUE value) {
+          rb_ivar_set(recv,idvar,value);
+          return value;
+        }
+        "
 
+        extra_code << "static VALUE _lvar_assing(VALUE* destination,VALUE value) {
+          *destination = value;
+          return value;
+        }
+        "
+      end
     end
 
     def on_block
@@ -71,10 +95,10 @@ module FastRuby
       send("to_c_" + tree[0].to_s, tree);
     end
 
-    def anonymous_function(method)
+    def anonymous_function
 
       name = "anonymous" + rand(10000000).to_s
-      extra_code << method.call(name)
+      extra_code << yield(name)
 
       name
     end
@@ -105,9 +129,6 @@ module FastRuby
 
       caller_code = nil
 
-      str_lvar_initialization = @locals_struct + " *plocals;
-                                plocals = (void*)param;"
-
       recvtype = infer_type(recv_tree || s(:self))
 
       address = nil
@@ -179,14 +200,19 @@ module FastRuby
 
       anonymous_impl = tree[3]
 
-      str_lvar_initialization = @locals_struct + " *plocals;
-                                  plocals = (void*)param;"
+      str_lvar_initialization = "#{@frame_struct} *pframe;
+                                 #{@locals_struct} *plocals;
+                                pframe = (void*)param;
+                                plocals = (void*)pframe->plocals;
+                                "
 
       str_arg_initialization = ""
 
       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
             if anonymous_impl[0] == :block
@@ -209,7 +235,7 @@ module FastRuby
           else
             str_impl = "last_expression = Qnil;"
           end
-
+        end
       end
 
       if convention == :ruby or convention == :cruby
@@ -260,11 +286,44 @@ module FastRuby
         str_arg_initialization
 
         block_code = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE param) {
+          static VALUE #{name}(VALUE arg, VALUE _parent_frame) {
             // block for call to #{call_tree[2]}
             VALUE last_expression = Qnil;
 
-            #{str_lvar_initialization};
+            #{@frame_struct} frame;
+            #{@frame_struct} *pframe = (void*)&frame;
+            #{@frame_struct} *parent_frame = (void*)_parent_frame;
+            #{@locals_struct} *plocals;
+
+            frame.plocals = parent_frame->plocals;
+            frame.parent_frame = parent_frame;
+            frame.return_value = Qnil;
+            frame.target_frame = &frame;
+            frame.exception = Qnil;
+            frame.rescue = 0;
+
+            plocals = frame.plocals;
+
+            if (setjmp(frame.jmp) != 0) {
+              if (pframe->target_frame != pframe) {
+                if (pframe->target_frame == (void*)-3) {
+                   return pframe->return_value;
+                }
+
+                VALUE ex = rb_funcall(
+                        (VALUE)#{UnwindFastrubyFrame.internal_value},
+                        #{:new.to_i},
+                        3,
+                        pframe->exception,
+                        LONG2FIX(pframe->target_frame),
+                        pframe->return_value
+                        );
+                rb_funcall(plocals->self, #{:raise.to_i}, 1, ex);
+              }
+              return frame.return_value;
+            }
+
+
             #{str_arg_initialization}
             #{str_impl}
 
@@ -273,7 +332,8 @@ module FastRuby
         "
         }
 
-        "rb_iterate(#{anonymous_function(caller_code)}, (VALUE)#{locals_pointer}, #{anonymous_function(block_code)}, (VALUE)#{locals_pointer})"
+        protected_block("rb_iterate(#{anonymous_function(&caller_code)}, (VALUE)pframe, #{anonymous_function(&block_code)}, (VALUE)pframe)", true)
+
       elsif convention == :fastruby
 
         str_arg_initialization = ""
@@ -291,11 +351,37 @@ module FastRuby
         end
 
         block_code = proc { |name| "
-          static VALUE #{name}(int argc, VALUE* argv, VALUE param) {
+          static VALUE #{name}(int argc, VALUE* argv, VALUE _locals, VALUE _parent_frame) {
             // block for call to #{call_tree[2]}
             VALUE last_expression = Qnil;
+            #{@frame_struct} frame;
+            #{@frame_struct} *pframe = (void*)&frame;
+            #{@frame_struct} *parent_frame = (void*)_parent_frame;
+            #{@locals_struct} *plocals;
+
+            frame.plocals = (void*)_locals;
+            frame.parent_frame = parent_frame;
+            frame.return_value = Qnil;
+            frame.target_frame = &frame;
+            frame.exception = Qnil;
+            frame.rescue = 0;
+
+            plocals = frame.plocals;
+
+            if (setjmp(frame.jmp) != 0) {
+                if (pframe->target_frame != pframe) {
+                  if (pframe->target_frame == (void*)-3) {
+                     return pframe->return_value;
+                  }
+                  // 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);
+                }
+
+            }
 
-            #{str_lvar_initialization};
             #{str_arg_initialization}
             #{str_impl}
 
@@ -313,59 +399,60 @@ module FastRuby
 
         if call_args_tree.size > 1
           value_cast = ( ["VALUE"]*(call_tree[3].size) ).join(",")
-          value_cast = value_cast + ", VALUE" if convention == :fastruby
+          value_cast = value_cast + ", VALUE, VALUE" if convention == :fastruby
 
           str_called_code_args = call_tree[3][1..-1].map{|subtree| to_c subtree}.join(",")
 
             caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param) {
+              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_address = (void*)#{anonymous_function(&block_code)};
                 block.block_function_param = (void*)param;
 
                 // call to #{call_tree[2]}
 
-                #{str_lvar_initialization}
-
-                return ((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{str_recv}, (VALUE)&block, #{str_called_code_args});
+                return ((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{str_recv}, (VALUE)&block, (VALUE)pframe, #{str_called_code_args});
               }
             "
             }
 
         else
             caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param) {
+              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_address = (void*)#{anonymous_function(&block_code)};
                 block.block_function_param = (void*)param;
 
                 // call to #{call_tree[2]}
-                #{str_lvar_initialization}
 
-                return ((VALUE(*)(VALUE,VALUE))0x#{address.to_s(16)})(#{str_recv}, (VALUE)&block);
+                return ((VALUE(*)(VALUE,VALUE,VALUE))0x#{address.to_s(16)})(#{str_recv}, (VALUE)&block, (VALUE)pframe);
               }
             "
             }
         end
 
-        "#{anonymous_function(caller_code)}((VALUE)#{locals_pointer})"
+        "#{anonymous_function(&caller_code)}((VALUE)plocals, (VALUE)pframe)"
       end
     end
 
     def to_c_yield(tree)
 
       block_code = proc { |name| "
-        static VALUE #{name}(VALUE locals_param, VALUE* block_args) {
+        static VALUE #{name}(VALUE frame_param, VALUE* block_args) {
 
           #{@locals_struct} *plocals;
-          plocals = (void*)locals_param;
+          #{@frame_struct} *pframe;
+          pframe = (void*)frame_param;
+          plocals = (void*)pframe->plocals;
 
           if (plocals->block_function_address == 0) {
             rb_raise(rb_eLocalJumpError, \"no block given\");
           } else {
-            return ((VALUE(*)(int,VALUE*,VALUE))plocals->block_function_address)(#{tree.size-1}, block_args, plocals->block_function_param);
+            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))plocals->block_function_address)(#{tree.size-1}, block_args, plocals->block_function_param, (VALUE)pframe);
           }
         }
       "
@@ -388,9 +475,9 @@ module FastRuby
       end
 
       if tree.size > 1
-        anonymous_function(block_code)+"((VALUE)#{locals_pointer}, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}})"
+        anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}})"
       else
-        anonymous_function(block_code)+"((VALUE)#{locals_pointer}, (VALUE[]){})"
+        anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){})"
       end
     end
 
@@ -416,7 +503,41 @@ module FastRuby
     end
 
     def to_c_return(tree)
-      "return #{to_c(tree[1])};\n"
+      "pframe->target_frame = ((typeof(pframe))plocals->pframe); plocals->return_value = #{to_c(tree[1])}; longjmp(pframe->jmp, 1);\n"
+    end
+
+    def to_c_break(tree)
+      if @on_block
+        inline_block(
+         "
+         pframe->target_frame = (void*)-2;
+         pframe->return_value = #{tree[1] ? to_c(tree[1]) : "Qnil"};
+         pframe->exception = Qnil;
+         longjmp(pframe->jmp,1);"
+         )
+      else
+        inline_block("
+            pframe->target_frame = (void*)-1;
+            pframe->exception = (VALUE)#{LocalJumpError.exception.internal_value};
+            longjmp(pframe->jmp,1);
+            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)"
+      else
+        inline_block("
+            pframe->target_frame = (void*)-1;
+            pframe->exception = (VALUE)#{LocalJumpError.exception.internal_value};
+            longjmp(pframe->jmp,1);
+            return Qnil;
+            ")
+
+      end
     end
 
     def to_c_lit(tree)
@@ -440,16 +561,18 @@ module FastRuby
         hash_aset_code << "rb_hash_aset(hash, #{strkey}, #{strvalue});"
       end
 
-      wrapper_func = proc { |name| "
+      anonymous_function{ |name| "
         static VALUE #{name}(VALUE value_params) {
-          #{@locals_struct} *plocals = (void*)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;
         }
-      " }
-
-      anonymous_function(wrapper_func) + "((VALUE)#{locals_pointer})"
+      " } + "((VALUE)pframe)"
     end
 
     def to_c_array(tree)
@@ -506,54 +629,178 @@ module FastRuby
       "rb_funcall(plocals->self,#{:fastruby.to_i},1,(VALUE)#{tree.internal_value})"
     end
 
-    def to_c_method(tree)
-      method_name = tree[1]
-      args_tree = tree[2]
+    def to_c_defs(tree)
+      args_tree = tree[3];
 
-      impl_tree = tree[3][1]
+      tmp = FastRuby.build_defs(tree)
+
+      extra_code << tmp[0]
 
+      inline_block "
+        rb_define_singleton_method(#{to_c tree[1]}, \"#{tree[2].to_s}\", (void*)#{tmp[1]}, #{args_tree.size-1});
+        return Qnil;
+        "
+    end
+
+    def to_c_defined(tree)
+      nt = tree[1].node_type
+
+      if nt == :self
+      'rb_str_new2("self")'
+      elsif nt == :true
+      'rb_str_new2("true")'
+      elsif nt == :false
+      'rb_str_new2("false")'
+      elsif nt == :nil
+      'rb_str_new2("nil")'
+      elsif nt == :lvar
+      'rb_str_new2("local-variable")'
+      elsif nt == :gvar
+      "rb_gvar_defined((struct global_entry*)0x#{global_entry(tree[1][1]).to_s(16)}) ? #{"global-variable".internal_value} : Qnil"
+      elsif nt == :const
+      "rb_const_defined(rb_cObject, #{tree[1][1].to_i}) ? #{"constant".internal_value} : Qnil"
+      elsif nt == :call
+      "rb_method_node(CLASS_OF(#{to_c tree[1][1]}), #{tree[1][2].to_i}) ? #{"method".internal_value} : Qnil"
+      elsif nt == :yield
+        "rb_block_given_p() ? #{"yield".internal_value} : Qnil"
+      elsif nt == :ivar
+      "rb_ivar_defined(plocals->self,#{tree[1][1].to_i}) ? #{"instance-variable".internal_value} : Qnil"
+      elsif nt == :attrset or
+            nt == :op_asgn1 or
+            nt == :op_asgn2 or
+            nt == :op_asgn_or or
+            nt == :op_asgn_and or
+            nt == :op_asgn_masgn or
+            nt == :masgn or
+            nt == :lasgn or
+            nt == :dasgn or
+            nt == :dasgn_curr or
+            nt == :gasgn or
+            nt == :iasgn or
+            nt == :cdecl or
+            nt == :cvdecl or
+            nt == :cvasgn
+        "assignment".internal_value
+      else
+        "expression".internal_value
+      end
+    end
+
+    def initialize_method_structs(args_tree)
       @locals_struct = "struct {
-        #{@locals.map{|l| "VALUE #{l};\n"}.join}
-        #{args_tree[1..-1].map{|arg| "VALUE #{arg};\n"}.join};
         void* block_function_address;
         VALUE block_function_param;
+        jmp_buf jmp;
+        VALUE return_value;
+        void* pframe;
+        #{@locals.map{|l| "VALUE #{l};\n"}.join}
+        #{args_tree[1..-1].map{|arg| "VALUE #{arg};\n"}.join};
         }"
+    end
 
-      @block_struct = "struct {
-        void* block_function_address;
-        void* block_function_param;
+    def to_c_method_defs(tree)
+
+      method_name = tree[2]
+      args_tree = tree[3]
+
+      impl_tree = tree[4][1]
+
+      initialize_method_structs(args_tree)
+
+      strargs = if args_tree.size > 1
+        "VALUE self, void* block_address, VALUE block_param, void* _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
+      else
+        "VALUE self, void* block_address, VALUE block_param, void* _parent_frame"
+      end
+
+      extra_code << "static VALUE #{@alt_method_name + "_real"}(#{strargs}) {
+        #{func_frame}
+
+        #{args_tree[1..-1].map { |arg|
+          "locals.#{arg} = #{arg};\n"
+        }.join("") }
+
+        locals.block_function_address = block_address;
+        locals.block_function_param = block_param;
+
+        return #{to_c impl_tree};
       }"
 
-      str_impl = ""
-      # if impl_tree is a block, implement the last node with a return
-      if impl_tree[0] == :block
-        str_impl = to_c impl_tree
+      strargs2 = if args_tree.size > 1
+        "VALUE self, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
       else
-        if impl_tree[0] != :return
-          str_impl = str_impl + ";last_expression = #{to_c(impl_tree)};"
-        else
-          str_impl = str_impl + ";#{to_c(impl_tree)};"
-        end
+        "VALUE self"
+      end
+
+      value_cast = ( ["VALUE"]*(args_tree.size+1) ).join(",")
+      strmethodargs = ""
+
+      if args_tree.size > 1
+        strmethodargs = "self,block_address,block_param,&frame,#{args_tree[1..-1].map(&:to_s).join(",") }"
+      else
+        strmethodargs = "self,block_address,block_param,&frame"
       end
 
+      "
+      VALUE #{@alt_method_name}(#{strargs2}) {
+          #{@frame_struct} frame;
+          int argc = #{args_tree.size};
+          void* block_address = 0;
+          VALUE block_param = Qnil;
+
+
+          frame.plocals = 0;
+          frame.parent_frame = 0;
+          frame.return_value = Qnil;
+          frame.target_frame = &frame;
+          frame.exception = Qnil;
+          frame.rescue = 0;
+
+          if (rb_block_given_p()) {
+            block_address = #{
+              anonymous_function{|name|
+              "static VALUE #{name}(int argc, VALUE* argv, VALUE param) {
+                return rb_yield_splat(rb_ary_new4(argc,argv));
+              }"
+              }
+            };
+
+            block_param = 0;
+          }
+
+          int aux = setjmp(frame.jmp);
+          if (aux != 0) {
+            rb_funcall(self, #{:raise.to_i}, 1, frame.exception);
+          }
+
+
+          return #{@alt_method_name + "_real"}(#{strmethodargs});
+      }
+      "
+    end
+
+    def to_c_method(tree)
+      method_name = tree[1]
+      args_tree = tree[2]
+
+      impl_tree = tree[3][1]
+
+      initialize_method_structs(args_tree)
+
       strargs = if args_tree.size > 1
-        "VALUE block, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
+        "VALUE block, VALUE _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
       else
-        "VALUE block"
+        "VALUE block, VALUE _parent_frame"
       end
 
       "VALUE #{@alt_method_name || method_name}(#{strargs}) {
-        #{@locals_struct} locals;
-        #{@locals_struct} *plocals = (void*)&locals;
-        #{@block_struct} *pblock;
-        VALUE last_expression = Qnil;
+
+        #{func_frame}
 
         #{args_tree[1..-1].map { |arg|
           "locals.#{arg} = #{arg};\n"
         }.join("") }
 
-        locals.self = self;
-
         pblock = (void*)block;
         if (pblock) {
           locals.block_function_address = pblock->block_function_address;
@@ -563,7 +810,7 @@ module FastRuby
           locals.block_function_param = Qnil;
         }
 
-        return #{str_impl};
+        return #{to_c impl_tree};
       }"
     end
 
@@ -571,10 +818,6 @@ module FastRuby
       "plocals->"
     end
 
-    def locals_pointer
-      "plocals"
-    end
-
     def to_c_gvar(tree)
       "rb_gvar_get((struct global_entry*)0x#{global_entry(tree[1]).to_s(16)})"
     end
@@ -632,7 +875,7 @@ module FastRuby
           }
 
 
-          "_lvar_assing(&#{locals_accessor}#{tree[1]}, #{anonymous_function(verify_type_function)}(#{to_c tree[2]}))"
+          "_lvar_assing(&#{locals_accessor}#{tree[1]}, #{anonymous_function(&verify_type_function)}(#{to_c tree[2]}))"
         else
           "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
         end
@@ -688,16 +931,67 @@ module FastRuby
       "
     end
 
-    def to_c_call(tree)
-      recv = tree[1]
-      mname = tree[2]
-      args = tree[3]
+    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 = 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])};
+          }
+          ", else_tree ? to_c(else_tree) : nil, 1)
+      end
+    end
+
+    def to_c_ensure(tree)
+      if tree.size == 2
+        to_c tree[1]
+      else
+        ensured_code = to_c tree[2]
+        inline_block "
+          #{frame(to_c(tree[1]),ensured_code,ensured_code,1)};
+        "
+      end
+    end
 
+    def to_c_call(tree)
       directive_code = directive(tree)
       if directive_code
         return directive_code
       end
 
+      if tree[2] == :require
+        tree[2] = :fastruby_require
+      elsif tree[2] == :raise
+        # raise code
+        args = tree[3]
+
+        return inline_block("
+            pframe->target_frame = (void*)-1;
+            pframe->exception = rb_funcall(#{to_c args[1]}, #{:exception.to_i},0);
+            longjmp(pframe->jmp, 1);
+            return Qnil;
+            ")
+      end
+
+      recv = tree[1]
+      mname = tree[2]
+      args = tree[3]
+
+      mname = :require_fastruby if mname == :require
+
       strargs = args[1..-1].map{|arg| to_c arg}.join(",")
 
       argnum = args.size - 1
@@ -745,8 +1039,12 @@ module FastRuby
           convention = :cruby
         end
 
-        address = getaddress(mobject)
-        len = getlen(mobject)
+        address = nil
+        len = 0
+        if mobject
+          address = getaddress(mobject)
+          len = getlen(mobject)
+        end
 
         extraargs = ""
         extraargs = ", Qfalse" if convention == :fastruby
@@ -754,10 +1052,10 @@ module FastRuby
         if address then
           if argnum == 0
             value_cast = "VALUE"
-            value_cast = value_cast + ", VALUE" if convention == :fastruby
+            value_cast = value_cast + ", VALUE,VALUE" if convention == :fastruby
 
             if convention == :fastruby
-              "((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{to_c recv}, Qfalse)"
+              "((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{to_c recv}, Qfalse, (VALUE)pframe)"
             else
 
               str_incall_args = nil
@@ -771,28 +1069,28 @@ module FastRuby
                 str_incall_args = "recv"
               end
 
-              wrapper_func = proc { |name| "
-                static VALUE #{name}(VALUE recv) {
-                  // call to #{recvtype}##{mname}
-                  if (rb_block_given_p()) {
-                    // no passing block, recall
-                    return rb_funcall(recv, #{tree[2].to_i}, 0);
-                  } else {
-                    return ((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{str_incall_args});
+              protected_block(
+
+                anonymous_function{ |name| "
+                  static VALUE #{name}(VALUE recv) {
+                    // call to #{recvtype}##{mname}
+                    if (rb_block_given_p()) {
+                      // no passing block, recall
+                      return rb_funcall(recv, #{tree[2].to_i}, 0);
+                    } else {
+                      return ((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{str_incall_args});
+                    }
                   }
-                }
-              " }
-
-              anonymous_function(wrapper_func) + "(#{to_c(recv)})"
-
+                " } + "(#{to_c(recv)})"
+              )
             end
           else
             value_cast = ( ["VALUE"]*(args.size) ).join(",")
-            value_cast = value_cast + ", VALUE" if convention == :fastruby
+            value_cast = value_cast + ", VALUE, VALUE" if convention == :fastruby
 
             wrapper_func = nil
             if convention == :fastruby
-              "((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{to_c recv}, Qfalse, #{strargs})"
+              "((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{strargs})"
             else
 
               str_incall_args = nil
@@ -806,35 +1104,36 @@ module FastRuby
                 str_incall_args = "recv, #{ (1..argnum).map{|x| "_arg"+x.to_s }.join(",")}"
               end
 
-              wrapper_func = proc { |name| "
-                static VALUE #{name}(VALUE recv, #{ (1..argnum).map{|x| "VALUE _arg"+x.to_s }.join(",")} ) {
-                  // call to #{recvtype}##{mname}
-                  if (rb_block_given_p()) {
-                    // no passing block, recall
-                    return rb_funcall(recv, #{tree[2].to_i}, #{argnum}, #{ (1..argnum).map{|x| "_arg"+x.to_s }.join(",")});
-                  } else {
-                    return ((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{str_incall_args});
+              protected_block(
+
+                anonymous_function{ |name| "
+                  static VALUE #{name}(VALUE recv, #{ (1..argnum).map{|x| "VALUE _arg"+x.to_s }.join(",")} ) {
+                    // call to #{recvtype}##{mname}
+                    if (rb_block_given_p()) {
+                      // no passing block, recall
+                      return rb_funcall(recv, #{tree[2].to_i}, #{argnum}, #{ (1..argnum).map{|x| "_arg"+x.to_s }.join(",")});
+                    } else {
+                      return ((VALUE(*)(#{value_cast}))0x#{address.to_s(16)})(#{str_incall_args});
+                    }
                   }
-                }
-              " }
-
-              anonymous_function(wrapper_func) + "(#{to_c(recv)}, #{strargs})"
+                " } + "(#{to_c(recv)}, #{strargs})"
+              )
             end
           end
         else
 
           if argnum == 0
-            "rb_funcall(#{to_c recv}, #{tree[2].to_i}, 0)"
+            protected_block("rb_funcall(#{to_c recv}, #{tree[2].to_i}, 0)")
           else
-            "rb_funcall(#{to_c recv}, #{tree[2].to_i}, #{argnum}, #{strargs} )"
+            protected_block("rb_funcall(#{to_c recv}, #{tree[2].to_i}, #{argnum}, #{strargs} )")
           end
         end
 
       else
         if argnum == 0
-          "rb_funcall(#{to_c recv}, #{tree[2].to_i}, 0)"
+          protected_block("rb_funcall(#{to_c recv}, #{tree[2].to_i}, 0)")
         else
-          "rb_funcall(#{to_c recv}, #{tree[2].to_i}, #{argnum}, #{strargs} )"
+          protected_block("rb_funcall(#{to_c recv}, #{tree[2].to_i}, #{argnum}, #{strargs} )")
         end
       end
     end
@@ -847,6 +1146,13 @@ module FastRuby
 
     end
 
+    def to_c_module(tree)
+      inline_block("
+        rb_funcall(plocals->self,#{:fastruby.to_i},1,(VALUE)#{tree.internal_value});
+        return Qnil;
+      ")
+    end
+
     def to_c_while(tree)
       inline_block("
           while (#{to_c tree[1]}) {
@@ -872,6 +1178,14 @@ module FastRuby
       end
     end
 
+    def on_block
+      old_on_block = @on_block
+      @on_block = true
+      return yield
+    ensure
+      @on_block = old_on_block
+    end
+
     def with_extra_inference(extra_inference)
       previous_infer_lvar_map = @infer_lvar_map
       begin
@@ -900,33 +1214,225 @@ module FastRuby
       elsif mname == :inline_c
         code = args[1][1]
 
-        caller_code = proc { |name| "
+        return anonymous_function{ |name| "
            static VALUE #{name}(VALUE param) {
             #{@locals_struct} *plocals = (void*)param;
             #{code};
             return Qnil;
           }
          "
-        }
-
-        return anonymous_function(caller_code)+"((VALUE)plocals)"
+        }+"((VALUE)plocals)"
       else
         nil
       end
     end
 
+    def inline_block_reference(arg)
+      code = nil
+
+      if arg.instance_of? Sexp
+        code = to_c(arg);
+      else
+        code = arg
+      end
+
+      anonymous_function{ |name| "
+        static VALUE #{name}(VALUE param) {
+          #{@frame_struct} *pframe = (void*)param;
+          #{@locals_struct} *plocals = (void*)pframe->plocals;
+          VALUE last_expression = Qnil;
+
+          #{code};
+          return last_expression;
+          }
+        "
+      }
+    end
+
     def inline_block(code)
-      caller_code = proc { |name| "
+      anonymous_function{ |name| "
         static VALUE #{name}(VALUE param) {
-          #{@locals_struct} *plocals = (void*)param;
+          #{@frame_struct} *pframe = (void*)param;
+          #{@locals_struct} *plocals = (void*)pframe->plocals;
           VALUE last_expression = Qnil;
 
           #{code}
           }
         "
-      }
+      } + "((VALUE)pframe)"
+    end
+
+    def inline_ruby(proced, parameter)
+      "rb_funcall(#{proced.internal_value}, #{:call.to_i}, 1, #{parameter})"
+    end
+
+    def wrapped_break_block(inner_code)
+      frame("return " + inner_code, "
+            if (original_frame->target_frame == (void*)-2) {
+              return pframe->return_value;
+            }
+            ")
+    end
 
-      anonymous_function(caller_code) + "((VALUE)#{locals_pointer})"
+    def protected_block(inner_code, always_rescue = false)
+      wrapper_code = "
+         if (pframe->last_error != Qnil) {
+              if (CLASS_OF(pframe->last_error)==(VALUE)#{UnwindFastrubyFrame.internal_value}) {
+              #{@frame_struct} *pframe = (void*)param;
+
+                pframe->target_frame = (void*)FIX2LONG(rb_ivar_get(pframe->last_error, #{:@target_frame.to_i}));
+                pframe->exception = rb_ivar_get(pframe->last_error, #{:@ex.to_i});
+                pframe->return_value = rb_ivar_get(pframe->last_error, #{:@return_value.to_i});
+
+               if (pframe->target_frame == (void*)-2) {
+                  return pframe->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;
+              }
+
+          }
+      "
+      rescue_code = "rb_rescue2(#{inline_block_reference "return #{inner_code};"},(VALUE)pframe,#{anonymous_function{|name| "
+        static VALUE #{name}(VALUE param, VALUE error) {
+            #{@frame_struct} *pframe = (void*)param;
+            pframe->last_error = error;
+          }
+      "}}
+      ,(VALUE)pframe, rb_eException,(VALUE)0)"
+
+      if always_rescue
+        inline_block "
+          pframe->last_error = Qnil;
+          VALUE result = #{rescue_code};
+
+          #{wrapper_code}
+
+          return result;
+        "
+      else
+        inline_block "
+          VALUE result;
+          pframe->last_error = Qnil;
+
+          if (pframe->rescue) {
+            result = #{rescue_code};
+          } else {
+            return #{inner_code};
+          }
+
+          #{wrapper_code}
+
+          return result;
+        "
+      end
+
+    end
+
+
+    def func_frame
+      "
+        #{@locals_struct} locals;
+        #{@locals_struct} *plocals = (void*)&locals;
+        #{@frame_struct} frame;
+        #{@frame_struct} *pframe;
+
+        frame.plocals = plocals;
+        frame.parent_frame = (void*)_parent_frame;
+        frame.return_value = Qnil;
+        frame.target_frame = &frame;
+        frame.exception = Qnil;
+        frame.rescue = 0;
+
+        locals.pframe = &frame;
+
+        pframe = (void*)&frame;
+
+        #{@block_struct} *pblock;
+        VALUE last_expression = Qnil;
+
+        int aux = setjmp(pframe->jmp);
+        if (aux != 0) {
+
+          if (pframe->target_frame == (void*)-2) {
+            return pframe->return_value;
+          }
+
+          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);
+          }
+
+          return plocals->return_value;
+        }
+
+        locals.self = self;
+      "
+    end
+
+    def frame(code, jmp_code, not_jmp_code = "", rescued = nil)
+
+      anonymous_function{ |name| "
+        static VALUE #{name}(VALUE param) {
+          VALUE last_expression;
+          #{@frame_struct} frame, *pframe, *parent_frame;
+          #{@locals_struct} *plocals;
+
+          parent_frame = (void*)param;
+
+          frame.parent_frame = (void*)param;
+          frame.plocals = parent_frame->plocals;
+          frame.target_frame = &frame;
+          frame.rescue = #{rescued ? rescued : "parent_frame->rescue"};
+
+          plocals = frame.plocals;
+          pframe = &frame;
+
+          int aux = setjmp(frame.jmp);
+          if (aux != 0) {
+            last_expression = pframe->return_value;
+
+            // restore previous frame
+            typeof(pframe) original_frame = pframe;
+            pframe = parent_frame;
+
+            #{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);
+            }
+
+            return last_expression;
+          }
+
+          #{code};
+
+          // restore previous frame
+          typeof(pframe) original_frame = pframe;
+          pframe = parent_frame;
+          #{not_jmp_code};
+
+          return last_expression;
+
+          }
+        "
+      } + "((VALUE)pframe)"
     end
 
     inline :C  do |builder|