fastruby 0.0.19 → 0.0.20

data/lib/fastruby/translator/translator.rb~

@@ -0,0 +1,1600 @@
+=begin
+
+This file is part of the fastruby project, http://github.com/tario/fastruby
+
+Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+fastruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+fastruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with fastruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "set"
+require "rubygems"
+require "sexp"
+require "fastruby/method_extension"
+require "fastruby/set_tree"
+require "fastruby/exceptions"
+require "fastruby/translator/translator_modules"
+require "fastruby/translator/scope_mode_helper"
+require "fastruby/modules"
+require "define_method_handler"
+require "base64"
+
+module FastRuby
+  class Context
+    attr_accessor :locals
+    attr_accessor :options
+    attr_reader :no_cache
+    attr_reader :init_extra
+    attr_reader :extra_code
+    
+    class Value
+      attr_accessor :value
+      def initialize(v); @value = v; end
+    end
+    
+    def self.define_translator_for(ntype, options = {}, &blk)
+      condition_blk = proc do |*x|
+        tree = x.first; tree.node_type == ntype
+      end
+      
+      if options[:arity]
+        if options[:arity] == 1
+          condition_blk = proc do |*x|
+            tree = x.first; x.size == 1 and tree.node_type == ntype
+          end
+        end
+      end
+      
+      define_method_handler(:to_c, options, &blk).condition &condition_blk
+    end
+
+    define_method_handler(:to_c, :priority => 10000){|*x|
+        "Qnil"
+      }.condition{|*x| x.size == 1 and (not x.first)}
+
+    define_method_handler(:to_c, :priority => 1000){|tree, result_var|
+        "#{result_var} = #{to_c(tree)};"
+      }.condition{|*x| x.size == 2 and (not x.first)}
+
+    define_method_handler(:to_c, :priority => -9000){ |tree, result_var|
+      "#{result_var} = #{to_c(tree)};"
+    }.condition{|*x| x.size == 2 }
+    
+    define_method_handler(:to_c, :priority => -10000) do |*x|
+      tree, result_var = x
+
+      raise "undefined translator for node type :#{tree.node_type}"
+    end
+    
+    define_method_handler(:initialize_to_c){|*x|}.condition{|*x|false}
+
+    define_translator_for(:call, :priority => 100){ |*x|
+      tree, result_var = x
+
+      tree[2] = :fastruby_require
+      to_c(tree)
+    }.condition{|*x|
+      tree = x.first; tree.node_type == :call && tree[2] == :require
+    }
+    
+    define_method_handler(:infer_value, :priority => -1000) do |tree|
+      nil
+    end
+    
+    FastRuby::Modules.load_all("translator")
+    
+    def catch_block(*catchs)
+        old_catch_blocks = @catch_blocks.dup
+      begin
+        catchs.each &@catch_blocks.method(:<<)
+        return yield
+      ensure
+        @catch_blocks = old_catch_blocks
+      end
+    end
+
+    def initialize(common_func = true, inferencer = nil)
+      initialize_to_c
+      
+      @inferencer = inferencer
+      @catch_blocks = []
+      @no_cache = false
+      @extra_code = ""
+      @options = {}
+      @init_extra = Array.new
+      @frame_struct = "struct {
+        void* parent_frame;
+        void* plocals;
+        jmp_buf jmp;
+        VALUE return_value;
+        int rescue;
+        VALUE last_error;
+        VALUE next_recv;
+        int targetted;
+        struct FASTRUBYTHREADDATA* thread_data;
+      }"
+
+      @block_struct = "struct {
+        void* block_function_address;
+        void* block_function_param;
+        VALUE proc;
+      }"
+
+        extra_code << "
+          static void frb_jump_tag(int state) {
+            VALUE exception = rb_funcall(#{literal_value FastRuby::JumpTagException}, #{intern_num :new},1,INT2FIX(state)); 
+            rb_exc_raise(exception);
+          }
+        "
+
+      extra_code << "
+        #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
+
+# define PTR2NUM(x)   (ULONG2NUM((unsigned long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+
+        #ifndef __INLINE_FASTRUBY_BASE
+        #include \"#{FastRuby.fastruby_load_path}/../ext/fastruby_base/fastruby_base.inl\"
+        #define __INLINE_FASTRUBY_BASE
+        #endif
+      "
+
+      ruby_code = "
+        unless $LOAD_PATH.include? #{FastRuby.fastruby_load_path.inspect}
+          $LOAD_PATH << #{FastRuby.fastruby_load_path.inspect}
+        end
+        require #{FastRuby.fastruby_script_path.inspect}
+      "
+
+      init_extra << "
+        rb_eval_string(#{ruby_code.inspect});
+    	"
+	
+	
+      if RUBY_VERSION =~ /^1\.8/
+
+      @lambda_node_gvar = add_global_name("NODE*", 0);
+      @proc_node_gvar = add_global_name("NODE*", 0);
+      @procnew_node_gvar = add_global_name("NODE*", 0);
+      @callcc_node_gvar = add_global_name("NODE*", 0);
+      
+      init_extra << "
+        #{@lambda_node_gvar} = rb_method_node(rb_cObject, #{intern_num :lambda});
+        #{@proc_node_gvar} = rb_method_node(rb_cObject, #{intern_num :proc});
+        #{@procnew_node_gvar} = rb_method_node(CLASS_OF(rb_cProc), #{intern_num :new});
+        #{@callcc_node_gvar} = rb_method_node(rb_mKernel, #{intern_num :callcc});
+      "
+     elsif RUBY_VERSION =~ /^1\.9/
+
+      @lambda_node_gvar = add_global_name("void*", 0);
+      @proc_node_gvar = add_global_name("void*", 0);
+      @procnew_node_gvar = add_global_name("void*", 0);
+      @callcc_node_gvar = add_global_name("void*", 0);
+      
+      init_extra << "
+        #{@lambda_node_gvar} = rb_method_entry(rb_cObject, #{intern_num :lambda});
+        #{@proc_node_gvar} = rb_method_entry(rb_cObject, #{intern_num :proc});
+        #{@procnew_node_gvar} = rb_method_entry(CLASS_OF(rb_const_get(rb_cObject, #{intern_num :Proc})), #{intern_num :new});
+        #{@callcc_node_gvar} = rb_method_entry(rb_mKernel, #{intern_num :callcc});
+      "
+	   end
+
+      @common_func = common_func
+      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 re_yield(int argc, VALUE* argv, VALUE param, VALUE _parent_frame) {
+         VALUE yield_args = rb_ary_new4(argc,argv);
+         VALUE* yield_args_p = &yield_args;
+
+         #{@frame_struct}* pframe;
+         pframe = (typeof(pframe))_parent_frame;
+
+         return #{protected_block("last_expression = rb_yield_splat(*(VALUE*)yield_args_p)",true,"yield_args_p",true)};
+        }"
+
+        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 __rb_cvar_set(VALUE recv,ID idvar, VALUE value, int warn) {
+          #{if RUBY_VERSION =~ /^1\.9/
+            "rb_cvar_set(recv,idvar,value);"
+            elsif RUBY_VERSION =~ /^1\.8/
+            "rb_cvar_set(recv,idvar,value,warn);"
+            else
+              raise RuntimeError, "unsupported ruby version #{RUBY_VERSION}"
+            end 
+          }
+         
+          return value;
+        }
+        "
+
+        extra_code << "static VALUE _lvar_assing(VALUE* destination,VALUE value) {
+          *destination = value;
+          return value;
+        }
+
+/*
+       #{caller.join("\n")}
+*/
+
+        "
+        
+      end
+    end
+
+
+    def _raise(class_tree, message_tree = nil)
+      class_tree = to_c class_tree unless class_tree.instance_of? String
+
+      if message_tree.instance_of? String
+        message_tree = "rb_str_new2(#{message_tree.inspect})"
+      else
+        message_tree = to_c message_tree
+      end
+
+      if message_tree
+        return inline_block("
+            pframe->thread_data->exception = rb_funcall(#{class_tree}, #{intern_num :exception},1,#{message_tree});
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+            return Qnil;
+            ")
+      else
+        return inline_block("
+            pframe->thread_data->exception = rb_funcall(#{class_tree}, #{intern_num :exception},0);
+            longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+            return Qnil;
+            ")
+      end
+
+    end
+    
+    def anonymous_function(*x)
+
+      name = "anonymous" + rand(10000000).to_s
+      extra_code << yield(name,*x)
+
+      name
+    end
+
+    def frame_call(inner_code, precode = "", postcode = "")
+      inline_block "
+
+        volatile VALUE ret = Qnil;
+        // create a call_frame
+        #{@frame_struct} call_frame;
+        typeof(call_frame)* volatile old_pframe = (void*)pframe;
+
+        pframe = (typeof(pframe))&call_frame;
+
+        call_frame.parent_frame = (void*)pframe;
+        call_frame.plocals = plocals;
+        call_frame.return_value = Qnil;
+        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();
+
+        void* volatile old_call_frame = plocals->call_frame;
+        plocals->call_frame = &call_frame;
+
+        #{precode}
+
+                int aux = setjmp(call_frame.jmp);
+                if (aux != 0) {
+                  if (call_frame.targetted == 0) {
+                    #{postcode}
+                    longjmp(old_pframe->jmp,aux);
+                  }
+
+                  if (aux == FASTRUBY_TAG_BREAK) {
+                    plocals->call_frame = old_call_frame;
+                    #{postcode}
+                    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;
+                    #{postcode}
+                    return call_frame.return_value;
+                  }
+                }
+                
+
+        #{inner_code};
+        
+        #{postcode}
+        
+        plocals->call_frame = old_call_frame;
+        return ret;
+      "
+    end
+
+    def initialize_method_structs(args_tree)
+      @locals_struct = "struct {
+        int size;        
+        void* call_frame;
+        void* parent_locals;
+        void* pframe;
+        void* block_function_address;
+        void* block_function_param;
+        VALUE active;
+        VALUE targetted;
+        VALUE return_value;
+        #{@locals.map{|l| "VALUE #{l};\n"}.join}
+        }"
+
+    end
+
+    def add_main
+      if options[:main]
+
+        extra_code << "
+          static VALUE #{@alt_method_name}(VALUE self__);
+          static VALUE main_proc_call(VALUE self__, VALUE signature, VALUE class_self_) {
+            #{@alt_method_name}(class_self_);
+            return Qnil;
+          }
+
+        "
+
+        init_extra << "
+            {
+            VALUE newproc = rb_funcall(rb_cObject,#{intern_num :new},0);
+            rb_define_singleton_method(newproc, \"call\", main_proc_call, 2);
+            rb_gv_set(\"$last_obj_proc\", newproc);
+            }
+          "
+      end
+    end
+
+    def define_method_at_init(method_name, size, signature)
+      extra_code << "
+        static VALUE main_proc_call(VALUE self__, VALUE signature, VALUE class_self_) {
+          VALUE method_name = rb_funcall(
+                #{literal_value FastRuby},
+                #{intern_num :make_str_signature},
+                2,
+                #{literal_value method_name},
+                signature
+                );
+
+          ID id = rb_intern(RSTRING_PTR(method_name));
+          
+          rb_funcall(
+                #{literal_value FastRuby},
+                #{intern_num :set_builder_module},
+                1,
+                class_self_
+                );
+          
+          VALUE rb_method_hash;
+          void** address = 0;
+          rb_method_hash = rb_funcall(class_self_, #{intern_num :method_hash},1,#{literal_value method_name});
+
+          if (rb_method_hash != Qnil) {
+            VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
+            if (tmp != Qnil) {
+                address = (void*)NUM2PTR(tmp);
+            }
+          }
+          
+          if (address == 0) {
+            address = malloc(sizeof(void*));
+          }
+          *address = #{@alt_method_name};
+          
+          rb_funcall(
+              class_self_,
+              #{intern_num :register_method_value}, 
+              3,
+              #{literal_value method_name},
+              PTR2NUM(id),
+              PTR2NUM(address)
+              );
+              
+              return Qnil;
+        }
+      "
+      
+      init_extra << "
+            {
+            VALUE newproc = rb_funcall(rb_cObject,#{intern_num :new},0);
+            rb_define_singleton_method(newproc, \"call\", main_proc_call, 2);
+            rb_gv_set(\"$last_obj_proc\", newproc);
+            }
+          "
+    end
+
+    def to_c_method(tree, signature = nil)
+      
+      if tree[0] == :defn
+        method_name = tree[1]
+        original_args_tree = tree[2]
+        block_argument = tree[2].find{|x| x.to_s[0] == ?&}
+        impl_tree = tree[3][1]
+      elsif tree[0] == :defs
+        method_name = tree[2]
+        original_args_tree = tree[3]
+        block_argument = tree[3].find{|x| x.to_s[0] == ?&}
+        impl_tree = tree[4][1]
+      end
+      
+      if "0".respond_to?(:ord)
+        @alt_method_name = "_" + method_name.to_s.gsub("_x_", "_x__x_").gsub(/\W/){|x| "_x_#{x.ord}" } + "_" + rand(10000000000).to_s
+      else
+        @alt_method_name = "_" + method_name.to_s.gsub("_x_", "_x__x_").gsub(/\W/){|x| "_x_#{x[0]}" } + "_" + rand(10000000000).to_s
+      end
+
+      args_tree = original_args_tree.select{|x| x.to_s[0] != ?&}
+
+        initialize_method_structs(original_args_tree)
+        
+        if options[:main] then
+          strargs = if args_tree.size > 1
+            "VALUE self, VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
+          else
+            "VALUE self, VALUE block, VALUE _parent_frame"
+          end
+
+        else
+          
+          strargs = "VALUE self, VALUE block, VALUE _parent_frame, int argc, VALUE* argv"
+          
+          splat_arg = args_tree[1..-1].find{|x| x.to_s.match(/\*/) }
+  
+          maxargnum = args_tree[1..-1].count{ |x|
+              if x.instance_of? Symbol
+                not x.to_s.match(/\*/) and not x.to_s.match(/\&/)
+              else
+                false
+              end
+            }
+            
+          minargnum = maxargnum
+            
+          args_tree[1..-1].each do |subtree|
+            unless subtree.instance_of? Symbol
+              if subtree[0] == :block
+                minargnum = minargnum - (subtree.size-1)
+              end
+            end
+          end
+          
+          if args_tree[1..-1].find{|x| x.to_s.match(/\*/)}
+            maxargnum = 2147483647
+          end
+          
+          read_arguments_code = ""
+  
+  
+          validate_arguments_code = if signature.size-1 < minargnum
+              "
+                rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{minargnum})\");
+              "
+          elsif signature.size-1 > maxargnum
+              "
+                rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{maxargnum})\");
+              "
+          else
+  
+              default_block_tree = args_tree[1..-1].find{|subtree|
+                unless subtree.instance_of? Symbol
+                  if subtree[0] == :block
+                    next true
+                  end
+                end
+      
+                false
+              }
+              
+              i = -1
+  
+              normalargsnum = args_tree[1..-1].count{|subtree|
+                if subtree.instance_of? Symbol
+                  unless subtree.to_s.match(/\*/) or subtree.to_s.match(/\&/)
+                    next true
+                  end
+                end
+                      
+                false
+              }
+  
+              read_arguments_code = args_tree[1..-1].map { |arg_|
+                  arg = arg_.to_s
+                  i = i + 1
+      
+                  if i < normalargsnum
+                    if i < signature.size-1
+                      "plocals->#{arg} = argv[#{i}];\n"
+                    else
+                        
+                      if default_block_tree
+                        initialize_tree = default_block_tree[1..-1].find{|subtree| subtree[1] == arg_}
+                        if initialize_tree
+                          to_c(initialize_tree) + ";\n"
+                        else
+                          ""
+                        end
+                      else
+                          ";\n"
+                      end
+                    end
+                  else
+                    ""
+                  end
+                }.join("")
+                
+              if splat_arg
+                    if signature.size-1 < normalargsnum then
+                      read_arguments_code << "
+                        plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new3(0);
+                        "
+                    else
+                      read_arguments_code << "
+                        plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new4(
+                              #{(signature.size-1) - (normalargsnum)}, argv+#{normalargsnum} 
+                              );
+                      "
+                    end
+      
+              end
+            
+            
+              ""
+          end
+  
+          if block_argument
+  
+            proc_reyield_block_tree = s(:iter, s(:call, nil, :proc, s(:arglist)), s(:masgn, s(:array, s(:splat, s(:lasgn, :__xproc_arguments)))), s(:yield, s(:splat, s(:lvar, :__xproc_arguments))))
+  
+            require "fastruby/sexp_extension"
+  
+            read_arguments_code << "
+              if (pblock ? pblock->proc != Qnil : 0) {
+                plocals->#{block_argument.to_s.gsub("&","")} = pblock->proc;
+              } else {
+                plocals->#{block_argument.to_s.gsub("&","")} = #{to_c FastRuby::FastRubySexp.from_sexp(proc_reyield_block_tree)};
+              }
+            "
+
+            read_arguments_code << "
+              if (pblock) {
+              rb_ivar_set(plocals->#{block_argument.to_s.gsub("&","")},
+                        #{intern_num "__block_address"}, PTR2NUM(pblock->block_function_address)); 
+              rb_ivar_set(plocals->#{block_argument.to_s.gsub("&","")},
+                        #{intern_num "__block_param"}, PTR2NUM(pblock->block_function_param));            
+              }            
+
+            "
+          end
+
+        end
+
+        require "fastruby/sexp_extension"
+        
+        trs = lambda{|tree| 
+            if not tree.respond_to? :node_type 
+              next tree
+            elsif tree.node_type == :call
+              mmname = tree[2]
+              next trs.call(tree[1]) || tree[1] if mmname == :infer
+              next fs(:nil) if mmname == :_throw or mmname == :_loop or mmname == :_raise
+              next fs(:nil) if mmname == :== and infer_value(tree)
+            elsif tree.node_type == :iter
+              mmname = tree[1][2]
+              next fs(:nil) if mmname == :_static
+              next fs(:block, trs.call(tree[3]) || tree[3]) if mmname == :_catch
+            end
+
+            tree.map &trs
+          }
+          
+        evaluate_tree = tree.transform &trs
+        
+        scope_mode = FastRuby::ScopeModeHelper.get_scope_mode(evaluate_tree)
+        ret = "VALUE #{@alt_method_name || method_name}(#{options[:main] ? "VALUE self" : strargs}) {
+          #{validate_arguments_code}
+
+          #{@frame_struct} frame;
+          #{@frame_struct} * volatile pframe;
+          
+          frame.parent_frame = #{options[:main] ? "0"  : "(void*)_parent_frame"};
+          frame.return_value = Qnil;
+          frame.rescue = 0;
+          frame.targetted = 0;
+          frame.thread_data = #{options[:main] ? "0" : "((typeof(pframe))_parent_frame)->thread_data"};
+          if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
+
+          int stack_chunk_instantiated = 0;
+          
+#{
+if scope_mode == :dag
+  " 
+          volatile VALUE rb_previous_stack_chunk = Qnil;
+          VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
+          struct STACKCHUNK* volatile stack_chunk = 0;
+
+          if (rb_stack_chunk != Qnil) {
+            Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,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;
+
+            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}* volatile plocals;
+
+          volatile int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
+          plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
+          
+  "
+else
+  "
+          #{@locals_struct} locals;
+          typeof(locals) * volatile plocals = &locals;
+  "
+end
+}
+
+          plocals->parent_locals = (frame.thread_data->last_plocals);
+          void* volatile old_parent_locals = frame.thread_data->last_plocals;
+          
+          #{
+          if scope_mode == :dag 
+            "frame.thread_data->last_plocals = plocals;\n"
+          end
+          }
+          
+          frame.plocals = plocals;
+          plocals->active = Qtrue;
+          plocals->targetted = Qfalse;
+          plocals->pframe = (&frame);
+          plocals->call_frame = (0);
+
+          pframe = (void*)&frame;
+
+          #{@block_struct} * volatile pblock;
+          volatile VALUE last_expression = Qnil;
+
+          int aux = setjmp(pframe->jmp);
+          if (aux != 0) {
+            plocals->active = Qfalse;
+
+#{
+if scope_mode == :dag
+  " 
+            stack_chunk_set_current_position(stack_chunk, previous_stack_position);
+
+            if (stack_chunk_instantiated) {
+              rb_gc_unregister_address(&rb_stack_chunk);
+              frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
+            }
+"
+end
+}            
+            #{
+            unless options[:main]
+              "
+              if (plocals->targetted == Qfalse || aux != FASTRUBY_TAG_RETURN) {
+                frame.thread_data->last_plocals = old_parent_locals;
+                
+                longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
+              }
+              "
+            end
+            }
+
+            frame.thread_data->last_plocals = old_parent_locals;
+            
+            return plocals->return_value;
+          }
+
+          plocals->self = self;
+
+          #{
+          unless options[:main]
+            "
+            pblock = (void*)block;
+            if (pblock) {
+              plocals->block_function_address = pblock->block_function_address;
+              plocals->block_function_param = pblock->block_function_param;
+            } else {
+              plocals->block_function_address = (0);
+              plocals->block_function_param = 0;
+            }
+            "
+          end
+          }
+
+          #{read_arguments_code}
+
+          #{to_c impl_tree, "last_expression"};
+          
+local_return:
+#{
+if scope_mode == :dag
+"
+          stack_chunk_set_current_position(stack_chunk, previous_stack_position);
+
+          if (stack_chunk_instantiated) {
+            rb_gc_unregister_address(&rb_stack_chunk);
+            frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
+          }
+"
+end
+}
+          plocals->active = Qfalse;
+          
+          frame.thread_data->last_plocals = old_parent_locals;
+          
+          return last_expression;
+        }"
+
+        add_main
+        extra_code << ret
+      
+      "
+        static VALUE dummy_#{@alt_method_name}_#{rand(1000000000000000000000000000000000)}(VALUE a) {
+          return Qnil;
+        }
+      "
+    end
+
+    def locals_accessor
+      "plocals->"
+    end
+
+    def locals_scope(locals)
+       old_locals = @locals
+       old_locals_struct = @locals_struct
+
+       @locals = locals
+        @locals_struct = "struct {
+        int size;
+        void* call_frame;
+        void* parent_locals;
+        void* pframe;
+        void* block_function_address;
+        void* block_function_param;
+        VALUE active;
+        VALUE targetted;
+        VALUE return_value;
+        #{@locals.map{|l| "VALUE #{l};\n"}.join}
+        }"
+
+      begin
+        yield
+      ensure
+        @locals = old_locals
+        @locals_struct = old_locals_struct
+      end
+    end
+
+    def infer_type(recv)
+      array = @inferencer.infer(recv).to_a
+      
+      if array.size == 1
+        array[0]
+      else
+        nil
+      end
+    end
+
+    def on_block
+      old_on_block = @on_block
+      @on_block = true
+      return yield
+    ensure
+      @on_block = old_on_block
+    end
+
+    def directive(tree)
+      recv = tree[1]
+      mname = tree[2]
+      args = tree[3]
+
+      if mname == :infer
+        return to_c(recv)
+      elsif mname == :block_given?
+        return "plocals->block_function_address == 0 ? Qfalse : Qtrue"
+      elsif mname == :inline_c
+
+        code = args[1][1]
+
+        unless (args[2] == s(:false))
+          return anonymous_function{ |name| "
+             static VALUE #{name}(VALUE param) {
+              #{@frame_struct} *pframe = (void*)param;
+              #{@locals_struct} *plocals = (void*)pframe->plocals;
+              #{code};
+
+              return Qnil;
+            }
+           "
+          }+"((VALUE)pframe)"
+        else
+          code
+        end
+
+      else
+        nil
+      end
+    end
+
+    def inline_block_reference(arg, nolocals = false)
+      code = nil
+
+      if arg.instance_of? FastRuby::FastRubySexp
+        code = to_c(arg);
+      else
+        code = arg
+      end
+
+      anonymous_function{ |name| "
+        static VALUE #{name}(VALUE param) {
+          #{@frame_struct} *pframe = (void*)param;
+
+          #{nolocals ? "" : "#{@locals_struct} *plocals = (void*)pframe->plocals;"}
+          VALUE last_expression = Qnil;
+
+          #{code};
+          return last_expression;
+          }
+        "
+      }
+    end
+
+    def catch_on_throw
+      old_catch_jmp_on_throw = @catch_jmp_on_throw || false
+      @catch_jmp_on_throw = true
+      begin
+        ret = yield
+      ensure
+        @catch_jmp_on_throw = old_catch_jmp_on_throw
+      end
+      
+      ret
+    end
+
+    def inline_block(*args)
+      
+      unless block_given?
+        code = args.first
+        return inline_block(*args[1..-1]) {
+            code
+          }
+      end
+      
+      repass_var = args[0]
+      nolocals = args[1] || false
+      
+      code = catch_on_throw{ yield }
+
+      anonymous_function{ |name| "
+        static VALUE #{name}(VALUE param#{repass_var ? ",void* " + repass_var : "" }) {
+          #{@frame_struct} * volatile pframe = (void*)param;
+
+          #{nolocals ? "" : "#{@locals_struct} * volatile plocals = (void*)pframe->plocals;"}
+          volatile VALUE last_expression = Qnil;
+
+          #{code}
+          return Qnil;
+
+
+#{@catch_blocks.map { |cb|
+  "#{cb.to_s}_end:
+
+   plocals->return_value = last_expression;
+   plocals->targetted = 1;
+   longjmp(pframe->jmp, #{intern_num( cb.to_s + "_end")});
+    
+   #{cb.to_s}_start:
+  
+   plocals->return_value = last_expression;
+   plocals->targetted = 1;
+   longjmp(pframe->jmp, #{intern_num( cb.to_s + "_start")});
+  
+  "
+
+}.join("\n")
+}
+          #{unless nolocals
+          "
+local_return:
+        plocals->return_value = last_expression;
+        plocals->targetted = 1;
+        longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
+        return last_expression;
+        "
+        end
+          }
+fastruby_local_redo:
+          longjmp(pframe->jmp,FASTRUBY_TAG_REDO);
+          return Qnil;
+fastruby_local_next:
+          longjmp(pframe->jmp,FASTRUBY_TAG_NEXT);
+          return Qnil;
+
+
+          }
+        "
+      } + "((VALUE)pframe#{repass_var ? ", " + repass_var : "" })"
+    end
+
+    def inline_ruby(proced, parameter)
+      "rb_funcall(#{proced.__id__}, #{intern_num :call}, 1, #{parameter})"
+    end
+
+    def protected_block(*args)
+      unless block_given?
+        inner_code = args.first
+        return protected_block(*args[1..-1]) {
+          inner_code
+        }
+      end
+      
+      repass_var = args[1]
+      nolocals = args[2] || false
+      
+      inline_block(repass_var, nolocals) do
+        generate_protected_block(yield, *args)
+      end
+    end
+    
+    def generate_protected_block(inner_code, always_rescue = false,repass_var = nil, nolocals = false)
+      body = nil
+      rescue_args = nil
+
+        body =  anonymous_function{ |name| "
+          static VALUE #{name}(VALUE param) {
+
+            #{@frame_struct} frame;
+
+            typeof(frame)* volatile pframe;
+            
+            #{if repass_var
+            "typeof(frame)* parent_frame = ((typeof(pframe))((void**)param)[0]);"
+            else
+            "typeof(frame)* parent_frame = (typeof(pframe))param;"
+            end
+            }
+
+            frame.parent_frame = 0;
+            frame.return_value = Qnil;
+            frame.rescue = 0;
+            frame.last_error = Qnil;
+            frame.targetted = 0;
+            frame.thread_data = parent_frame->thread_data;
+            frame.next_recv = parent_frame->next_recv;
+            if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
+
+            pframe = &frame;
+
+            #{
+            nolocals ? "frame.plocals = 0;" : "#{@locals_struct}* plocals = parent_frame->plocals;
+            frame.plocals = plocals;
+            "
+            }
+
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
+
+              if (frame.targetted == 1) {
+                return frame.return_value;
+              } else {
+                frb_jump_tag(aux);
+              }
+            }
+
+            #{if repass_var 
+              "VALUE #{repass_var} = (VALUE)((void**)param)[1];"
+            end
+            }
+              volatile VALUE last_expression = Qnil;
+              #{inner_code};
+              return last_expression;
+            }
+          "
+        }
+
+      if repass_var
+        rescue_args = ""
+        rescue_args = "(VALUE)(VALUE[]){(VALUE)pframe,(VALUE)#{repass_var}}"
+      else
+        rescue_args = "(VALUE)pframe"
+      end
+
+      wrapper_code = "
+            if (str.state >= 0x80) {
+              longjmp(pframe->jmp, str.state);
+            } else {
+              if (str.last_error != Qnil) {
+                  // raise emulation
+                  pframe->thread_data->exception = str.last_error;
+                  longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+                  return Qnil;
+              }
+            }
+        "
+        
+        return_err_struct = "struct {
+            VALUE last_error;
+            int state;
+          }
+          "
+
+        rescue_body = anonymous_function{ |name| "
+          static VALUE #{name}(VALUE param, VALUE err) {
+            #{return_err_struct} *pstr = (void*)param;
+            
+            if (rb_obj_is_instance_of(err, #{literal_value FastRuby::JumpTagException})) {
+              pstr->state = FIX2INT(rb_funcall(err, #{intern_num :state}, 0));
+            } else {
+              pstr->last_error = err;
+            }
+            
+            return Qnil;
+          }
+        "
+      }
+
+      rescue_code = "rb_rescue2(#{body}, #{rescue_args}, #{rescue_body}, (VALUE)&str, rb_eException, (VALUE)0)"
+
+      if always_rescue
+        "
+          #{return_err_struct} str;
+          
+          str.state = 0;
+          str.last_error = Qnil;
+          
+          pframe->last_error = Qnil;
+          VALUE result = #{rescue_code};
+
+          #{wrapper_code}
+
+          return result;
+        "
+      else
+        "
+          VALUE result;
+          #{return_err_struct} str;
+          
+          str.state = 0;
+          str.last_error = Qnil;
+          
+          pframe->last_error = Qnil;
+
+          if (pframe->rescue) {
+            result = #{rescue_code};
+            #{wrapper_code}
+          } else {
+            VALUE last_expression = Qnil;
+            #{inner_code};
+            return last_expression;
+          }
+
+          return result;
+        "
+      end
+    end
+
+    def c_escape(str)
+      str.inspect
+    end
+
+    def literal_value(value)
+      @literal_value_hash = Hash.new unless @literal_value_hash
+      return @literal_value_hash[value] if @literal_value_hash[value]
+
+      name = self.add_global_name("VALUE", "Qnil");
+
+      begin
+
+        str = Marshal.dump(value)
+
+
+        if value.instance_of? Module
+
+          container_str = value.to_s.split("::")[0..-2].join("::")
+
+          init_extra << "
+            #{name} = rb_define_module_under(
+                    #{container_str == "" ? "rb_cObject" : literal_value(eval(container_str))}
+                    ,\"#{value.to_s.split("::").last}\");
+
+            rb_funcall(#{name},#{intern_num :gc_register_object},0);
+          "
+        elsif value.instance_of? Class
+          container_str = value.to_s.split("::")[0..-2].join("::")
+
+          str_class_name = value.to_s.split("::").last
+
+          if (str_class_name == "Object")
+            init_extra << "
+              #{name} = rb_cObject;
+            "
+          else
+            init_extra << "
+              #{name} = rb_define_class_under(
+                      #{container_str == "" ? "rb_cObject" : literal_value(eval(container_str))}
+                      ,\"#{str_class_name}\"
+                      ,#{value.superclass == Object ? "rb_cObject" : literal_value(value.superclass)});
+
+              rb_funcall(#{name},#{intern_num :gc_register_object},0);
+            "
+          end
+        elsif value.instance_of? Array
+          init_extra << "
+            #{name} = rb_ary_new3(#{value.size}, #{value.map{|x| literal_value x}.join(",")} );
+            rb_funcall(#{name},#{intern_num :gc_register_object},0);
+          "
+        else
+          
+          init_extra << "
+          
+            {
+              VALUE encoded_str = rb_str_new2(#{Base64.encode64(str).inspect});
+              VALUE str = rb_funcall(rb_cObject, #{intern_num :decode64}, 1, encoded_str);
+              #{name} = rb_marshal_load(str);
+              
+              rb_funcall(#{name},#{intern_num :gc_register_object},0);
+            }
+
+          "
+        end
+      rescue TypeError => e
+        @no_cache = true
+        FastRuby.logger.info "#{value} disabling cache for extension"
+        init_extra << "
+          #{name} = rb_funcall(rb_const_get(rb_cObject, #{intern_num :ObjectSpace}), #{intern_num :_id2ref}, 1, INT2FIX(#{value.__id__}));
+        "
+
+      end
+     @literal_value_hash[value] = name
+
+      name
+    end
+
+    def encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name = nil, is_block_call = false)
+      name = self.add_global_name("void*", 0);
+      address_name = self.add_global_name("void**", 0);
+      @last_address_name = address_name
+      cfunc_address_name = self.add_global_name("void**", 0);
+      cfunc_real_address_name  = self.add_global_name("void*", 0);
+      tree_pointer_name = self.add_global_name("VALUE*", 0);
+      
+      if call_tree[3].select{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
+        is_block_call = true
+      end
+      
+      args_tree = call_tree[3].reject{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
+      method_tree = nil
+
+      begin
+        method_tree = recvtype.instance_method(@method_name.to_sym).fastruby.tree
+      rescue NoMethodError
+      end
+
+      strargs_signature = (0..args_tree.size-2).map{|x| "VALUE arg#{x}"}.join(",")
+      strargs = (0..args_tree.size-2).map{|x| "arg#{x}"}.join(",")
+      inprocstrargs = (1..args_tree.size-1).map{|x| "((VALUE*)method_arguments)[#{x}]"}.join(",")
+
+      if args_tree.size > 1
+        strargs_signature = "," + strargs_signature
+        toprocstrargs = "self,"+strargs
+        strargs = "," + strargs
+        inprocstrargs = ","+inprocstrargs
+      else
+        toprocstrargs = "self"
+      end
+
+      value_cast = ( ["VALUE"]*(args_tree.size) ).join(",") + ",VALUE,VALUE"
+
+      recvdump = nil
+
+      begin
+         recvdump = literal_value recvtype
+      rescue
+      end
+      
+      pureruby_wrapper = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv){
+          #{@frame_struct}* pframe = frame;
+          VALUE method_arguments[3];
+          
+          method_arguments[0] = (VALUE)argc;
+          method_arguments[1] = (VALUE)argv;
+          method_arguments[2] = (VALUE)self;
+          
+          return #{
+            protected_block "last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", false, "method_arguments"
+            };
+        }
+      "
+      }
+      
+      generic_wrapper = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv){
+          #{@frame_struct}* pframe = frame;
+          VALUE method_arguments[4];
+          
+          method_arguments[0] = (VALUE)argc;
+          method_arguments[1] = (VALUE)argv;
+          method_arguments[2] = (VALUE)self;
+          method_arguments[3] = (VALUE)block;
+          
+          void* fptr = 0;
+          
+          if (*#{address_name} == 0) {
+            if (#{tree_pointer_name} != 0) {
+              if (*#{tree_pointer_name} != Qnil) {
+                VALUE signature = #{literal_value signature};
+                VALUE recvtype = #{recvdump};
+                VALUE mname = #{literal_value mname};
+                
+                rb_funcall(recvtype, #{intern_num :build}, 2, signature, mname);
+              }
+            }
+          }
+          
+          fptr = *#{address_name};
+          
+            if (fptr == 0) {
+              fptr = *#{cfunc_address_name};
+              if (fptr != 0) {
+                return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*) ) (fptr) )(self,(VALUE)block,(VALUE)frame, argc, argv);  
+              }
+            }
+
+          if (fptr == 0) {
+            if (block==0) {
+              return #{
+                protected_block "last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", false, "method_arguments"
+                };
+
+            } else {
+              return #{
+                  protected_block "
+                        #{@block_struct} *pblock;
+                        pblock = (typeof(pblock))( ((VALUE*)method_arguments)[3] );
+                        last_expression = rb_iterate(
+                        #{anonymous_function{|name_|
+                          "
+                            static VALUE #{name_} (VALUE data) {
+                              VALUE* method_arguments = (VALUE*)data;
+                              return rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);
+                            }
+                          "
+                        }},
+                          (VALUE)method_arguments,
+                          
+                        #{anonymous_function{|name_|
+                          "
+                            static VALUE #{name_} (VALUE arg_, VALUE param, int argc, VALUE* argv) {
+
+           VALUE arg;
+            #{
+            # TODO: access directly to argc and argv for optimal execution
+            if RUBY_VERSION =~ /^1\.9/ 
+              "
+                if (TYPE(arg_) == T_ARRAY) {
+                  if (_RARRAY_LEN(arg_) <= 1) {
+                    arg = rb_ary_new4(argc,argv);
+                  } else {
+                    arg = arg_;
+                  }
+                } else {
+                  arg = rb_ary_new4(argc,argv);
+                }
+              "
+            else
+              "arg = arg_;"
+            end
+            }
+        
+                              return rb_proc_call(param, arg);
+                            }
+                          "
+                        }},
+                          pblock->proc
+                        );
+                ", false, "method_arguments"
+                };
+            }
+
+          } else {
+            return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*)) (fptr) )(self,(VALUE)block,(VALUE)frame,argc,argv);  
+          }
+        }
+        "
+      }
+
+
+      cfuncall1inprocargs = (0..args_tree.size-2).map{|x| "argv[#{x}]"}.join(",")
+      cfuncall1inprocargs = ","+cfuncall1inprocargs if cfuncall1inprocargs != ""
+      
+      cfunc_value_cast = (["VALUE"]*args_tree.size).join(",")
+      cfunc_wrapper = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
+          return rb_vm_call(ruby_current_thread, self, #{intern_num mname.to_sym}, argc, argv, #{cfunc_real_address_name});
+        }
+        "
+      }
+      
+      toprocstrargs = (0..25).map{|x| "arg#{x}"}.join(",")
+      strargs_signature = (0..25).map{|x| "VALUE arg#{x}"}.join(",")
+
+      cfunc_wrapper_1 = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
+            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(argc,argv,self);
+        }
+        "
+      }
+
+      cfunc_wrapper_2 = anonymous_function{ |funcname| "
+        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
+            VALUE args = rb_ary_new3(argc, argv);
+            return ( (VALUE(*)(VALUE,VALUE)) (#{cfunc_real_address_name}) )(self,args);
+        }
+        "
+      }
+
+      update_cfunc_method = anonymous_function{ |funcname| "
+          static VALUE #{funcname}(){
+                void** default_address = (void**)#{cfunc_address_name};
+                ID default_id = rb_intern(\"default\");
+                VALUE recvtype = #{recvdump};
+
+                if (1) {
+                  *default_address = 0;
+    
+    #{
+    if RUBY_VERSION == "1.9.2"
+      
+    "
+                  rb_method_entry_t* me = rb_method_entry(recvtype,#{intern_num mname});
+                  if (me != 0) {
+                    rb_method_definition_t* def = me->def;
+                    
+                    if (def->type == VM_METHOD_TYPE_CFUNC) {
+                      *default_address = #{cfunc_wrapper};
+                      #{cfunc_real_address_name} = (void*)me;
+                    }
+                  }
+    "
+    end
+    }
+                  if (default_address != 0) {
+                    if (recvtype != Qnil) { 
+                      rb_funcall(
+                          recvtype,
+                          #{intern_num :register_method_value}, 
+                          3,
+                          #{literal_value mname},
+                          PTR2NUM(default_id),
+                          PTR2NUM(default_address)
+                          );
+                    }
+                  }
+                }
+              return Qnil;
+          }
+        "
+      }
+        
+        
+
+      if recvdump and recvtype
+        init_extra << "
+          {
+            VALUE recvtype = #{recvdump};
+            rb_funcall(#{literal_value FastRuby}, #{intern_num :set_builder_module}, 1, recvtype);
+            VALUE signature = #{literal_value signature};
+            VALUE mname = #{literal_value mname};
+            VALUE tree = #{literal_value method_tree};
+            VALUE rb_str_signature = rb_funcall(
+                                      #{literal_value FastRuby},
+                                      #{intern_num :make_str_signature},
+                                      2,
+                                      mname,
+                                      signature);
+
+
+
+            VALUE fastruby_method = rb_funcall(recvtype, #{intern_num :fastruby_method}, 1, mname);
+            #{tree_pointer_name} = (VALUE*)NUM2PTR(fastruby_method_tree_pointer(fastruby_method));
+            
+            ID id;
+            ID default_id = rb_intern(\"default\");
+            VALUE rb_method_hash;
+            void** address = 0;
+            void** default_address = 0;
+            id = rb_intern(RSTRING_PTR(rb_str_signature));
+            rb_method_hash = rb_funcall(recvtype, #{intern_num :method_hash},1,mname);
+
+            if (rb_method_hash != Qnil) {
+              VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
+              if (tmp != Qnil) {
+                  address = (void*)NUM2PTR(tmp);
+              }
+              
+              tmp = rb_hash_aref(rb_method_hash, PTR2NUM(default_id));
+              if (tmp != Qnil) {
+                 default_address = (void*)NUM2PTR(tmp);
+              }
+            }
+            
+            if (default_address==0) {
+              default_address = malloc(sizeof(void*));
+              *default_address = 0;
+            }
+            #{cfunc_address_name} = default_address;
+            #{unless is_block_call
+              "
+              #{update_cfunc_method}();
+              rb_iterate(#{anonymous_function{|funcname|
+                "static VALUE #{funcname}(VALUE recv) {
+                  return rb_funcall(recv, #{intern_num :observe}, 1, #{literal_value(@alt_method_name + "#" + cfunc_address_name)});
+                }
+                "
+              }},fastruby_method,#{update_cfunc_method},Qnil);
+              "
+            end
+            }
+
+            if (address==0) {
+              address = malloc(sizeof(void*));
+              
+              if (recvtype != Qnil) { 
+                rb_funcall(
+                    recvtype,
+                    #{intern_num :register_method_value}, 
+                    3,
+                    #{literal_value mname},
+                    PTR2NUM(id),
+                    PTR2NUM(address)
+                    );
+              }
+  
+              *address = 0; //(void*)
+            }
+            
+            #{address_name} = address;
+            #{name} = (void*)#{generic_wrapper};
+          }
+        "
+      else
+        init_extra << "
+        // ruby, wrap rb_funcall
+        #{name} = (void*)#{pureruby_wrapper};
+        "
+      end
+
+      name
+    end
+
+    def intern_num(symbol)
+      symbol = symbol.to_sym
+      @intern_num_hash = Hash.new unless @intern_num_hash
+      return @intern_num_hash[symbol] if @intern_num_hash[symbol]
+
+      name = self.add_global_name("ID", 0);
+
+      init_extra << "
+        #{name} = rb_intern(\"#{symbol.to_s}\");
+      "
+
+      @intern_num_hash[symbol] = name
+
+      name
+    end
+
+    def add_global_name(ctype, default)
+      name = "glb" + rand(1000000000).to_s
+
+      extra_code << "
+        static #{ctype} #{name} = #{default};
+      "
+      name
+    end
+
+    def global_entry(glbname)
+      name = add_global_name("struct global_entry*", 0);
+
+      init_extra << "
+        #{name} = rb_global_entry(SYM2ID(#{literal_value glbname}));
+      "
+
+      name
+    end
+
+
+    def frame(code, jmp_code, not_jmp_code = "", rescued = nil)
+
+      anonymous_function{ |name| "
+        static VALUE #{name}(VALUE param) {
+          volatile VALUE last_expression = Qnil;
+          #{@frame_struct} frame;
+
+          typeof(frame)* volatile pframe;
+          typeof(frame)* volatile parent_frame;
+          #{@locals_struct}* volatile plocals;
+
+          parent_frame = (void*)param;
+
+          frame.parent_frame = (void*)param;
+          frame.plocals = parent_frame->plocals;
+          frame.rescue = #{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;
+
+          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->targetted == 0) {
+              longjmp(pframe->jmp,aux);
+            }
+
+            return last_expression;
+          }
+
+          #{code};
+
+          // restore previous frame
+          volatile typeof(pframe) original_frame = pframe;
+          pframe = parent_frame;
+          #{not_jmp_code};
+
+          return last_expression;
+
+          }
+        "
+      } + "((VALUE)pframe)"
+    end
+  end
+end