fastruby 0.0.16 → 0.0.17

data/lib/fastruby/translator/modules/iter.rb

@@ -23,7 +23,7 @@ module FastRuby
     
     register_translator_module IterTranslator
 
-    def to_c_iter(tree)
+    def to_c_iter(tree, result_var = nil)
 
       call_tree = tree[1]
       args_tree = tree[2]
@@ -31,7 +31,11 @@ module FastRuby
 
       directive_code = directive(call_tree)
       if directive_code
-        return directive_code
+        if result_var
+          return "#{result_var} = #{directive_code};\n"
+        else
+          return directive_code
+        end
       end
 
       other_call_tree = call_tree.dup
@@ -75,31 +79,9 @@ module FastRuby
       str_arg_initialization = ""
 
       str_impl = ""
-
-        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
+      on_block do
+        str_impl = to_c(anonymous_impl, "last_expression")
+      end     
 
         if not args_tree
         elsif args_tree.first == :lasgn
@@ -154,21 +136,70 @@ module FastRuby
             end
           end
         end
-        rb_funcall_caller_code = nil
+          str_recv = "pframe->next_recv"
+          str_recv = "plocals->self" unless recv_tree
 
-        if call_args_tree.size > 1
+          strargs = if call_args_tree.size > 1
+                      "," + (0..call_args_tree.size-2).map{|i| "arg#{i}"}.join(",")
+                  else
+                    ""
+                  end
+          
+          str_evaluate_args = ""
 
-          str_recv = "pframe->next_recv"
+            rb_funcall_caller_code = proc { |name, call_type| "
+              static VALUE #{name}(VALUE param) {
+                // call to #{call_tree[2]}
+                 VALUE last_expression = Qnil;
+  
+                #{str_lvar_initialization}
+                #{str_evaluate_args};
+                
+              VALUE ret = rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, #{call_args_tree.size-1} #{strargs});
+                #{
+                if call_type == :lambda
+              "
 
-          str_recv = "plocals->self" unless recv_tree
+              // 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});
+                }
+              }
+              "
+              end
+            }
+              return ret;
+              }
+            "
+            }
+
+
+          if call_args_tree.size > 1
             if call_args_tree.last[0] == :splat
-              rb_funcall_caller_code = proc { |name| "
+              rb_funcall_caller_code = proc { |name,call_type| "
                 static VALUE #{name}(VALUE param) {
                   // call to #{call_tree[2]}
   
+                  VALUE last_expression = Qnil;
                   #{str_lvar_initialization}
                   
-                  VALUE array = #{to_c call_args_tree.last[1]};
+                  VALUE array = Qnil;
+                  
+                  #{to_c call_args_tree.last[1], "array"};
                   
                   if (TYPE(array) != T_ARRAY) {
                     array = rb_ary_new4(1,&array);
@@ -177,11 +208,15 @@ module FastRuby
                   int argc = #{call_args_tree.size-2};
                   VALUE argv[#{call_args_tree.size} + _RARRAY_LEN(array)];
                   
+                  VALUE aux_ = Qnil;;
                   #{
                     i = -1
                     call_args_tree[1..-2].map {|arg|
                       i = i + 1
-                      "argv[#{i}] = #{to_c arg}"
+                      "
+                      #{to_c arg, "aux_"};
+                      argv[#{i}] = aux_;
+                      "
                     }.join(";\n")
                   };
                   
@@ -196,67 +231,24 @@ module FastRuby
                   return rb_funcall2(#{str_recv}, #{intern_num call_tree[2]}, argc, argv);
                 }
               "
-              }
+              }   
             else
-              str_called_code_args = call_args_tree[1..-1].map{ |subtree| to_c subtree }.join(",")
-              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});
-                }
+              str_evaluate_args = "
+                  #{
+                    (0..call_args_tree.size-2).map{|i|
+                      "VALUE arg#{i} = Qnil;"
+                    }.join("\n")
+                  }
+                  
+                  #{
+                    (0..call_args_tree.size-2).map{|i|
+                      to_c(call_args_tree[i+1], "arg#{i}")+";"
+                    }.join("\n")
+                  }
               "
-              }
             end
-            
-            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
 
-        end
-        
         argument_array_read = "
             VALUE arg;
             #{
@@ -279,17 +271,16 @@ module FastRuby
             }
         "
         
-
-        rb_funcall_block_code_with_lambda = proc { |name| "
+        rb_funcall_block_code = proc { |name,call_type| "
           static VALUE #{name}(VALUE arg_, VALUE _plocals, int argc, VALUE* argv) {
             // block for call to #{call_tree[2]}
             #{argument_array_read}
-            
-            VALUE last_expression = Qnil;
+
+            volatile VALUE last_expression = Qnil;
 
             #{@frame_struct} frame;
-            #{@frame_struct} *pframe = (void*)&frame;
-            #{@locals_struct} *plocals = (void*)_plocals;
+            #{@frame_struct} * volatile pframe = (void*)&frame;
+            #{@locals_struct} * volatile plocals = (void*)_plocals;
 
             frame.plocals = plocals;
             frame.parent_frame = 0;
@@ -298,80 +289,50 @@ module FastRuby
             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);
+            #{str_arg_initialization}
 
-              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;
+            #{
+            if call_type == :lambda or call_type == :proc_new
+            "
+              void* volatile old_call_frame = ((typeof(plocals))(pframe->plocals))->call_frame;
+              ((typeof(plocals))(pframe->plocals))->call_frame = pframe;
+            "
+            end
+            }
+
+            int aux = setjmp(frame.jmp);
+            if (aux != 0) {
+
+                if (aux == FASTRUBY_TAG_NEXT) {
+                  last_expression = pframe->thread_data->accumulator;
+                  goto fastruby_local_next;
                 } else if (aux == FASTRUBY_TAG_REDO) {
                   // do nothing and let execute the block again
+#{
+if call_type == :lambda
+"
+
+                } else if (aux == FASTRUBY_TAG_BREAK) {
+                  last_expression = frame.return_value;
+                  goto fastruby_local_next;
+"
+end
+}
+#{
+if call_type == :lambda or call_type == :proc_new
+"
                 } else if (aux == FASTRUBY_TAG_RAISE) {
                    rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.thread_data->exception);
                    return Qnil;
+"
+end
+}
                 } else {
-                  if (aux == FASTRUBY_TAG_RETURN) {
-                    if (plocals->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, int argc, VALUE* argv) {
-            // block for call to #{call_tree[2]}
-            #{argument_array_read}
-            
-            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 {
+#{
+case call_type
+when :proc_new
+"
+_local_return:
                       if (plocals->targetted == 1) {
                         if (plocals->active == Qfalse) {
                           rb_raise(rb_eLocalJumpError,\"return from proc-closure\");
@@ -382,110 +343,86 @@ module FastRuby
                       } 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, int argc, VALUE* argv) {
-            // block for call to #{call_tree[2]}
-            #{argument_array_read}
-
-            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) {
+"
+when :lambda
+"
+                  if (aux == FASTRUBY_TAG_RETURN) {
+                    if (plocals->targetted == 1) {
+                      last_expression = ((typeof(plocals))(pframe->plocals))->return_value;
+                      goto fastruby_local_next;
 
-                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 {
+                    } else {
+                      rb_raise(rb_eLocalJumpError, \"unexpected return\");
+                    }
+                  } else {
+                    rb_raise(rb_eLocalJumpError, \"unexpected return\");
+                  }
+"
+else
+  "
                   frb_jump_tag(aux);
                   return frame.return_value;
-                }
-            }
-
-
-            #{str_arg_initialization}
-            #{str_impl}
-
-            return last_expression;
-          }
-        "
-        }
-
-        rb_funcall_block_code_callcc = proc { |name| "
-          static VALUE #{name}(VALUE arg, VALUE _plocals, int argc, VALUE* argv) {
-            #{
-            # TODO: access directly to argc and argv for optimal execution
-            if RUBY_VERSION =~ /^1\.9/ 
-              "arg = rb_ary_new4(argc,argv);"
-            end
-            }
-          
-            // 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) {
+  "
+end
+}
 
-                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 {
-                  frb_jump_tag(aux);
-                  return frame.return_value;
                 }
             }
-            
+
+          #{
+          if call_type == :callcc
+          "
             if (rb_obj_is_kind_of(arg, rb_const_get(rb_cObject, #{intern_num :Continuation}))) {
               struct FASTRUBYTHREADDATA* thread_data = frame.thread_data;
               rb_ivar_set(arg,#{intern_num :__stack_chunk},thread_data->rb_stack_chunk);
             }
+          "
+          end
+          }
 
-            #{str_arg_initialization}
-            #{str_impl}
+fastruby_local_redo:
+            #{str_impl};
 
+#{
+case call_type
+when :proc_new
+"
             return last_expression;
-          }
+local_return:
+            aux = FASTRUBY_TAG_RETURN;
+            plocals->return_value = last_expression;
+            plocals->targetted = 1;
+            goto _local_return;
+"
+when :lambda
+"
+local_return:
+"
+else
+" 
+            return last_expression;
+local_return:            
+            plocals->return_value = last_expression;
+            plocals->targetted = 1;
+            frb_jump_tag(FASTRUBY_TAG_RETURN);
+"
+end
+}
+
+
+fastruby_local_next:
+#{
+if call_type == :proc_new or call_type == :lambda
+"
+  ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
+"
+end
+}
+            return last_expression;          
+            }
         "
         }
 
-
         fastruby_str_arg_initialization = ""
 
         if not args_tree
@@ -515,11 +452,11 @@ module FastRuby
         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;
+            volatile VALUE last_expression = Qnil;
             #{@frame_struct} frame;
-            #{@frame_struct} *pframe = (void*)&frame;
-            #{@frame_struct} *parent_frame = (void*)_parent_frame;
-            #{@locals_struct} *plocals;
+            #{@frame_struct} * volatile pframe = (void*)&frame;
+            #{@frame_struct} * volatile parent_frame = (void*)_parent_frame;
+            #{@locals_struct} * volatile plocals;
 
             frame.plocals = (void*)_locals;
             frame.parent_frame = parent_frame;
@@ -531,6 +468,8 @@ module FastRuby
 
             plocals = frame.plocals;
 
+            #{fastruby_str_arg_initialization}
+
             int aux = setjmp(frame.jmp);
             if (aux != 0) {
                 if (pframe->targetted == 0) {
@@ -545,63 +484,35 @@ module FastRuby
 
             }
 
-            #{fastruby_str_arg_initialization}
-            #{str_impl}
+fastruby_local_redo:
+            #{str_impl};
 
             return last_expression;
-          }
+local_return:
+            plocals->return_value = last_expression;
+            plocals->targetted = 1;
+            longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
+fastruby_local_next:
+            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;
-
-                block.block_function_address = (void*)#{anonymous_function(&block_code)};
-                block.block_function_param = (void*)plocals;
-
-                // 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;
-                  }
-                }
-        "
         
           precode = "
               struct FASTRUBYTHREADDATA* thread_data = 0;
-              VALUE saved_rb_stack_chunk = Qnil; 
+              VALUE saved_rb_stack_chunk = Qnil;
+              
+              VALUE next_recv = plocals->self;
+              
+              #{
+                if recv_tree
+                  to_c recv_tree, "next_recv"
+                end
+              };
 
-              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
+              pframe->next_recv = next_recv;
 #ifdef RUBY_1_8
               NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
 #endif              
@@ -639,9 +550,9 @@ module FastRuby
           
         
           funcall_call_code = "
-          return #{
+          #{
             frame_call(
-              protected_block(inline_block("
+              "ret = " + protected_block("
               
               void* caller_func;
               void* block_func;
@@ -662,21 +573,21 @@ module FastRuby
                 node == #{@lambda_node_gvar}
                 )  {
 
-                caller_func = #{anonymous_function(&rb_funcall_caller_code_with_lambda)};
-                block_func = #{anonymous_function(&rb_funcall_block_code_with_lambda)};
+                caller_func = #{anonymous_function(:lambda,&rb_funcall_caller_code)};
+                block_func = #{anonymous_function(:lambda,&rb_funcall_block_code)};
               } 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)};
+                caller_func = #{anonymous_function(:lambda,&rb_funcall_caller_code)};
+                block_func = #{anonymous_function(:proc_new,&rb_funcall_block_code)};
               } else if (node == #{@callcc_node_gvar}) {
-                caller_func = #{anonymous_function(&rb_funcall_caller_code)};
-                block_func = #{anonymous_function(&rb_funcall_block_code_callcc)};
+                caller_func = #{anonymous_function(:normal,&rb_funcall_caller_code)};
+                block_func = #{anonymous_function(:callcc,&rb_funcall_block_code)};
               } else {
-                caller_func = #{anonymous_function(&rb_funcall_caller_code)};
-                block_func = #{anonymous_function(&rb_funcall_block_code)};
+                caller_func = #{anonymous_function(:normal,&rb_funcall_caller_code)};
+                block_func = #{anonymous_function(:normal,&rb_funcall_block_code)};
               }
               
 
-              VALUE ret = rb_iterate(
+              last_expression = rb_iterate(
                 caller_func,
                 (VALUE)pframe,
                 block_func,
@@ -688,7 +599,7 @@ module FastRuby
                 current_plocals = pframe->thread_data->last_plocals;
                 while (current_plocals) {
                   current_plocals->active = Qfalse;
-                  current_plocals = (typeof(current_plocals))FIX2LONG(current_plocals->parent_locals); 
+                  current_plocals = (typeof(current_plocals))(current_plocals->parent_locals); 
                 }
                 
                 // restore last_plocals
@@ -699,57 +610,83 @@ module FastRuby
                 
                 while (current_plocals) {
                   current_plocals->active = Qtrue;
-                  current_plocals = (typeof(current_plocals))FIX2LONG(current_plocals->parent_locals); 
+                  current_plocals = (typeof(current_plocals))(current_plocals->parent_locals); 
                 }
               }
-
-              return ret;
-              "), true), precode, postcode
+              ", true), precode, postcode
             )
           };
           "        
 
       recvtype = nil if call_args_tree.size > 1 ? call_args_tree.last[0] == :splat : false
       unless recvtype
-        inline_block "
-          #{funcall_call_code}
-        "
+        if result_var
+          "#{result_var} = #{funcall_call_code};"
+        else
+          funcall_call_code
+        end
       else
         encoded_address = encode_address(recvtype,signature,mname,call_tree,inference_complete,convention_global_name)
 
-        fastruby_call_code = if call_args_tree.size > 1
+        if call_args_tree.size > 1
           value_cast = ( ["VALUE"]*(call_tree[3].size) ).join(",") + ", VALUE, VALUE"
-
-            "
-                // call to #{call_tree[2]}
-                #{call_frame_struct_code}
-
-                VALUE ret = ((VALUE(*)(#{value_cast}))#{encoded_address})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame, #{str_called_code_args});
-                plocals->call_frame = old_call_frame;
-                return ret;
-            "
+          strargs = "," + (0..call_args_tree.size-2).map{|i| "arg#{i}"}.join(",")
         else
-            "
-                #{call_frame_struct_code}
+          value_cast = "VALUE,VALUE,VALUE"
+          strargs = ""
+        end
 
+        fastruby_call_code = "
                 // call to #{call_tree[2]}
-                VALUE ret = ((VALUE(*)(VALUE,VALUE,VALUE))#{encoded_address})(#{str_recv}, (VALUE)&block, (VALUE)&call_frame);
-                plocals->call_frame = old_call_frame;
-                return ret;
+                #{
+                if call_args_tree.size > 1
+                  str_evaluate_args
+                end
+                };
+                
+                VALUE recv = plocals->self;
+                
+                #{
+                if recv_tree
+                 to_c recv_tree, "recv" 
+                end
+                } 
+
+                ret = ((VALUE(*)(#{value_cast}))#{encoded_address})(recv, (VALUE)&block, (VALUE)&call_frame #{strargs});
             "
-        end
         
-        inline_block "
+        code = "
           if (#{@last_address_name} == 0) {
-            #{funcall_call_code}
+            return #{funcall_call_code};
           } else {
+            #{if recvtype and inference_complete
+              "if (*#{@last_address_name} == 0) {
+                rb_funcall(#{literal_value recvtype},#{intern_num :build}, 2, #{literal_value signature}, #{literal_value mname});
+              }
+              "
+            end
+            }
             if (*#{@last_address_name} == 0) {
-              #{funcall_call_code}
+              return #{funcall_call_code};
             } else {
               #{fastruby_call_code}
             }
           }
         "
+        
+        fastruby_precode = "                 #{@block_struct} block;
+
+                block.block_function_address = ((void*)#{anonymous_function(&block_code)});
+                block.block_function_param = ((void*)plocals);
+                block.proc = Qnil;                
+                "
+        
+        if result_var
+          "#{result_var} = #{frame_call(code,fastruby_precode,"")}"
+        else
+          frame_call(code,fastruby_precode,"")
+        end
+        
       end
     end
   end