fastruby 0.0.11 → 0.0.12

data/lib/fastruby/translator/iter.rb

@@ -0,0 +1,2594 @@
+=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