fastruby 0.0.12 → 0.0.13

data/lib/fastruby/translator/iter.rb

@@ -1,2594 +0,0 @@
-=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 "fastruby/method_extension"
-require "fastruby/set_tree"
-require "fastruby/exceptions"
-require "rubygems"
-require "sexp"
-
-module FastRuby
-  class Context
-    attr_accessor :infer_lvar_map
-    attr_accessor :alt_method_name
-    attr_accessor :locals
-    attr_accessor :options
-    attr_accessor :infer_self
-    attr_accessor :snippet_hash
-    attr_reader :no_cache
-    attr_reader :init_extra
-    attr_reader :extra_code
-    attr_reader :yield_signature
-
-    def initialize(common_func = true)
-      @infer_lvar_map = Hash.new
-      @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;
-      }"
-
-
-      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
-        #endif
-      "
-
-      ruby_code = "
-        $LOAD_PATH << #{FastRuby.fastruby_load_path.inspect}
-        require #{FastRuby.fastruby_script_path.inspect}
-      "
-
-      init_extra << "
-        rb_eval_string(#{ruby_code.inspect});
-    	"
-
-      @lambda_node_gvar = add_global_name("NODE*", 0);
-      @proc_node_gvar = add_global_name("NODE*", 0);
-      @procnew_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});
-      "
-
-      @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("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) {
-          rb_cvar_set(recv,idvar,value,warn);
-          return value;
-        }
-        "
-
-        extra_code << "static VALUE _lvar_assing(VALUE* destination,VALUE value) {
-          *destination = value;
-          return value;
-        }
-
-/*
-       #{caller.join("\n")}
-*/
-
-        "
-      end
-    end
-
-    def to_c(tree)
-      return "Qnil" unless tree
-      send("to_c_" + tree[0].to_s, tree);
-    end
-
-    def anonymous_function
-
-      name = "anonymous" + rand(10000000).to_s
-      extra_code << yield(name)
-
-      name
-    end
-
-    def to_c_dot2(tree)
-      "rb_range_new(#{to_c tree[1]}, #{to_c tree[2]},0)"
-    end
-
-    def to_c_attrasgn(tree)
-      to_c_call(tree)
-    end
-
-    def to_c_iter(tree)
-
-      call_tree = tree[1]
-      args_tree = tree[2]
-      recv_tree = call_tree[1]
-
-      directive_code = directive(call_tree)
-      if directive_code
-        return directive_code
-      end
-
-      other_call_tree = call_tree.dup
-      other_call_tree[1] = s(:lvar, :arg)
-
-      mname = call_tree[2]
-
-      call_args_tree = call_tree[3]
-
-      caller_code = nil
-
-      recvtype = infer_type(recv_tree || s(:self))
-
-      address = nil
-      mobject = nil
-      len = nil
-
-      extra_inference = {}
-
-      if recvtype
-
-        inference_complete = true
-        signature = [recvtype]
-
-        call_args_tree[1..-1].each do |arg|
-          argtype = infer_type(arg)
-          if argtype
-            signature << argtype
-          else
-            inference_complete = false
-          end
-        end
-
-        if recvtype.respond_to? :fastruby_method and inference_complete
-          method_tree = nil
-          begin
-            method_tree = recvtype.instance_method(call_tree[2]).fastruby.tree
-          rescue NoMethodError
-          end
-
-          if method_tree
-            mobject = recvtype.build(signature, call_tree[2])
-            yield_signature = mobject.yield_signature
-
-            if not args_tree
-            elsif args_tree.first == :lasgn
-              if yield_signature[0]
-              extra_inference[args_tree.last] = yield_signature[0]
-              end
-            elsif args_tree.first == :masgn
-              yield_args = args_tree[1][1..-1].map(&:last)
-              (0...yield_signature.size-1).each do |i|
-                extra_inference[yield_args[i]] = yield_signature[i]
-              end
-            end
-          end
-        end
-      end
-
-      anonymous_impl = tree[3]
-
-      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
-              str_impl = anonymous_impl[1..-2].map{ |subtree|
-                to_c(subtree)
-              }.join(";")
-
-              if anonymous_impl[-1][0] != :return and anonymous_impl[-1][0] != :break and anonymous_impl[-1][0] != :next
-                str_impl = str_impl + ";last_expression = (#{to_c(anonymous_impl[-1])});"
-              else
-                str_impl = str_impl + ";#{to_c(anonymous_impl[-1])};"
-              end
-            else
-              if anonymous_impl[0] != :return and anonymous_impl[0] != :break and anonymous_impl[0] != :next
-                str_impl = str_impl + ";last_expression = (#{to_c(anonymous_impl)});"
-              else
-                str_impl = str_impl + ";#{to_c(anonymous_impl)};"
-              end
-            end
-          else
-            str_impl = "last_expression = Qnil;"
-          end
-        end
-      end
-
-
-        if not args_tree
-          str_arg_initialization = ""
-        elsif args_tree.first == :lasgn
-          str_arg_initialization = "plocals->#{args_tree[1]} = arg;"
-        elsif args_tree.first == :masgn
-          arguments = args_tree[1][1..-1].map(&:last)
-
-          (0..arguments.size-1).each do |i|
-            str_arg_initialization << "plocals->#{arguments[i]} = rb_ary_entry(arg,#{i});\n"
-          end
-        end
-        rb_funcall_caller_code = nil
-
-        if call_args_tree.size > 1
-
-          str_called_code_args = call_args_tree[1..-1].map{ |subtree| to_c subtree }.join(",")
-          str_recv = "pframe->next_recv"
-
-          str_recv = "plocals->self" unless recv_tree
-
-            rb_funcall_caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param) {
-                // call to #{call_tree[2]}
-
-                #{str_lvar_initialization}
-                return rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, #{call_args_tree.size-1}, #{str_called_code_args});
-              }
-            "
-            }
-
-            rb_funcall_caller_code_with_lambda = rb_funcall_caller_code
-        else
-          str_recv = "pframe->next_recv"
-          str_recv = "plocals->self" unless recv_tree
-
-            rb_funcall_caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param) {
-                // call to #{call_tree[2]}
-                #{str_lvar_initialization}
-                return rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, 0);
-              }
-            "
-            }
-
-            rb_funcall_caller_code_with_lambda = proc { |name| "
-              static VALUE #{name}(VALUE param) {
-                // call to #{call_tree[2]}
-                #{str_lvar_initialization}
-              VALUE ret = rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, 0);
-
-              // freeze all stacks
-              struct FASTRUBYTHREADDATA* thread_data = rb_current_thread_data();
-
-              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);
-
-                // freeze the complete chain of stack chunks
-                while (rb_stack_chunk != Qnil) {
-                  struct STACKCHUNK* stack_chunk;
-                  Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
-
-                  stack_chunk_freeze(stack_chunk);
-
-                  rb_stack_chunk = rb_ivar_get(rb_stack_chunk,#{intern_num :_parent_stack_chunk});
-                }
-              }
-
-              return ret;
-              }
-            "
-            }
-
-        end
-
-        rb_funcall_block_code_with_lambda = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
-            // block for call to #{call_tree[2]}
-            VALUE last_expression = Qnil;
-
-            #{@frame_struct} frame;
-            #{@frame_struct} *pframe = (void*)&frame;
-            #{@locals_struct} *plocals = (void*)_plocals;
-
-            frame.plocals = plocals;
-            frame.parent_frame = 0;
-            frame.return_value = Qnil;
-            frame.rescue = 0;
-            frame.targetted = 0;
-            frame.thread_data = rb_current_thread_data();
-
-              // 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);
-
-              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 ((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;
-
-                }
-              }
-
-            #{str_arg_initialization}
-            #{str_impl}
-
-             ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
-            return last_expression;
-          }
-        "
-        }
-
-        rb_funcall_block_code_proc_new = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
-            // block for call to #{call_tree[2]}
-            VALUE last_expression = Qnil;
-
-            #{@frame_struct} frame;
-            #{@frame_struct} *pframe = (void*)&frame;
-            #{@locals_struct} *plocals = (void*)_plocals;
-
-            frame.plocals = plocals;
-            frame.parent_frame = 0;
-            frame.return_value = Qnil;
-            frame.rescue = 0;
-            frame.targetted = 0;
-            frame.thread_data = rb_current_thread_data();
-
-              // 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);
-
-              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 {
-                        rb_raise(rb_eLocalJumpError, \"unexpected return\");
-                      }
-                    }
-              }
-
-            #{str_arg_initialization}
-            #{str_impl}
-
-            ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
-
-            return last_expression;
-          }
-        "
-        }
-
-
-        rb_funcall_block_code = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals) {
-            // block for call to #{call_tree[2]}
-            VALUE last_expression = Qnil;
-
-            #{@frame_struct} frame;
-            #{@frame_struct} *pframe = (void*)&frame;
-            #{@locals_struct} *plocals = (void*)_plocals;
-
-            frame.plocals = plocals;
-            frame.parent_frame = 0;
-            frame.return_value = Qnil;
-            frame.rescue = 0;
-            frame.targetted = 0;
-            frame.thread_data = rb_current_thread_data();
-
-            int aux = setjmp(frame.jmp);
-            if (aux != 0) {
-
-                if (aux == FASTRUBY_TAG_NEXT) {
-                  return pframe->thread_data->accumulator;
-                } else if (aux == FASTRUBY_TAG_REDO) {
-                  // do nothing and let execute the block again
-                } else {
-                  rb_jump_tag(aux);
-                  return frame.return_value;
-                }
-            }
-
-
-            #{str_arg_initialization}
-            #{str_impl}
-
-            return last_expression;
-          }
-        "
-        }
-
-
-        fastruby_str_arg_initialization = ""
-
-        if not args_tree
-          fastruby_str_arg_initialization = ""
-        elsif args_tree.first == :lasgn
-          fastruby_str_arg_initialization = "plocals->#{args_tree[1]} = argv[0];"
-        elsif args_tree.first == :masgn
-          arguments = args_tree[1][1..-1].map(&:last)
-
-          (0..arguments.size-1).each do |i|
-            fastruby_str_arg_initialization << "plocals->#{arguments[i]} = #{i} < argc ? argv[#{i}] : Qnil;\n"
-          end
-        end
-
-        block_code = proc { |name| "
-          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.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;
-
-            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);
-                  }
-                }
-
-            }
-
-            #{fastruby_str_arg_initialization}
-            #{str_impl}
-
-            return last_expression;
-          }
-        "
-        }
-
-        str_recv = "plocals->self"
-
-        if recv_tree
-           str_recv = to_c recv_tree
-        end
-
-        caller_code = nil
-        convention_global_name = add_global_name("int",0)
-
-        call_frame_struct_code = "
-                #{@block_struct} block;
-                #{@locals_struct} *plocals = (void*)param;
-
-                block.block_function_address = (void*)#{anonymous_function(&block_code)};
-                block.block_function_param = (void*)param;
-
-                // create a call_frame
-                #{@frame_struct} 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 = rb_current_thread_data();
-
-                VALUE old_call_frame = plocals->call_frame;
-                plocals->call_frame = LONG2FIX(&call_frame);
-
-                int aux = setjmp(call_frame.jmp);
-                if (aux != 0) {
-                  #{@frame_struct}* pframe_ = (void*)pframe;
-
-                  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;
-                  }
-                }
-        "
-
-        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);
-                plocals->call_frame = old_call_frame;
-                return ret;
-              }
-            "
-            }
-        end
-
-      inline_block "
-        if (#{convention_global_name}) {
-          return #{anonymous_function(&caller_code)}((VALUE)plocals, (VALUE)pframe);
-        } else {
-          return #{
-            frame_call(
-              protected_block(inline_block("
-
-              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
-
-              NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
-              void* caller_func;
-              void* block_func;
-
-              if (
-                node == #{@proc_node_gvar} ||
-                node == #{@lambda_node_gvar}
-                )  {
-
-                caller_func = #{anonymous_function(&rb_funcall_caller_code_with_lambda)};
-                block_func = #{anonymous_function(&rb_funcall_block_code_with_lambda)};
-              } else if (node == #{@procnew_node_gvar} && pframe->next_recv == rb_cProc) {
-                caller_func = #{anonymous_function(&rb_funcall_caller_code_with_lambda)};
-                block_func = #{anonymous_function(&rb_funcall_block_code_proc_new)};
-              } else {
-                caller_func = #{anonymous_function(&rb_funcall_caller_code)};
-                block_func = #{anonymous_function(&rb_funcall_block_code)};
-              }
-
-              return rb_iterate(
-                caller_func,
-                (VALUE)pframe,
-                block_func,
-                (VALUE)plocals);
-
-              "), true)
-            )
-          };
-        }
-      "
-    end
-
-    def frame_call(inner_code)
-      inline_block "
-
-
-        // create a call_frame
-        #{@frame_struct} call_frame;
-        typeof(call_frame)* 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();
-
-        VALUE old_call_frame = plocals->call_frame;
-        plocals->call_frame = LONG2FIX(&call_frame);
-
-                int aux = setjmp(call_frame.jmp);
-                if (aux != 0) {
-                  if (call_frame.targetted == 0) {
-                    longjmp(old_pframe->jmp,aux);
-                  }
-
-                  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};
-        plocals->call_frame = old_call_frame;
-        return ret;
-      "
-    end
-
-    def to_c_yield(tree)
-
-      block_code = proc { |name| "
-        static VALUE #{name}(VALUE frame_param, VALUE* block_args) {
-
-          #{@locals_struct} *plocals;
-          #{@frame_struct} *pframe;
-          pframe = (void*)frame_param;
-          plocals = (void*)pframe->plocals;
-
-          if (FIX2LONG(plocals->block_function_address) == 0) {
-            #{_raise("rb_eLocalJumpError", "no block given")};
-          } else {
-            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))FIX2LONG(plocals->block_function_address))(#{tree.size-1}, block_args, FIX2LONG(plocals->block_function_param), (VALUE)pframe);
-          }
-        }
-      "
-      }
-
-      new_yield_signature = tree[1..-1].map{|subtree| infer_type subtree}
-      # merge the new_yield_signature with the new
-      if @yield_signature
-        if new_yield_signature.size == @yield_signature.size
-          (0..new_yield_signature.size-1).each do |i|
-            if @yield_signature[i] != new_yield_signature[i]
-              @yield_signature[i] = nil
-            end
-          end
-        else
-          @yield_signature = new_yield_signature.map{|x| nil}
-        end
-      else
-        @yield_signature = new_yield_signature
-      end
-
-      ret = if tree.size > 1
-          anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){#{tree[1..-1].map{|subtree| to_c subtree}.join(",")}})"
-        else
-          anonymous_function(&block_code)+"((VALUE)pframe, (VALUE[]){})"
-        end
-
-      protected_block(ret, false)
-    end
-
-    def to_c_block(tree)
-
-      str = ""
-      str = tree[1..-2].map{ |subtree|
-        to_c(subtree)
-      }.join(";")
-
-      if tree[-1]
-
-        if tree[-1][0] != :return
-          str = str + ";last_expression = #{to_c(tree[-1])};"
-        else
-          str = str + ";#{to_c(tree[-1])};"
-        end
-      end
-
-      str << "return last_expression;"
-
-      inline_block str
-    end
-
-    def to_c_cvar(tree)
-      "rb_cvar_get(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]})"
-    end
-
-    def to_c_cvasgn(tree)
-      "__rb_cvar_set(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]},#{to_c tree[2]},Qfalse)"
-    end
-
-    def to_c_return(tree)
-      inline_block "
-        plocals->return_value = #{to_c(tree[1])};
-        ((typeof(pframe))FIX2LONG(plocals->pframe))->targetted = 1;
-        longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
-        return Qnil;
-        "
-    end
-
-    def to_c_break(tree)
-        inline_block(
-         "
-
-         VALUE value = #{tree[1] ? to_c(tree[1]) : "Qnil"};
-
-         typeof(pframe) target_frame_;
-         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
-
-         if (target_frame_ == 0) {
-            #{_raise("rb_eLocalJumpError","illegal break")};
-         }
-
-         plocals->call_frame = LONG2FIX(0);
-
-         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) {
-            #{_raise("rb_eLocalJumpError","illegal retry")};
-         }
-
-         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
-          _raise("rb_eLocalJumpError","illegal redo");
-      end
-    end
-
-    def to_c_next(tree)
-      if @on_block
-       inline_block "
-        pframe->thread_data->accumulator = #{tree[1] ? to_c(tree[1]) : "Qnil"};
-        longjmp(pframe->jmp,FASTRUBY_TAG_NEXT);
-        return Qnil;
-        "
-      else
-        _raise("rb_eLocalJumpError","illegal next");
-      end
-    end
-
-    def to_c_lit(tree)
-      literal_value tree[1]
-    end
-
-    def to_c_nil(tree)
-      "Qnil"
-    end
-
-    def to_c_str(tree)
-      literal_value tree[1]
-    end
-
-    def to_c_hash(tree)
-
-      hash_aset_code = ""
-      (0..(tree.size-3)/2).each do |i|
-        strkey = to_c tree[1 + i * 2]
-        strvalue = to_c tree[2 + i * 2]
-        hash_aset_code << "rb_hash_aset(hash, #{strkey}, #{strvalue});"
-      end
-
-      anonymous_function{ |name| "
-        static VALUE #{name}(VALUE 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;
-        }
-      " } + "((VALUE)pframe)"
-    end
-
-    def to_c_array(tree)
-      if tree.size > 1
-        strargs = tree[1..-1].map{|subtree| to_c subtree}.join(",")
-        "rb_ary_new3(#{tree.size-1}, #{strargs})"
-      else
-        "rb_ary_new3(0)"
-      end
-    end
-
-    def to_c_scope(tree)
-      if tree[1]
-        to_c(tree[1])
-      else
-        "Qnil"
-      end
-    end
-
-    def to_c_cdecl(tree)
-      if tree[1].instance_of? Symbol
-        inline_block "
-          // set constant #{tree[1].to_s}
-          VALUE val = #{to_c tree[2]};
-          rb_const_set(rb_cObject, #{intern_num tree[1]}, val);
-          return val;
-          "
-      elsif tree[1].instance_of? FastRuby::FastRubySexp
-
-        if tree[1].node_type == :colon2
-          inline_block "
-            // set constant #{tree[1].to_s}
-            VALUE val = #{to_c tree[2]};
-            VALUE klass = #{to_c tree[1][1]};
-            rb_const_set(klass, #{intern_num tree[1][2]}, val);
-            return val;
-            "
-        elsif tree[1].node_type == :colon3
-          inline_block "
-            // set constant #{tree[1].to_s}
-            VALUE val = #{to_c tree[2]};
-            rb_const_set(rb_cObject, #{intern_num tree[1][1]}, val);
-            return val;
-            "
-        end
-      end
-    end
-
-    def to_c_case(tree)
-
-      tmpvarname = "tmp" + rand(1000000).to_s;
-
-      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))
-              "
-                if (RTEST(#{to_c_call(calltree, tmpvarname)})) {
-                   return #{to_c(subtree[2])};
-                }
-
-              "
-        }.join("\n")
-
-      }.join("\n")
-
-      inline_block "
-
-        VALUE #{tmpvarname} = #{to_c tree[1]};
-
-        #{code};
-
-        return #{to_c tree[-1]};
-      "
-    end
-
-    def to_c_const(tree)
-      "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
-    end
-
-    def to_c_defn(tree)
-
-      method_name = tree[1]
-      args_tree = tree[2]
-
-      global_klass_variable = add_global_name("VALUE", "Qnil");
-
-      hash = Hash.new
-      value_cast = ( ["VALUE"]*(args_tree.size+2) ).join(",")
-
-      strmethodargs = ""
-      strmethodargs_class = (["self"] + args_tree[1..-1]).map{|arg| "CLASS_OF(#{arg.to_s})"}.join(",")
-
-      if args_tree.size > 1
-        strmethodargs = "self,block,(VALUE)&frame,#{args_tree[1..-1].map(&:to_s).join(",") }"
-      else
-        strmethodargs = "self,block,(VALUE)&frame"
-      end
-
-      strmethod_signature = (["self"] + args_tree[1..-1]).map { |arg|
-        "sprintf(method_name+strlen(method_name), \"%lu\", FIX2LONG(rb_obj_id(CLASS_OF(#{arg}))));\n"
-      }.join
-
-      anonymous_method_name = anonymous_function{ |anonymous_method_name| "VALUE #{anonymous_method_name}(#{(["self"]+args_tree[1..-1]).map{|arg| "VALUE #{arg}" }.join(",")}) {
-
-          VALUE klass = #{global_klass_variable};
-          char method_name[0x100];
-
-          method_name[0] = '_';
-          method_name[1] = 0;
-
-          sprintf(method_name+1, \"#{method_name}\");
-          #{strmethod_signature}
-
-          NODE* body;
-          ID id;
-
-          id = rb_intern(method_name);
-          body = rb_method_node(klass,id);
-
-          if (body == 0) {
-            VALUE argv_class[] = {#{strmethodargs_class} };
-            VALUE signature = rb_ary_new4(#{args_tree.size},argv_class);
-
-            VALUE mobject = rb_funcall(#{global_klass_variable}, #{intern_num :build}, 2, signature,rb_str_new2(#{method_name.to_s.inspect}));
-
-            struct METHOD {
-              VALUE klass, rklass;
-              VALUE recv;
-              ID id, oid;
-              int safe_level;
-              NODE *body;
-            };
-
-            struct METHOD *data;
-            Data_Get_Struct(mobject, struct METHOD, data);
-            body = data->body;
-
-            if (body == 0) {
-              rb_raise(rb_eRuntimeError,\"method not found after build: '%s'\", method_name);
-            }
-          }
-
-            if (nd_type(body) == NODE_CFUNC) {
-              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;
-              } frame;
-
-              frame.parent_frame = 0;
-              frame.rescue = 0;
-              frame.return_value = Qnil;
-              frame.thread_data = rb_current_thread_data();
-              frame.targetted = 0;
-
-              int argc = body->nd_argc;
-
-              VALUE block = Qfalse;
-
-              if (rb_block_given_p()) {
-                struct {
-                  void *block_function_address;
-                  void *block_function_param;
-                } block_struct;
-
-                block_struct.block_function_address = re_yield;
-                block_struct.block_function_param = 0;
-
-                block = (VALUE)&block_struct;
-              }
-
-              int aux = setjmp(frame.jmp);
-              if (aux != 0) {
-                if (aux == FASTRUBY_TAG_RAISE) {
-                  rb_funcall(self, #{intern_num :raise}, 1, frame.thread_data->exception);
-                }
-
-                if (frame.targetted == 0) {
-                    rb_jump_tag(aux);
-                }
-
-                return Qnil;
-              }
-
-              if (argc == #{args_tree.size+1}) {
-                return ((VALUE(*)(#{value_cast}))body->nd_cfnc)(#{strmethodargs});
-              } else if (argc == -1) {
-                VALUE argv[] = {#{(["block,(VALUE)&frame"]+args_tree[1..-1]).map(&:to_s).join(",")} };
-                return ((VALUE(*)(int,VALUE*,VALUE))body->nd_cfnc)(#{args_tree.size},argv,self);
-              } else if (argc == -2) {
-                VALUE argv[] = {#{(["block,(VALUE)&frame"]+args_tree[1..-1]).map(&:to_s).join(",")} };
-                return ((VALUE(*)(VALUE,VALUE))body->nd_cfnc)(self, rb_ary_new4(#{args_tree.size},argv));
-              } else {
-                rb_raise(rb_eArgError, \"wrong number of arguments (#{args_tree.size-1} for %d)\", argc);
-              }
-            }
-
-          return Qnil;
-        }"
-      }
-
-      alt_options = options.dup
-
-      alt_options.delete(:self)
-      alt_options.delete(:main)
-
-      inline_block "
-        #{global_klass_variable} = plocals->self;
-
-        // set tree
-        rb_funcall(#{literal_value FastRuby}, #{intern_num :set_tree}, 5,
-                #{global_klass_variable},
-                rb_str_new2(#{method_name.to_s.inspect}),
-                #{literal_value tree},
-                #{literal_value snippet_hash},
-                #{literal_value alt_options}
-
-                );
-
-        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, #{args_tree.size-1} );
-        "
-
-    end
-
-    def to_c_defs(tree)
-      args_tree = tree[3];
-
-      tmp = FastRuby.build_defs(tree)
-
-      extra_code << tmp[0]
-      @init_extra = @init_extra + tmp[2]
-
-      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*)#{global_entry(tree[1][1])}) ? #{literal_value "global-variable"} : Qnil"
-      elsif nt == :const
-      "rb_const_defined(rb_cObject, #{intern_num tree[1][1]}) ? #{literal_value "constant"} : Qnil"
-      elsif nt == :call
-      "rb_method_node(CLASS_OF(#{to_c tree[1][1]}), #{intern_num tree[1][2]}) ? #{literal_value "method"} : Qnil"
-      elsif nt == :yield
-        "rb_block_given_p() ? #{literal_value "yield"} : Qnil"
-      elsif nt == :ivar
-      "rb_ivar_defined(plocals->self,#{intern_num tree[1][1]}) ? #{literal_value "instance-variable"} : 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
-        literal_value "assignment"
-      else
-        literal_value "expression"
-      end
-    end
-
-    def initialize_method_structs(args_tree)
-      @locals_struct = "struct {
-        VALUE return_value;
-        VALUE pframe;
-        VALUE block_function_address;
-        VALUE block_function_param;
-        VALUE call_frame;
-        VALUE active;
-        #{@locals.map{|l| "VALUE #{l};\n"}.join}
-        #{args_tree[1..-1].map{|arg| "VALUE #{arg};\n"}.join};
-        }"
-
-    end
-
-    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|
-          "plocals->#{arg} = #{arg};\n"
-        }.join("") }
-
-        plocals->block_function_address = LONG2FIX(block_address);
-        plocals->block_function_param = LONG2FIX(block_param);
-
-        return #{to_c impl_tree};
-      }"
-
-      strargs2 = if args_tree.size > 1
-        "VALUE self, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
-      else
-        "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.rescue = 0;
-          frame.targetted = 0;
-          frame.thread_data = rb_current_thread_data();
-
-          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, #{intern_num :raise}, 1, frame.thread_data->exception);
-          }
-
-
-          return #{@alt_method_name + "_real"}(#{strmethodargs});
-      }
-      "
-    end
-
-    def add_main
-      if options[:main]
-
-        extra_code << "
-          static VALUE #{@alt_method_name}(VALUE self__);
-          static VALUE main_proc_call(VALUE self__, 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, 1);
-            rb_gv_set(\"$last_obj_proc\", newproc);
-
-            }
-          "
-      end
-    end
-
-    def define_method_at_init(klass,method_name, size, signature)
-      init_extra << "
-        {
-          VALUE method_name = rb_funcall(
-                #{literal_value FastRuby},
-                #{intern_num :make_str_signature},
-                2,
-                #{literal_value method_name},
-                #{literal_value signature}
-                );
-
-          rb_define_method(#{literal_value klass}, RSTRING(method_name)->ptr, #{alt_method_name}, #{size});
-        }
-      "
-    end
-
-    def to_c_method(tree)
-      method_name = tree[1]
-      args_tree = tree[2]
-      impl_tree = tree[3][1]
-
-      if (options[:main])
-        initialize_method_structs(args_tree)
-
-        strargs = if args_tree.size > 1
-          "VALUE block, VALUE _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
-        else
-          "VALUE block, VALUE _parent_frame"
-        end
-
-        ret = "VALUE #{@alt_method_name || method_name}() {
-
-          #{@locals_struct} *plocals;
-          #{@frame_struct} frame;
-          #{@frame_struct} *pframe;
-
-          frame.parent_frame = 0;
-          frame.return_value = 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 rb_stack_chunk = frame.thread_data->rb_stack_chunk;
-          struct STACKCHUNK* 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);
-          }
-
-          int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
-
-          plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
-          plocals->active = Qtrue;
-          plocals->pframe = LONG2FIX(&frame);
-          frame.plocals = plocals;
-
-          pframe = (void*)&frame;
-
-          VALUE last_expression = Qnil;
-
-          int aux = setjmp(pframe->jmp);
-          if (aux != 0) {
-            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;
-            }
-
-            plocals->active = Qfalse;
-            return plocals->return_value;
-          }
-
-          plocals->self = self;
-
-          #{args_tree[1..-1].map { |arg|
-            "plocals->#{arg} = #{arg};\n"
-          }.join("") }
-
-          plocals->block_function_address = LONG2FIX(0);
-          plocals->block_function_param = LONG2FIX(Qnil);
-          plocals->call_frame = LONG2FIX(0);
-
-          VALUE ret = #{to_c impl_tree};
-          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;
-          }
-
-          plocals->active = Qfalse;
-          return ret;
-
-        }"
-
-        add_main
-        ret
-      else
-
-        initialize_method_structs(args_tree)
-
-        strargs = if args_tree.size > 1
-          "VALUE block, VALUE _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
-        else
-          "VALUE block, VALUE _parent_frame"
-        end
-
-        ret = "VALUE #{@alt_method_name || method_name}(#{strargs}) {
-
-          #{@frame_struct} frame;
-          #{@frame_struct} *pframe;
-
-          frame.parent_frame = (void*)_parent_frame;
-          frame.return_value = 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 rb_stack_chunk = frame.thread_data->rb_stack_chunk;
-          struct STACKCHUNK* 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} *plocals;
-
-          int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
-
-          plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
-          frame.plocals = plocals;
-          plocals->active = Qtrue;
-          plocals->pframe = LONG2FIX(&frame);
-          plocals->call_frame = LONG2FIX(0);
-
-          pframe = (void*)&frame;
-
-          #{@block_struct} *pblock;
-          VALUE last_expression = Qnil;
-
-          int aux = setjmp(pframe->jmp);
-          if (aux != 0) {
-            plocals->active = Qfalse;
-
-            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;
-            }
-
-            if (pframe->targetted == 0) {
-              longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
-            }
-
-            return plocals->return_value;
-          }
-
-          plocals->self = self;
-
-          #{args_tree[1..-1].map { |arg|
-            "plocals->#{arg} = #{arg};\n"
-          }.join("") }
-
-          pblock = (void*)block;
-          if (pblock) {
-            plocals->block_function_address = LONG2FIX(pblock->block_function_address);
-            plocals->block_function_param = LONG2FIX(pblock->block_function_param);
-          } else {
-            plocals->block_function_address = LONG2FIX(0);
-            plocals->block_function_param = LONG2FIX(Qnil);
-          }
-
-          VALUE __ret = #{to_c impl_tree};
-          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;
-          }
-
-          plocals->active = Qfalse;
-          return __ret;
-        }"
-
-        add_main
-        ret
-      end
-    end
-
-    def locals_accessor
-      "plocals->"
-    end
-
-    def to_c_gvar(tree)
-      if (tree[1] == :$!)
-        "pframe->thread_data->exception"
-      else
-        "rb_gvar_get((struct global_entry*)#{global_entry(tree[1])})"
-      end
-    end
-
-    def to_c_gasgn(tree)
-      "_rb_gvar_set((void*)#{global_entry(tree[1])}, #{to_c tree[2]})"
-    end
-
-    def to_c_ivar(tree)
-      "rb_ivar_get(#{locals_accessor}self,#{intern_num tree[1]})"
-    end
-
-    def to_c_iasgn(tree)
-      "_rb_ivar_set(#{locals_accessor}self,#{intern_num tree[1]},#{to_c tree[2]})"
-    end
-
-    def to_c_colon3(tree)
-      "rb_const_get_from(rb_cObject, #{intern_num tree[1]})"
-    end
-    def to_c_colon2(tree)
-      inline_block "
-        VALUE klass = #{to_c tree[1]};
-
-      if (rb_is_const_id(#{intern_num tree[2]})) {
-        switch (TYPE(klass)) {
-          case T_CLASS:
-          case T_MODULE:
-            return rb_const_get_from(klass, #{intern_num tree[2]});
-            break;
-          default:
-            #{_raise("rb_eTypeError","not a class/module")};
-            break;
-        }
-      }
-      else {
-        return rb_funcall(klass, #{intern_num tree[2]}, 0, 0);
-      }
-
-        return Qnil;
-      "
-    end
-
-    def to_c_lasgn(tree)
-      if options[:validate_lvar_types]
-        klass = @infer_lvar_map[tree[1]]
-        if klass
-
-          verify_type_function = proc { |name| "
-            static VALUE #{name}(VALUE arg, void* pframe ) {
-              if (CLASS_OF(arg)!=#{literal_value klass}) {
-                #{_raise(literal_value(FastRuby::TypeMismatchAssignmentException), "Illegal assignment at runtime (type mismatch)")};
-              }
-              return arg;
-            }
-          "
-          }
-
-
-          "_lvar_assing(&#{locals_accessor}#{tree[1]}, #{anonymous_function(&verify_type_function)}(#{to_c tree[2]},pframe))"
-        else
-          "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
-        end
-      else
-        "_lvar_assing(&#{locals_accessor}#{tree[1]},#{to_c tree[2]})"
-      end
-    end
-
-    def to_c_lvar(tree)
-      locals_accessor + tree[1].to_s
-    end
-
-    def to_c_self(tree)
-      locals_accessor + "self"
-    end
-
-    def to_c_false(tree)
-      "Qfalse"
-    end
-
-    def to_c_true(tree)
-      "Qtrue"
-    end
-
-    def to_c_and(tree)
-      "(RTEST(#{to_c tree[1]}) && RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
-    end
-
-    def to_c_or(tree)
-      "(RTEST(#{to_c tree[1]}) || RTEST(#{to_c tree[2]})) ? Qtrue : Qfalse"
-    end
-
-    def to_c_not(tree)
-      "RTEST(#{to_c tree[1]}) ? Qfalse : Qtrue"
-    end
-
-    def to_c_if(tree)
-      condition_tree = tree[1]
-      impl_tree = tree[2]
-      else_tree = tree[3]
-
-      inline_block "
-          if (RTEST(#{to_c condition_tree})) {
-            last_expression = #{to_c impl_tree};
-          }#{else_tree ?
-            " else {
-            last_expression = #{to_c else_tree};
-            }
-            " : ""
-          }
-
-          return last_expression;
-      "
-    end
-
-    def to_c_rescue(tree)
-      if tree[1][0] == :resbody
-        else_tree = tree[2]
-
-        if else_tree
-          to_c else_tree
-        else
-          "Qnil"
-        end
-      else
-        resbody_tree = tree[2]
-        else_tree = nil
-        if tree[-1]
-          if tree[-1][0] != :resbody
-            else_tree = tree[-1]
-          end
-        end
-
-        catch_condition_array = []
-        lasgn_code = ""
-        resbody_code = to_c(resbody_tree[2])
-
-        rescue_code = ""
-
-        tree[1..-1].each do |resbody_tree|
-          next if resbody_tree[0] != :resbody
-
-          if resbody_tree[1].size == 1
-            resbody_tree[1][1] = [:const, :Exception]
-          end
-
-          if resbody_tree[1].last[0] == :lasgn
-            lasgn_code = to_c(resbody_tree[1].last)
-          end
-
-          resbody_tree[1][1..-1].each do |xtree|
-            if xtree[0] != :lasgn
-              trapcode = "rb_eException";
-
-              if xtree
-                trapcode = to_c(xtree)
-              end
-
-              catch_condition_array << "(rb_obj_is_kind_of(frame.thread_data->exception,#{trapcode}) == Qtrue)"
-            end
-          end
-
-          rescue_code << "
-            if (aux == FASTRUBY_TAG_RAISE) {
-              if (#{catch_condition_array.join(" || ")})
-              {
-                // trap exception
-                frame.targetted = 1;
-
-                #{lasgn_code};
-
-                 #{resbody_code};
-              }
-            }
-          "
-        end
-
-        frame_call(
-          frame(to_c(tree[1])+";","
-            #{rescue_code}
-          ", 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 _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 to_c_call(tree, repass_var = nil)
-      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 _raise(args[1],args[2])
-      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
-
-      recv = recv || s(:self)
-
-      recvtype = infer_type(recv)
-
-      if recvtype
-
-        address = nil
-        mobject = nil
-
-        inference_complete = true
-        signature = [recvtype]
-
-        args[1..-1].each do |arg|
-          argtype = infer_type(arg)
-          if argtype
-            signature << argtype
-          else
-            inference_complete = false
-          end
-        end
-
-        if repass_var
-          extraargs = ","+repass_var
-          extraargs_signature = ",VALUE " + repass_var
-        else
-          extraargs = ""
-          extraargs_signature = ""
-        end
-
-          if argnum == 0
-            value_cast = "VALUE,VALUE,VALUE"
-            "((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe)"
-          else
-            value_cast = ( ["VALUE"]*(args.size) ).join(",") + ",VALUE,VALUE"
-            "((VALUE(*)(#{value_cast}))#{encode_address(recvtype,signature,mname,tree,inference_complete)})(#{to_c recv}, Qfalse, (VALUE)pframe, #{strargs})"
-          end
-
-      else # else recvtype
-        if argnum == 0
-          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
-        else
-          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", true, repass_var)
-        end
-      end # if recvtype
-    end
-
-    def get_class_name(argument)
-      if argument.instance_of? Symbol
-        argument.to_s
-      elsif argument.instance_of? FastRuby::FastRubySexp
-        if argument[0] == :colon3
-          get_class_name(argument[1])
-        elsif argument[0] == :colon2
-          get_class_name(argument[2])
-        end
-      end
-    end
-
-    def get_container_tree(argument)
-      if argument.instance_of? Symbol
-        s(:self)
-      elsif argument.instance_of? FastRuby::FastRubySexp
-        if argument[0] == :colon3
-          s(:const, :Object)
-        elsif argument[0] == :colon2
-          argument[1]
-        end
-      end
-    end
-
-    def locals_scope(locals)
-       old_locals = @locals
-       old_locals_struct = @locals_struct
-
-       @locals = locals
-        @locals_struct = "struct {
-        VALUE return_value;
-        VALUE pframe;
-        VALUE block_function_address;
-        VALUE block_function_param;
-        VALUE call_frame;
-        VALUE active;
-        #{@locals.map{|l| "VALUE #{l};\n"}.join}
-        }"
-
-      begin
-        yield
-      ensure
-        @locals = old_locals
-        @locals_struct = old_locals_struct
-      end
-    end
-
-    def method_group(init_code, tree)
-
-      alt_locals = Set.new
-      alt_locals << :self
-
-      FastRuby::GetLocalsProcessor.get_locals(tree).each do |local|
-        alt_locals << local
-      end
-
-      fun = nil
-
-      locals_scope(alt_locals) do
-        fun = anonymous_function { |method_name| "static VALUE #{method_name}(VALUE self) {
-
-            #{@frame_struct} frame;
-            typeof(&frame) pframe = &frame;
-            #{@locals_struct} *plocals;
-
-            frame.parent_frame = 0;
-            frame.return_value = 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 rb_stack_chunk = frame.thread_data->rb_stack_chunk;
-            struct STACKCHUNK* 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);
-            }
-
-            int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
-
-            plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
-
-            frame.plocals = plocals;
-            plocals->active = Qtrue;
-            plocals->self = self;
-            plocals->call_frame = LONG2FIX(0);
-
-            #{to_c tree};
-
-            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;
-            }
-
-            plocals->active = Qfalse;
-            return Qnil;
-          }
-        "
-        }
-      end
-
-      inline_block("
-        #{init_code}
-
-        rb_funcall(tmpklass, #{intern_num :__id__},0);
-
-        #{fun}(tmpklass);
-        return Qnil;
-
-
-      ")
-
-    end
-
-
-
-    def to_c_class(tree)
-      str_class_name = get_class_name(tree[1])
-      container_tree = get_container_tree(tree[1])
-
-      if container_tree == s(:self)
-        method_group("
-                    VALUE tmpklass = rb_define_class(
-                      #{str_class_name.inspect},
-                      #{tree[2] ? to_c(tree[2]) : "rb_cObject"}
-                  );
-        ", tree[3])
-      else
-        method_group("
-                    VALUE container_klass = #{to_c(container_tree)};
-                    VALUE tmpklass = rb_define_class_under(
-                      container_klass,
-                      #{str_class_name.inspect},
-                      #{tree[2] ? to_c(tree[2]) : "rb_cObject"}
-                  );
-        ", tree[3])
-      end
-    end
-
-    def to_c_module(tree)
-      str_class_name = get_class_name(tree[1])
-      container_tree = get_container_tree(tree[1])
-
-      if container_tree == s(:self)
-        method_group("
-                      VALUE tmpklass = rb_define_module(#{str_class_name.inspect});
-        ", tree[2])
-      else
-        method_group("
-                      VALUE container_klass = #{to_c(container_tree)};
-                      VALUE tmpklass = rb_define_module_under(container_klass,#{str_class_name.inspect});
-        ", tree[2])
-      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]}) {
-            #{to_c tree[2]};
-          }
-          return Qnil;
-      ")
-    end
-
-    def infer_type(recv)
-      if recv[0] == :call
-        if recv[2] == :infer
-          eval(recv[3].last.last.to_s)
-        end
-      elsif recv[0] == :lvar
-        @infer_lvar_map[recv[1]]
-      elsif recv[0] == :self
-        @infer_self
-      elsif recv[0] == :str or recv[0] == :lit
-        recv[1].class
-      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 with_extra_inference(extra_inference)
-      previous_infer_lvar_map = @infer_lvar_map
-      begin
-        @infer_lvar_map = @infer_lvar_map.merge(extra_inference)
-        yield
-      ensure
-        @infer_lvar_map = previous_infer_lvar_map
-      end
-    end
-
-    def directive(tree)
-      recv = tree[1]
-      mname = tree[2]
-      args = tree[3]
-
-      if mname == :infer
-        return to_c(recv)
-      elsif mname == :lvar_type
-        lvar_name = args[1][1] || args[1][2]
-        lvar_type = eval(args[2][1].to_s)
-
-        @infer_lvar_map[lvar_name] = lvar_type
-        return ""
-      elsif mname == :block_given?
-        return "FIX2LONG(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 inline_block(code, repass_var = nil, nolocals = false)
-      anonymous_function{ |name| "
-        static VALUE #{name}(VALUE param#{repass_var ? ",void* " + repass_var : "" }) {
-          #{@frame_struct} *pframe = (void*)param;
-
-          #{nolocals ? "" : "#{@locals_struct} *plocals = (void*)pframe->plocals;"}
-          VALUE last_expression = Qnil;
-
-          #{code}
-          }
-        "
-      } + "((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(inner_code, always_rescue = false,repass_var = nil, nolocals = false)
-      body = nil
-      rescue_args = nil
-      if repass_var
-        body =  anonymous_function{ |name| "
-          static VALUE #{name}(VALUE param) {
-
-            #{@frame_struct} frame;
-
-            typeof(frame)* pframe;
-            typeof(frame)* parent_frame = ((typeof(pframe))((void**)param)[0]);
-
-            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;
-            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 {
-                rb_jump_tag(aux);
-              }
-            }
-
-            VALUE #{repass_var} = (VALUE)((void**)param)[1];
-            return #{inner_code};
-            }
-          "
-        }
-
-        rescue_args = ""
-        rescue_args = "(VALUE)(VALUE[]){(VALUE)pframe,(VALUE)#{repass_var}}"
-      else
-
-        body = anonymous_function{ |name| "
-          static VALUE #{name}(VALUE param) {
-            #{@frame_struct} frame;
-
-            typeof(frame)* pframe;
-            typeof(frame)* parent_frame = (typeof(pframe))param;
-
-            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;
-            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 {
-                rb_jump_tag(aux);
-              }
-            }
-
-            return #{inner_code};
-            }
-          "
-        }
-
-        rescue_args = "(VALUE)pframe"
-      end
-
-      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);
-          }
-
-        }
-        "
-
-      rescue_code = "rb_protect(#{body},#{rescue_args},&state)"
-
-      if always_rescue
-        inline_block "
-          int state;
-          pframe->last_error = Qnil;
-          VALUE result = #{rescue_code};
-
-          #{wrapper_code}
-
-          return result;
-        ", repass_var, nolocals
-      else
-        inline_block "
-          VALUE result;
-          int state;
-          pframe->last_error = Qnil;
-
-          if (pframe->rescue) {
-            result = #{rescue_code};
-            #{wrapper_code}
-          } else {
-            return #{inner_code};
-          }
-
-          return result;
-        ", repass_var, nolocals
-      end
-    end
-
-    def func_frame
-      "
-        #{@locals_struct} *plocals = malloc(sizeof(typeof(*plocals)));
-        #{@frame_struct} frame;
-        #{@frame_struct} *pframe;
-
-        frame.plocals = plocals;
-        frame.parent_frame = (void*)_parent_frame;
-        frame.return_value = 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);
-
-        pframe = (void*)&frame;
-
-        #{@block_struct} *pblock;
-        VALUE last_expression = Qnil;
-
-        int aux = setjmp(pframe->jmp);
-        if (aux != 0) {
-
-          if (pframe->targetted == 0) {
-            longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
-          }
-
-          return plocals->return_value;
-        }
-
-        plocals->self = self;
-      "
-    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("::")
-
-          init_extra << "
-            #{name} = rb_define_class_under(
-                    #{container_str == "" ? "rb_cObject" : literal_value(eval(container_str))}
-                    ,\"#{value.to_s.split("::").last}\"
-                    ,#{value.superclass == Object ? "rb_cObject" : literal_value(value.superclass)});
-
-            rb_funcall(#{name},#{intern_num :gc_register_object},0);
-          "
-        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 << "
-            #{name} = rb_marshal_load(rb_str_new(#{c_escape str}, #{str.size}));
-            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)
-      name = self.add_global_name("void*", 0);
-      cruby_name = self.add_global_name("void*", 0);
-      cruby_len = self.add_global_name("int", 0);
-      args_tree = call_tree[3]
-      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
-
-      ruby_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
-          #{@frame_struct}* pframe = frame;
-
-          VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
-
-          return #{
-            protected_block "rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
-            };
-        }
-        "
-      }
-
-      value_cast = ( ["VALUE"]*(args_tree.size) ).join(",")
-
-      cruby_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
-          #{@frame_struct}* pframe = frame;
-
-          VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
-
-          // call to #{recvtype}::#{mname}
-
-          if (#{cruby_len} == -1) {
-            return #{
-              protected_block "((VALUE(*)(int,VALUE*,VALUE))#{cruby_name})(#{args_tree.size-1}, ((VALUE*)method_arguments)+1,*((VALUE*)method_arguments));", false, "method_arguments"
-              };
-
-          } else if (#{cruby_len} == -2) {
-            return #{
-              protected_block "((VALUE(*)(VALUE,VALUE))#{cruby_name})(*((VALUE*)method_arguments), rb_ary_new4(#{args_tree.size-1},((VALUE*)method_arguments)+1) );", false, "method_arguments"
-              };
-
-          } else {
-            return #{
-              protected_block "((VALUE(*)(#{value_cast}))#{cruby_name})(((VALUE*)method_arguments)[0] #{inprocstrargs});", false, "method_arguments"
-              };
-          }
-        }
-        "
-      }
-
-      recvdump = nil
-
-      begin
-         recvdump = literal_value recvtype
-      rescue
-      end
-
-      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 convention = rb_funcall(recvtype, #{intern_num :convention}, 3,signature,mname,#{inference_complete ? "Qtrue" : "Qfalse"});
-            VALUE mobject = rb_funcall(recvtype, #{intern_num :method_from_signature},3,signature,mname,#{inference_complete ? "Qtrue" : "Qfalse"});
-
-            struct METHOD {
-              VALUE klass, rklass;
-              VALUE recv;
-              ID id, oid;
-              int safe_level;
-              NODE *body;
-            };
-
-            int len = 0;
-            void* address = 0;
-
-            if (mobject != Qnil) {
-
-              struct METHOD *data;
-              Data_Get_Struct(mobject, struct METHOD, data);
-
-              if (nd_type(data->body) == NODE_CFUNC) {
-              address = data->body->nd_cfnc;
-              len = data->body->nd_argc;
-              }
-            }
-
-            if (address==0) convention = #{literal_value :ruby};
-
-            #{convention_global_name ? convention_global_name + " = 0;" : ""}
-            if (recvtype != Qnil) {
-
-              if (convention == #{literal_value :fastruby}) {
-                #{convention_global_name ? convention_global_name + " = 1;" : ""}
-                #{name} = address;
-              } else if (convention == #{literal_value :cruby}) {
-                // cruby, wrap direct call
-                #{cruby_name} = address;
-
-                if (#{cruby_name} == 0) {
-                  #{name} = (void*)#{ruby_wrapper};
-                } else {
-                  #{cruby_len} = len;
-                  #{name} = (void*)#{cruby_wrapper};
-                }
-              } else {
-                // ruby, wrap rb_funcall
-                #{name} = (void*)#{ruby_wrapper};
-              }
-            } else {
-              // ruby, wrap rb_funcall
-              #{name} = (void*)#{ruby_wrapper};
-            }
-
-          }
-        "
-      else
-        init_extra << "
-        // ruby, wrap rb_funcall
-        #{name} = (void*)#{ruby_wrapper};
-        "
-      end
-
-      name
-    end
-
-    def intern_num(symbol)
-      @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) {
-          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.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
-          typeof(pframe) original_frame = pframe;
-          pframe = parent_frame;
-          #{not_jmp_code};
-
-          return last_expression;
-
-          }
-        "
-      } + "((VALUE)pframe)"
-    end
-  end
-end