fastruby 0.0.21 → 0.0.22

data/lib/fastruby/translator/translator.rb

@@ -250,6 +250,8 @@ module FastRuby
 
 
     def _raise(class_tree, message_tree = nil)
+      @has_raise = true
+      @has_inline_block = true
       class_tree = to_c class_tree unless class_tree.instance_of? String
 
       if message_tree.instance_of? String
@@ -443,6 +445,8 @@ module FastRuby
         block_argument = tree[3].find{|x| x.to_s[0] == ?&}
         impl_tree = tree[4][1]
       end
+
+      @method_arguments = original_args_tree[1..-1]
       
       if "0".respond_to?(:ord)
         @alt_method_name = "_" + method_name.to_s.gsub("_x_", "_x__x_").gsub(/\W/){|x| "_x_#{x.ord}" } + "_" + rand(10000000000).to_s
@@ -450,6 +454,14 @@ module FastRuby
         @alt_method_name = "_" + method_name.to_s.gsub("_x_", "_x__x_").gsub(/\W/){|x| "_x_#{x[0]}" } + "_" + rand(10000000000).to_s
       end
 
+        @has_yield = false
+        @has_dynamic_call = false
+        @has_nonlocal_goto = false
+        @has_inline_block = (options[:main] or tree.find_tree(:lasgn))
+        @has_plocals_ref = false
+        @has_raise = false
+        @has_inline_c = false
+
       args_tree = original_args_tree.select{|x| x.to_s[0] != ?&}
 
         initialize_method_structs(original_args_tree)
@@ -534,6 +546,7 @@ module FastRuby
                     else
                         
                       if default_block_tree
+                        @has_inline_block = true
                         initialize_tree = default_block_tree[1..-1].find{|subtree| subtree[1] == arg_}
                         if initialize_tree
                           to_c(initialize_tree) + ";\n"
@@ -550,6 +563,7 @@ module FastRuby
                 }.join("")
                 
               if splat_arg
+                    @has_splat_args = true
                     if signature.size-1 < normalargsnum then
                       read_arguments_code << "
                         plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new3(0);
@@ -569,6 +583,8 @@ module FastRuby
           end
   
           if block_argument
+
+            @has_yield = true
   
             proc_reyield_block_tree = s(:iter, s(:call, nil, :proc, s(:arglist)), s(:masgn, s(:array, s(:splat, s(:lasgn, :__xproc_arguments)))), s(:yield, s(:splat, s(:lvar, :__xproc_arguments))))
   
@@ -615,11 +631,29 @@ module FastRuby
           }
           
         evaluate_tree = tree.transform &trs
+
+        impl_code = to_c(impl_tree, "last_expression")
+
+        put_setjmp = (@has_dynamic_call or @has_nonlocal_goto or @has_yield or @has_raise or @has_inline_c)
+        put_block_init = @has_yield
+        if options[:main]
+          put_block_init = false
+        end
         
         scope_mode = FastRuby::ScopeModeHelper.get_scope_mode(evaluate_tree)
+        if scope_mode == :dag or put_setjmp or put_block_init or @has_splat_args
+          put_frame = true
+          put_locals = true
+        else
+          put_frame = @has_inline_block
+          put_locals = @has_plocals_ref
+        end
+
         ret = "VALUE #{@alt_method_name || method_name}(#{options[:main] ? "VALUE self" : strargs}) {
           #{validate_arguments_code}
 
+#{if put_frame
+"
           #{@frame_struct} frame;
           #{@frame_struct} * volatile pframe;
           
@@ -629,12 +663,15 @@ module FastRuby
           frame.targetted = 0;
           frame.thread_data = #{options[:main] ? "0" : "((typeof(pframe))_parent_frame)->thread_data"};
           if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
-
-          int stack_chunk_instantiated = 0;
+"
+end
+}
           
 #{
 if scope_mode == :dag
   " 
+          int stack_chunk_instantiated = 0;
+
           volatile VALUE rb_previous_stack_chunk = Qnil;
           VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
           struct STACKCHUNK* volatile stack_chunk = 0;
@@ -670,6 +707,8 @@ else
 end
 }
 
+#{if put_locals and put_frame
+"
           plocals->parent_locals = (frame.thread_data->last_plocals);
           void* volatile old_parent_locals = frame.thread_data->last_plocals;
           
@@ -680,16 +719,26 @@ end
           }
           
           frame.plocals = plocals;
+          plocals->pframe = (&frame);
+          pframe = (void*)&frame;
+"
+end
+}
+
+#{if put_locals
+"
           plocals->active = Qtrue;
           plocals->targetted = Qfalse;
-          plocals->pframe = (&frame);
           plocals->call_frame = (0);
+"
+end
+}
 
-          pframe = (void*)&frame;
-
-          #{@block_struct} * volatile pblock;
           volatile VALUE last_expression = Qnil;
 
+#{if put_setjmp
+"
+
           int aux = setjmp(pframe->jmp);
           if (aux != 0) {
             plocals->active = Qfalse;
@@ -722,12 +771,21 @@ end
             
             return plocals->return_value;
           }
+"
+end
+}
 
+#{if put_locals
+"
           plocals->self = self;
+"
+end
+}
 
           #{
-          unless options[:main]
+          if put_block_init
             "
+            #{@block_struct} * volatile pblock;
             pblock = (void*)block;
             if (pblock) {
               plocals->block_function_address = pblock->block_function_address;
@@ -740,9 +798,14 @@ end
           end
           }
 
+#{if put_locals
+"
           #{read_arguments_code}
+"
+end
+}
 
-          #{to_c impl_tree, "last_expression"};
+          #{impl_code};
           
 local_return:
 #{
@@ -757,10 +820,21 @@ if scope_mode == :dag
 "
 end
 }
+
+#{if put_locals
+"
           plocals->active = Qfalse;
+"
+end
+}          
           
+#{if put_locals and put_frame
+"
           frame.thread_data->last_plocals = old_parent_locals;
-          
+"
+end
+}          
+
           return last_expression;
         }"
 
@@ -775,6 +849,7 @@ end
     end
 
     def locals_accessor
+      @has_plocals_ref = true
       "plocals->"
     end
 
@@ -830,9 +905,10 @@ end
       if mname == :infer
         return to_c(recv)
       elsif mname == :block_given?
+        @has_yield = true
         return "plocals->block_function_address == 0 ? Qfalse : Qtrue"
       elsif mname == :inline_c
-
+        @has_inline_c = true
         code = args[1][1]
 
         unless (args[2] == s(:false))
@@ -856,6 +932,8 @@ end
     end
 
     def inline_block_reference(arg, nolocals = false)
+      @has_inline_block = true
+
       code = nil
 
       if arg.instance_of? FastRuby::FastRubySexp
@@ -891,6 +969,7 @@ end
     end
 
     def inline_block(*args)
+      @has_inline_block = true
       
       unless block_given?
         code = args.first
@@ -1188,324 +1267,358 @@ fastruby_local_next:
 
       name
     end
+    
+    def dynamic_block_call(signature, mname)
+      dynamic_call(signature, mname, true)
+    end
 
-    def encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name = nil, is_block_call = false)
-      name = self.add_global_name("void*", 0);
-      address_name = self.add_global_name("void**", 0);
-      @last_address_name = address_name
-      cfunc_address_name = self.add_global_name("void**", 0);
-      cfunc_real_address_name  = self.add_global_name("void*", 0);
-      tree_pointer_name = self.add_global_name("VALUE*", 0);
-      
-      if call_tree[3].select{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
-        is_block_call = true
-      end
-      
-      args_tree = call_tree[3].reject{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
-      method_tree = nil
+    # returns a anonymous function who made a dynamic call
+    def dynamic_call(signature, mname, return_on_block_call = false, funcall_fallback = true, global_klass_variable = nil)
+      # TODO: initialize the table
+      @has_dynamic_call = true
+      max_argument_size = 0
+      recvtype = signature.first
 
-      begin
-        method_tree = recvtype.instance_method(@method_name.to_sym).fastruby.tree
-      rescue NoMethodError
+      unless recvtype
+        max_argument_size = max_argument_size + 1
       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(",")
+      compare_hash = {}
+      (1..signature.size-1).each do |j|
+        unless signature[j]
+          compare_hash[max_argument_size] = j-1
+          max_argument_size = max_argument_size + 1
+        end
+      end
 
-      if args_tree.size > 1
-        strargs_signature = "," + strargs_signature
-        toprocstrargs = "self,"+strargs
-        strargs = "," + strargs
-        inprocstrargs = ","+inprocstrargs
+      table_size = if compare_hash.size == 0
+        1
+      elsif compare_hash.size == 1
+        16
       else
-        toprocstrargs = "self"
+        64
       end
 
-      value_cast = ( ["VALUE"]*(args_tree.size) ).join(",") + ",VALUE,VALUE"
-
-      recvdump = nil
+      table_name = reserve_table(table_size, max_argument_size)
 
-      begin
-         recvdump = literal_value recvtype
-      rescue
-      end
-      
-      pureruby_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv){
-          #{@frame_struct}* pframe = frame;
-          VALUE method_arguments[3];
-          
-          method_arguments[0] = (VALUE)argc;
-          method_arguments[1] = (VALUE)argv;
-          method_arguments[2] = (VALUE)self;
-          
-          return #{
-            protected_block "last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", false, "method_arguments"
-            };
+      if recvtype
+        
+        init_extra << "{
+          memset(#{table_name},0,sizeof(#{table_name}));
+        
+          VALUE mname = #{literal_value mname};
+          VALUE recvtype = #{literal_value recvtype};
+          rb_funcall(#{literal_value FastRuby}, #{intern_num :set_builder_module}, 1, recvtype);
+          VALUE fastruby_method = rb_funcall(recvtype, #{intern_num :fastruby_method}, 1, mname);      
+          rb_iterate(#{anonymous_function{|funcname|
+            "static VALUE #{funcname}(VALUE recv) {
+              return rb_funcall(recv, #{intern_num :observe}, 1, #{literal_value(mname.to_s + "#" + table_name.to_s)});
+            }
+            "
+          }},fastruby_method,
+            #{anonymous_function{|funcname|
+              "static VALUE #{funcname}() {
+                // clear table
+                memset(#{table_name},0,sizeof(#{table_name}));
+                return Qnil;
+              }
+              " 
+            }
+            }
+          ,Qnil);
         }
-      "
-      }
-      
-      generic_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv){
+        "
+      else
         
-          #{@frame_struct}* pframe = frame;
-          VALUE method_arguments[4];
-          
-          method_arguments[0] = (VALUE)argc;
-          method_arguments[1] = (VALUE)argv;
-          method_arguments[2] = (VALUE)self;
-          method_arguments[3] = (VALUE)block;
-          
-          void* fptr = 0;
-          
-          if (*#{address_name} == 0) {
-            if (#{tree_pointer_name} != 0) {
-              if (*#{tree_pointer_name} != Qnil) {
-                VALUE signature = #{literal_value signature};
-                VALUE recvtype = #{recvdump};
-                VALUE mname = #{literal_value mname};
-                
-                rb_funcall(recvtype, #{intern_num :build}, 2, signature, mname);
+        # TODO: implemente this in ruby
+        init_extra << "
+        {
+          memset(#{table_name},0,sizeof(#{table_name}));
+        
+          rb_iterate(#{anonymous_function{|funcname|
+            "static VALUE #{funcname}(VALUE recv) {
+              return rb_funcall(recv, #{intern_num :observe_method_name}, 1, #{literal_value(mname.to_sym)});
+            }
+            "
+          }},#{literal_value FastRuby::Method},
+            #{anonymous_function{|funcname|
+              "static VALUE #{funcname}() {
+                // clear table
+                memset(#{table_name},0,sizeof(#{table_name}));
+                return Qnil;
               }
+              " 
             }
-          }
+            }
+          ,Qnil);
           
-          fptr = *#{address_name};
+        }
+        "
           
-            if (fptr == 0) {
-              fptr = *#{cfunc_address_name};
-              if (fptr != 0) {
-                return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*) ) (fptr) )(self,(VALUE)block,(VALUE)frame, argc, argv);  
-              }
-            }
+      end
 
-          if (fptr == 0) {
-            if (block==0) {
-              return #{
-                protected_block "last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", false, "method_arguments"
-                };
+      anonymous_function{|funcname| "
+        static VALUE #{funcname}(VALUE self,void* block,void* frame, int argc, VALUE* argv #{return_on_block_call ? ", int* block_call" : ""}){
+          void* fptr = 0;
+          #{if global_klass_variable
+          "
+          VALUE klass = #{global_klass_variable};
+          "
+          else
+          "
+          VALUE klass = CLASS_OF(self);
+          "
+          end
+          }
 
-            } else {
-              return #{
-                  protected_block "
-                        #{@block_struct} *pblock;
-                        pblock = (typeof(pblock))( ((VALUE*)method_arguments)[3] );
-                        last_expression = rb_iterate(
-                        #{anonymous_function{|name_|
-                          "
-                            static VALUE #{name_} (VALUE data) {
-                              VALUE* method_arguments = (VALUE*)data;
-                              return rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);
-                            }
-                          "
-                        }},
-                          (VALUE)method_arguments,
-                          
-                        #{anonymous_function{|name_|
-                          "
-                            static VALUE #{name_} (VALUE arg_, VALUE param, int argc, VALUE* argv) {
-
-           VALUE arg;
-            #{
-            # TODO: access directly to argc and argv for optimal execution
-            if RUBY_VERSION =~ /^1\.9/ 
-              "
-                if (TYPE(arg_) == T_ARRAY) {
-                  if (_RARRAY_LEN(arg_) <= 1) {
-                    arg = rb_ary_new4(argc,argv);
-                  } else {
-                    arg = arg_;
-                  }
-                } else {
-                  arg = rb_ary_new4(argc,argv);
-                }
+          char method_name[argc*40+64];
+          
+          unsigned int fptr_hash = 0;
+          int match = 1;
+
+          #{if table_size > 1
+          "
+            #{unless signature.first
+              "fptr_hash = klass;
               "
-            else
-              "arg = arg_;"
             end
             }
-        
-                              return rb_proc_call(param, arg);
-                            }
-                          "
-                        }},
-                          pblock->proc
-                        );
-                ", false, "method_arguments"
-                };
-            }
+            
+            #{
+            compare_hash.map { |k,v|
+              "if (#{v} < argc) {
+                   fptr_hash += CLASS_OF(argv[#{v}]);
+              }
+              "
+            }.join("\n")
+            };
 
-          } else {
-            return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*)) (fptr) )(self,(VALUE)block,(VALUE)frame,argc,argv);  
-          }
-        }
-        "
-      }
+            fptr_hash = fptr_hash % #{table_size};
 
+            int j = 0;
 
-      cfuncall1inprocargs = (0..args_tree.size-2).map{|x| "argv[#{x}]"}.join(",")
-      cfuncall1inprocargs = ","+cfuncall1inprocargs if cfuncall1inprocargs != ""
-      
-      cfunc_value_cast = (["VALUE"]*args_tree.size).join(",")
-      cfunc_wrapper = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
-          return rb_vm_call(ruby_current_thread, self, #{intern_num mname.to_sym}, argc, argv, #{cfunc_real_address_name});
-        }
-        "
-      }
-      
-      toprocstrargs = (0..25).map{|x| "arg#{x}"}.join(",")
-      strargs_signature = (0..25).map{|x| "VALUE arg#{x}"}.join(",")
-
-      cfunc_wrapper_1 = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
-            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(argc,argv,self);
-        }
-        "
-      }
-
-      cfunc_wrapper_2 = anonymous_function{ |funcname| "
-        static VALUE #{funcname}(VALUE self, void* block,void* frame, int argc, VALUE* argv){
-            VALUE args = rb_ary_new3(argc, argv);
-            return ( (VALUE(*)(VALUE,VALUE)) (#{cfunc_real_address_name}) )(self,args);
-        }
-        "
-      }
+            if (argc+15 != #{table_name}[fptr_hash].argc) {
+              match = 0;
+              goto does_not_match;
+            }
 
-      update_cfunc_method = anonymous_function{ |funcname| "
-          static VALUE #{funcname}(){
-                void** default_address = (void**)#{cfunc_address_name};
-                ID default_id = rb_intern(\"default\");
-                VALUE recvtype = #{recvdump};
+            #{unless recvtype
+              "
+              if (match == 1 && #{table_name}[fptr_hash].argument_type[0] != klass ) {
+                match = 0;
+                goto does_not_match;
+              }
+              "
+            end
+            }
 
-                if (1) {
-                  *default_address = 0;
-    
-    #{
-    if RUBY_VERSION == "1.9.2"
-      
-    "
-                  rb_method_entry_t* me = rb_method_entry(recvtype,#{intern_num mname});
-                  if (me != 0) {
-                    rb_method_definition_t* def = me->def;
-                    
-                    if (def->type == VM_METHOD_TYPE_CFUNC) {
-                      *default_address = #{cfunc_wrapper};
-                      #{cfunc_real_address_name} = (void*)me;
-                    }
-                  }
-    "
-    end
-    }
-                  if (default_address != 0) {
-                    if (recvtype != Qnil) { 
-                      rb_funcall(
-                          recvtype,
-                          #{intern_num :register_method_value}, 
-                          3,
-                          #{literal_value mname},
-                          PTR2NUM(default_id),
-                          PTR2NUM(default_address)
-                          );
-                    }
-                  }
-                }
-              return Qnil;
+            #{
+            compare_hash.map { |k,v|
+              "if (match == 1 && #{table_name}[fptr_hash].argument_type[#{k}] != CLASS_OF(argv[#{v}])) {
+                 match = 0;
+                 goto does_not_match;
+              }
+              "
+            }.join("\n")
+            };
+          "
+          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 rb_str_signature = rb_funcall(
-                                      #{literal_value FastRuby},
-                                      #{intern_num :make_str_signature},
-                                      2,
-                                      mname,
-                                      signature);
-
-
-
-            VALUE fastruby_method = rb_funcall(recvtype, #{intern_num :fastruby_method}, 1, mname);
-            #{tree_pointer_name} = (VALUE*)NUM2PTR(fastruby_method_tree_pointer(fastruby_method));
+          if (#{table_name}[fptr_hash].address == 0) match = 0;
+          if (match == 1) {
+            fptr = #{table_name}[fptr_hash].address;
+          } else {
+does_not_match:
+            method_name[0] = '_';
+            method_name[1] = 0;
+  
+            strncpy(method_name+1, \"#{mname}\",sizeof(method_name)-4);
+            sprintf(method_name+strlen(method_name), \"%li\", (long)NUM2PTR(rb_obj_id(CLASS_OF(self))));
             
+                        int i;
+                        for (i=0; i<argc; i++) {
+                          sprintf(method_name+strlen(method_name), \"%li\", (long)NUM2PTR(rb_obj_id(CLASS_OF(argv[i]))));
+                        }
+  
+            void** address = 0;
             ID id;
-            ID default_id = rb_intern(\"default\");
             VALUE rb_method_hash;
-            void** address = 0;
-            void** default_address = 0;
-            id = rb_intern(RSTRING_PTR(rb_str_signature));
-            rb_method_hash = rb_funcall(recvtype, #{intern_num :method_hash},1,mname);
-
-            if (rb_method_hash != Qnil) {
-              VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
-              if (tmp != Qnil) {
-                  address = (void*)NUM2PTR(tmp);
+  
+            id = rb_intern(method_name);
+            
+            if (rb_respond_to(klass, #{intern_num :method_hash})) {
+              rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value mname});
+              
+              if (rb_method_hash != Qnil) {
+                VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
+                if (tmp != Qnil) {
+                    address = (void**)NUM2PTR(tmp);
+                    fptr = *address;
+                }
               }
               
-              tmp = rb_hash_aref(rb_method_hash, PTR2NUM(default_id));
-              if (tmp != Qnil) {
-                 default_address = (void*)NUM2PTR(tmp);
+              if (fptr == 0) {
+                VALUE fastruby_method = rb_funcall(klass, #{intern_num :fastruby_method}, 1, #{literal_value mname});
+                VALUE tree = rb_funcall(fastruby_method, #{intern_num :tree}, 0,0);
+    
+                if (RTEST(tree)) {
+                  VALUE argv_class[argc+1];
+                                
+                  argv_class[0] = CLASS_OF(self); 
+                  for (i=0; i<argc; i++) {
+                  argv_class[i+1] = CLASS_OF(argv[i]);
+                  }
+                                
+                  VALUE signature = rb_ary_new4(argc+1,argv_class);
+                  
+                  rb_funcall(klass, #{intern_num :build}, 2, signature,rb_str_new2(#{mname.to_s.inspect}));
+        
+                  id = rb_intern(method_name);
+                  rb_method_hash = rb_funcall(klass, #{intern_num :method_hash},1,#{literal_value mname});
+                  
+                  if (rb_method_hash != Qnil) {
+                    VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
+                    if (tmp != Qnil) {
+                        address = (void**)NUM2PTR(tmp);
+                        fptr = *address;
+                    }
+                  }
+                  
+                  if (fptr == 0) {
+                    rb_raise(rb_eRuntimeError, \"Error: method not found after build\");
+                  }
+                }
               }
             }
             
-            if (default_address==0) {
-              default_address = malloc(sizeof(void*));
-              *default_address = 0;
-            }
-            #{cfunc_address_name} = default_address;
-            #{unless is_block_call
+            // insert the value on table
+            #{table_name}[fptr_hash].argc = argc+15;
+
+            #{unless recvtype
               "
-              #{update_cfunc_method}();
-              rb_iterate(#{anonymous_function{|funcname|
-                "static VALUE #{funcname}(VALUE recv) {
-                  return rb_funcall(recv, #{intern_num :observe}, 1, #{literal_value(@alt_method_name + "#" + cfunc_address_name)});
-                }
-                "
-              }},fastruby_method,#{update_cfunc_method},Qnil);
+              #{table_name}[fptr_hash].argument_type[0] = klass;
               "
             end
             }
 
-            if (address==0) {
-              address = malloc(sizeof(void*));
-              
-              if (recvtype != Qnil) { 
-                rb_funcall(
-                    recvtype,
-                    #{intern_num :register_method_value}, 
-                    3,
-                    #{literal_value mname},
-                    PTR2NUM(id),
-                    PTR2NUM(address)
-                    );
+            #{
+            compare_hash.map { |k,v|
+              "if (#{v} < argc) { 
+                #{table_name}[fptr_hash].argument_type[#{k}] = CLASS_OF(argv[#{v}]);
               }
-  
-              *address = 0; //(void*)
-            }
+              "
+            }.join("\n")
+            };
+
+            #{table_name}[fptr_hash].address = fptr;
+          }
+          
+          if (fptr != 0) {
+            return ((VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*))fptr)(self,(VALUE)block,(VALUE)frame, argc, argv);
+          }
+
+          #{if funcall_fallback
+          "
+       
+            #{@frame_struct}* pframe = frame;
+            VALUE method_arguments[4];
+            
+            method_arguments[0] = (VALUE)argc;
+            method_arguments[1] = (VALUE)argv;
+            method_arguments[2] = (VALUE)self;
+            method_arguments[3] = (VALUE)block;
+              
+              if (block == 0) {
+                return #{
+                  protected_block "
+                    last_expression = rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);", true, "method_arguments"
+                  };
             
-            #{address_name} = address;
-            #{name} = (void*)#{generic_wrapper};
+              } else {
+                #{
+                if return_on_block_call
+                  "*block_call = 1;
+                  return Qnil;
+                  "
+                else
+                  "
+                  return #{
+                      protected_block "
+                            #{@block_struct} *pblock;
+                            pblock = (typeof(pblock))( ((VALUE*)method_arguments)[3] );
+                            last_expression = rb_iterate(
+                            #{anonymous_function{|name_|
+                              "
+                                static VALUE #{name_} (VALUE data) {
+                                  VALUE* method_arguments = (VALUE*)data;
+                                  return rb_funcall2(((VALUE*)method_arguments)[2], #{intern_num mname.to_sym}, ((int*)method_arguments)[0], ((VALUE**)method_arguments)[1]);
+                                }
+                              "
+                            }},
+                              (VALUE)method_arguments,
+                              
+                            #{anonymous_function{|name_|
+                              "
+                                static VALUE #{name_} (VALUE arg_, VALUE param, int argc, VALUE* argv) {
+                                #{@block_struct}* pblock = (void*)param;
+                                
+                                  if (pblock->proc != Qnil) {
+                                     VALUE arg;
+                                      #{
+                                      # TODO: access directly to argc and argv for optimal execution
+                                      if RUBY_VERSION =~ /^1\.9/ 
+                                        "
+                                          if (TYPE(arg_) == T_ARRAY) {
+                                            if (_RARRAY_LEN(arg_) <= 1) {
+                                              arg = rb_ary_new4(argc,argv);
+                                            } else {
+                                              arg = arg_;
+                                            }
+                                          } else {
+                                            arg = rb_ary_new4(argc,argv);
+                                          }
+                                        "
+                                      else
+                                        "arg = arg_;"
+                                      end
+                                      }
+              
+                                    return rb_proc_call(pblock->proc, arg);
+      
+                                  } else {
+                                      #{
+                                      # TODO: access directly to argc and argv for optimal execution
+                                      if RUBY_VERSION =~ /^1\.9/
+                                        "return ((VALUE(*)(int,VALUE*,VALUE,VALUE))pblock->block_function_address)(argc,argv,(VALUE)pblock->block_function_param,(VALUE)0);" 
+                                      else
+                                        "return Qnil;"
+                                      end
+                                      }
+                                  }
+                                
+                                }
+                              "
+                            }},
+                              (VALUE)pblock
+                            );
+                    ", true, "method_arguments"
+                    };
+                  "
+                end
+                }
+              }
+            "
+            else
+            "
+              rb_raise(rb_eRuntimeError, \"Error: invalid dynamic call for defn\");
+              return Qnil;
+            "
+            end
           }
+        }
         "
-      else
-        init_extra << "
-        // ruby, wrap rb_funcall
-        #{name} = (void*)#{pureruby_wrapper};
-        "
-      end
-
-      name
+      }
     end
 
     def intern_num(symbol)
@@ -1523,6 +1636,20 @@ fastruby_local_next:
 
       name
     end
+    
+    def reserve_table(size, argument_count)
+      name = "glb_table" + rand(1000000000).to_s
+      
+      extra_code << "
+        static struct {
+          VALUE argument_type[#{argument_count}];
+          void* address;
+          int argc;
+        } #{name}[#{size}];
+      "
+      
+      name
+    end
 
     def add_global_name(ctype, default)
       name = "glb" + rand(1000000000).to_s