fastruby 0.0.16 → 0.0.17

data/lib/fastruby/translator/translator.rb

@@ -25,7 +25,7 @@ require "fastruby/method_extension"
 require "fastruby/set_tree"
 require "fastruby/exceptions"
 require "fastruby/translator/translator_modules"
-
+require "fastruby/translator/scope_mode_helper"
 
 module FastRuby
   class Context
@@ -65,6 +65,7 @@ module FastRuby
       @block_struct = "struct {
         void* block_function_address;
         void* block_function_param;
+        VALUE proc;
       }"
 
         extra_code << "
@@ -83,6 +84,9 @@ module FastRuby
         #define FASTRUBY_TAG_RETRY 0x85
         #define TAG_RAISE 0x6
 
+# define PTR2NUM(x)   (ULONG2NUM((unsigned long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+
         #ifndef __INLINE_FASTRUBY_BASE
         #include \"#{FastRuby.fastruby_load_path}/../ext/fastruby_base/fastruby_base.inl\"
         #define __INLINE_FASTRUBY_BASE
@@ -142,7 +146,7 @@ module FastRuby
          #{@frame_struct}* pframe;
          pframe = (typeof(pframe))_parent_frame;
 
-         return #{protected_block("rb_yield_splat(*(VALUE*)yield_args_p)",true,"yield_args_p",true)};
+         return #{protected_block("last_expression = rb_yield_splat(*(VALUE*)yield_args_p)",true,"yield_args_p",true)};
         }"
 
         extra_code << "static VALUE _rb_ivar_set(VALUE recv,ID idvar, VALUE value) {
@@ -179,15 +183,26 @@ module FastRuby
       end
     end
 
-    def to_c(tree)
+    def to_c(tree, result_variable = nil)
       return "Qnil" unless tree
-      send("to_c_" + tree[0].to_s, tree);
+      
+      mname = "to_c_" + tree[0].to_s
+      
+      if result_variable
+        if method(mname).arity == 1
+          "#{result_variable} = #{send(mname, tree)};\n"
+        else
+          send(mname, tree, result_variable)
+        end 
+      else
+        send(mname, tree)
+      end
     end
 
-    def anonymous_function
+    def anonymous_function(*x)
 
       name = "anonymous" + rand(10000000).to_s
-      extra_code << yield(name)
+      extra_code << yield(name,*x)
 
       name
     end
@@ -195,10 +210,10 @@ module FastRuby
     def frame_call(inner_code, precode = "", postcode = "")
       inline_block "
 
-
+        volatile VALUE ret = Qnil;
         // create a call_frame
         #{@frame_struct} call_frame;
-        typeof(call_frame)* old_pframe = (void*)pframe;
+        typeof(call_frame)* volatile old_pframe = (void*)pframe;
 
         pframe = (typeof(pframe))&call_frame;
 
@@ -209,8 +224,8 @@ module FastRuby
         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);
+        void* volatile old_call_frame = plocals->call_frame;
+        plocals->call_frame = &call_frame;
 
         #{precode}
 
@@ -235,7 +250,7 @@ module FastRuby
                 }
                 
 
-        VALUE ret = #{inner_code};
+        #{inner_code};
         
         #{postcode}
         
@@ -246,14 +261,15 @@ module FastRuby
 
     def initialize_method_structs(args_tree)
       @locals_struct = "struct {
-        VALUE return_value;
-        VALUE parent_locals;
-        VALUE pframe;
-        VALUE block_function_address;
-        VALUE block_function_param;
-        VALUE call_frame;
+        int size;        
+        void* call_frame;
+        void* parent_locals;
+        void* pframe;
+        void* block_function_address;
+        void* block_function_param;
         VALUE active;
         VALUE targetted;
+        VALUE return_value;
         #{@locals.map{|l| "VALUE #{l};\n"}.join}
         }"
 
@@ -307,9 +323,9 @@ module FastRuby
           rb_method_hash = rb_funcall(#{literal_value klass}, #{intern_num :method_hash},1,#{literal_value method_name});
 
           if (rb_method_hash != Qnil) {
-            VALUE tmp = rb_hash_aref(rb_method_hash, LONG2FIX(id));
+            VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
             if (tmp != Qnil) {
-                address = (void*)FIX2LONG(tmp);
+                address = (void*)NUM2PTR(tmp);
             }
           }
           
@@ -323,8 +339,8 @@ module FastRuby
               #{intern_num :register_method_value}, 
               3,
               #{literal_value method_name},
-              LONG2FIX(id),
-              LONG2FIX(address)
+              PTR2NUM(id),
+              PTR2NUM(address)
               );
         }
       "
@@ -346,247 +362,173 @@ module FastRuby
 
       args_tree = original_args_tree.select{|x| x.to_s[0] != ?&}
 
-      if (options[:main])
         initialize_method_structs(original_args_tree)
+        
+        if options[:main] then
+          strargs = if args_tree.size > 1
+            "VALUE self, VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
+          else
+            "VALUE self, VALUE block, VALUE _parent_frame"
+          end
 
-        strargs = if args_tree.size > 1
-          "VALUE self, VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
         else
-          "VALUE self, VALUE block, VALUE _parent_frame"
-        end
-
-        ret = "VALUE #{@alt_method_name || method_name}(VALUE self) {
-
-          #{@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->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
-          void* old_parent_locals = frame.thread_data->last_plocals;
-          frame.thread_data->last_plocals = plocals;
+          strargs = "VALUE self, VALUE block, VALUE _parent_frame, int argc, VALUE* argv"
           
-          plocals->active = Qtrue;
-          plocals->targetted = Qfalse;
-          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;
+          splat_arg = args_tree[1..-1].find{|x| x.to_s.match(/\*/) }
+  
+          maxargnum = args_tree[1..-1].count{ |x|
+              if x.instance_of? Symbol
+                not x.to_s.match(/\*/) and not x.to_s.match(/\&/)
+              else
+                false
+              end
             }
-
-            plocals->active = Qfalse;
-            frame.thread_data->last_plocals = old_parent_locals;
-            return plocals->return_value;
-          }
-
-          plocals->self = self;
-
-          #{args_tree[1..-1].map { |arg|
-            arg = arg.to_s
-            arg.gsub!("*","")
-            "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;
-          
-          frame.thread_data->last_plocals = old_parent_locals;
-          return ret;
-
-        }"
-
-        add_main
-        extra_code << ret
-      else
-
-        initialize_method_structs(original_args_tree)
-        
-        strargs = "VALUE self, VALUE block, VALUE _parent_frame, int argc, VALUE* argv"
-        
-        splat_arg = args_tree[1..-1].find{|x| x.to_s.match(/\*/) }
-
-        maxargnum = args_tree[1..-1].count{ |x|
-            if x.instance_of? Symbol
-              not x.to_s.match(/\*/) and not x.to_s.match(/\&/)
-            else
-              false
+            
+          minargnum = maxargnum
+            
+          args_tree[1..-1].each do |subtree|
+            unless subtree.instance_of? Symbol
+              if subtree[0] == :block
+                minargnum = minargnum - (subtree.size-1)
+              end
             end
-          }
-          
-        minargnum = maxargnum
+          end
           
-        args_tree[1..-1].each do |subtree|
-          unless subtree.instance_of? Symbol
-            if subtree[0] == :block
-              minargnum = minargnum - (subtree.size-1)
-            end
+          if args_tree[1..-1].find{|x| x.to_s.match(/\*/)}
+            maxargnum = 2147483647
           end
-        end
-        
-        if args_tree[1..-1].find{|x| x.to_s.match(/\*/)}
-          maxargnum = 2147483647
-        end
-        
-        read_arguments_code = ""
-
-
-        validate_arguments_code = if signature.size-1 < minargnum
-            "
-              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{minargnum})\");
-            "
-        elsif signature.size-1 > maxargnum
-            "
-              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{maxargnum})\");
-            "
-        else
-
-            default_block_tree = args_tree[1..-1].find{|subtree|
-              unless subtree.instance_of? Symbol
-                if subtree[0] == :block
-                  next true
+          
+          read_arguments_code = ""
+  
+  
+          validate_arguments_code = if signature.size-1 < minargnum
+              "
+                rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{minargnum})\");
+              "
+          elsif signature.size-1 > maxargnum
+              "
+                rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{maxargnum})\");
+              "
+          else
+  
+              default_block_tree = args_tree[1..-1].find{|subtree|
+                unless subtree.instance_of? Symbol
+                  if subtree[0] == :block
+                    next true
+                  end
                 end
-              end
-    
-              false
-            }
-            
-            i = -1
-
-            normalargsnum = args_tree[1..-1].count{|subtree|
-              if subtree.instance_of? Symbol
-                unless subtree.to_s.match(/\*/) or subtree.to_s.match(/\&/)
-                  next true
+      
+                false
+              }
+              
+              i = -1
+  
+              normalargsnum = args_tree[1..-1].count{|subtree|
+                if subtree.instance_of? Symbol
+                  unless subtree.to_s.match(/\*/) or subtree.to_s.match(/\&/)
+                    next true
+                  end
                 end
-              end
-                    
-              false
-            }
-
-            read_arguments_code = args_tree[1..-1].map { |arg_|
-                arg = arg_.to_s
-                i = i + 1
-    
-                if i < normalargsnum
-                  if i < signature.size-1
-                    "plocals->#{arg} = argv[#{i}];\n"
-                  else
                       
-                    if default_block_tree
-                      initialize_tree = default_block_tree[1..-1].find{|subtree| subtree[1] == arg_}
-                      if initialize_tree
-                        to_c(initialize_tree) + ";\n"
+                false
+              }
+  
+              read_arguments_code = args_tree[1..-1].map { |arg_|
+                  arg = arg_.to_s
+                  i = i + 1
+      
+                  if i < normalargsnum
+                    if i < signature.size-1
+                      "plocals->#{arg} = argv[#{i}];\n"
+                    else
+                        
+                      if default_block_tree
+                        initialize_tree = default_block_tree[1..-1].find{|subtree| subtree[1] == arg_}
+                        if initialize_tree
+                          to_c(initialize_tree) + ";\n"
+                        else
+                          ""
+                        end
                       else
-                        ""
+                          ";\n"
                       end
-                    else
-                        ";\n"
                     end
-                  end
-                else
-                  ""
-                end
-              }.join("")
-              
-            if splat_arg
-                  if signature.size-1 < normalargsnum then
-                    read_arguments_code << "
-                      plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new3(0);
-                      "
                   else
-                    read_arguments_code << "
-                      plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new4(
-                            #{(signature.size-1) - (normalargsnum)}, argv+#{normalargsnum} 
-                            );
-                    "
+                    ""
                   end
-    
-            end
-          
-          
-            ""
-        end
-
-        if block_argument
+                }.join("")
+                
+              if splat_arg
+                    if signature.size-1 < normalargsnum then
+                      read_arguments_code << "
+                        plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new3(0);
+                        "
+                    else
+                      read_arguments_code << "
+                        plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new4(
+                              #{(signature.size-1) - (normalargsnum)}, argv+#{normalargsnum} 
+                              );
+                      "
+                    end
+      
+              end
+            
+            
+              ""
+          end
+  
+          if block_argument
+  
+            proc_reyield_block_tree = s(:iter, s(:call, nil, :proc, s(:arglist)), s(:masgn, s(:array, s(:splat, s(:lasgn, :__xproc_arguments)))), s(:yield, s(:splat, s(:lvar, :__xproc_arguments))))
+  
+            require "fastruby/sexp_extension"
+  
+            read_arguments_code << "
+              if (pblock ? pblock->proc != Qnil : 0) {
+                plocals->#{block_argument.to_s.gsub("&","")} = pblock->proc;
+              } else {
+                plocals->#{block_argument.to_s.gsub("&","")} = #{to_c FastRuby::FastRubySexp.from_sexp(proc_reyield_block_tree)};
+              }
+            "
 
-          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))))
+            read_arguments_code << "
+              if (pblock) {
+              rb_ivar_set(plocals->#{block_argument.to_s.gsub("&","")},
+                        #{intern_num "__block_address"}, PTR2NUM(pblock->block_function_address)); 
+              rb_ivar_set(plocals->#{block_argument.to_s.gsub("&","")},
+                        #{intern_num "__block_param"}, PTR2NUM(pblock->block_function_param));            
+              }            
 
-          require "fastruby/sexp_extension"
+            "
+          end
 
-          read_arguments_code << "
-            plocals->#{block_argument.to_s.gsub("&","")} = #{to_c FastRuby::FastRubySexp.from_sexp(proc_reyield_block_tree)};
-          "
         end
 
-        ret = "VALUE #{@alt_method_name || method_name}(#{strargs}) {
+        require "fastruby/sexp_extension"       
+        scope_mode = FastRuby::ScopeModeHelper.get_scope_mode(tree)
+
+        ret = "VALUE #{@alt_method_name || method_name}(#{options[:main] ? "VALUE self" : strargs}) {
           #{validate_arguments_code}
 
           #{@frame_struct} frame;
-          #{@frame_struct} *pframe;
+          #{@frame_struct} * volatile pframe;
           
-          frame.parent_frame = (void*)_parent_frame;
+          frame.parent_frame = #{options[:main] ? "0"  : "(void*)_parent_frame"};
           frame.return_value = Qnil;
           frame.rescue = 0;
           frame.targetted = 0;
-          frame.thread_data = ((typeof(pframe))_parent_frame)->thread_data;
+          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;
-          VALUE rb_previous_stack_chunk = Qnil;
+          
+#{
+if scope_mode == :dag
+  " 
+          volatile VALUE rb_previous_stack_chunk = Qnil;
           VALUE rb_stack_chunk = frame.thread_data->rb_stack_chunk;
-          struct STACKCHUNK* stack_chunk = 0;
+          struct STACKCHUNK* volatile stack_chunk = 0;
 
           if (rb_stack_chunk != Qnil) {
             Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
@@ -605,43 +547,66 @@ module FastRuby
             Data_Get_Struct(rb_stack_chunk,struct STACKCHUNK,stack_chunk);
           }
 
+          #{@locals_struct}* volatile plocals;
 
-          #{@locals_struct} *plocals;
-
-          int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
-
+          volatile int previous_stack_position = stack_chunk_get_current_position(stack_chunk);
           plocals = (typeof(plocals))stack_chunk_alloc(stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
           
-          plocals->parent_locals = LONG2FIX(frame.thread_data->last_plocals);
-          void* old_parent_locals = frame.thread_data->last_plocals;
-          frame.thread_data->last_plocals = plocals;
+  "
+else
+  "
+          #{@locals_struct} locals;
+          typeof(locals) * volatile plocals = &locals;
+  "
+end
+}
+
+          plocals->parent_locals = (frame.thread_data->last_plocals);
+          void* volatile old_parent_locals = frame.thread_data->last_plocals;
+          
+          #{
+          if scope_mode == :dag 
+            "frame.thread_data->last_plocals = plocals;\n"
+          end
+          }
           
           frame.plocals = plocals;
           plocals->active = Qtrue;
           plocals->targetted = Qfalse;
-          plocals->pframe = LONG2FIX(&frame);
-          plocals->call_frame = LONG2FIX(0);
+          plocals->pframe = (&frame);
+          plocals->call_frame = (0);
 
           pframe = (void*)&frame;
 
-          #{@block_struct} *pblock;
-          VALUE last_expression = Qnil;
+          #{@block_struct} * volatile pblock;
+          volatile VALUE last_expression = Qnil;
 
           int aux = setjmp(pframe->jmp);
           if (aux != 0) {
             plocals->active = Qfalse;
 
+#{
+if scope_mode == :dag
+  " 
             stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
             if (stack_chunk_instantiated) {
               rb_gc_unregister_address(&rb_stack_chunk);
               frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
             }
-
-            if (plocals->targetted == Qfalse || aux != FASTRUBY_TAG_RETURN) {
-              frame.thread_data->last_plocals = old_parent_locals;
-              
-              longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
+"
+end
+}            
+            #{
+            unless options[:main]
+              "
+              if (plocals->targetted == Qfalse || aux != FASTRUBY_TAG_RETURN) {
+                frame.thread_data->last_plocals = old_parent_locals;
+                
+                longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
+              }
+              "
+            end
             }
 
             frame.thread_data->last_plocals = old_parent_locals;
@@ -651,35 +616,47 @@ module FastRuby
 
           plocals->self = self;
 
-          #{read_arguments_code}
-
-          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);
+          #{
+          unless options[:main]
+            "
+            pblock = (void*)block;
+            if (pblock) {
+              plocals->block_function_address = pblock->block_function_address;
+              plocals->block_function_param = pblock->block_function_param;
+            } else {
+              plocals->block_function_address = (0);
+              plocals->block_function_param = 0;
+            }
+            "
+          end
           }
 
-          VALUE __ret = #{to_c impl_tree};
+          #{read_arguments_code}
+
+          #{to_c impl_tree, "last_expression"};
+          
+local_return:
+#{
+if scope_mode == :dag
+"
           stack_chunk_set_current_position(stack_chunk, previous_stack_position);
 
           if (stack_chunk_instantiated) {
             rb_gc_unregister_address(&rb_stack_chunk);
             frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
           }
-
+"
+end
+}
           plocals->active = Qfalse;
           
           frame.thread_data->last_plocals = old_parent_locals;
           
-          return __ret;
+          return last_expression;
         }"
 
         add_main
         extra_code << ret
-      end
       
       "
         static VALUE dummy_#{method_name}_#{alt_method_name}_#{rand(1000000000000000000000000000000000)}(VALUE a) {
@@ -698,14 +675,15 @@ module FastRuby
 
        @locals = locals
         @locals_struct = "struct {
-        VALUE return_value;
-        VALUE parent_locals;
-        VALUE pframe;
-        VALUE block_function_address;
-        VALUE block_function_param;
-        VALUE call_frame;
+        int size;
+        void* call_frame;
+        void* parent_locals;
+        void* pframe;
+        void* block_function_address;
+        void* block_function_param;
         VALUE active;
         VALUE targetted;
+        VALUE return_value;
         #{@locals.map{|l| "VALUE #{l};\n"}.join}
         }"
 
@@ -753,9 +731,9 @@ module FastRuby
         lvar_type = eval(args[2][1].to_s)
 
         @infer_lvar_map[lvar_name] = lvar_type
-        return ""
+        return "Qnil"
       elsif mname == :block_given?
-        return "FIX2LONG(plocals->block_function_address) == 0 ? Qfalse : Qtrue"
+        return "plocals->block_function_address == 0 ? Qfalse : Qtrue"
       elsif mname == :inline_c
 
         code = args[1][1]
@@ -806,12 +784,32 @@ module FastRuby
     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;
+          #{@frame_struct} * volatile pframe = (void*)param;
 
-          #{nolocals ? "" : "#{@locals_struct} *plocals = (void*)pframe->plocals;"}
-          VALUE last_expression = Qnil;
+          #{nolocals ? "" : "#{@locals_struct} * volatile plocals = (void*)pframe->plocals;"}
+          volatile VALUE last_expression = Qnil;
 
           #{code}
+          return Qnil;
+
+          #{unless nolocals
+          "
+local_return:
+        plocals->return_value = last_expression;
+        plocals->targetted = 1;
+        longjmp(pframe->jmp, FASTRUBY_TAG_RETURN);
+        return last_expression;
+        "
+        end
+          }
+fastruby_local_redo:
+          longjmp(pframe->jmp,FASTRUBY_TAG_REDO);
+          return Qnil;
+fastruby_local_next:
+          longjmp(pframe->jmp,FASTRUBY_TAG_NEXT);
+          return Qnil;
+
+
           }
         "
       } + "((VALUE)pframe#{repass_var ? ", " + repass_var : "" })"
@@ -830,7 +828,7 @@ module FastRuby
 
             #{@frame_struct} frame;
 
-            typeof(frame)* pframe;
+            typeof(frame)* volatile pframe;
             
             #{if repass_var
             "typeof(frame)* parent_frame = ((typeof(pframe))((void**)param)[0]);"
@@ -870,7 +868,9 @@ module FastRuby
               "VALUE #{repass_var} = (VALUE)((void**)param)[1];"
             end
             }
-            return #{inner_code};
+              volatile VALUE last_expression = Qnil;
+              #{inner_code};
+              return last_expression;
             }
           "
         }
@@ -946,7 +946,9 @@ module FastRuby
             result = #{rescue_code};
             #{wrapper_code}
           } else {
-            return #{inner_code};
+            VALUE last_expression = Qnil;
+            #{inner_code};
+            return last_expression;
           }
 
           return result;
@@ -983,14 +985,22 @@ module FastRuby
         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)});
+          str_class_name = value.to_s.split("::").last
 
-            rb_funcall(#{name},#{intern_num :gc_register_object},0);
-          "
+          if (str_class_name == "Object")
+            init_extra << "
+              #{name} = rb_cObject;
+            "
+          else
+            init_extra << "
+              #{name} = rb_define_class_under(
+                      #{container_str == "" ? "rb_cObject" : literal_value(eval(container_str))}
+                      ,\"#{str_class_name}\"
+                      ,#{value.superclass == Object ? "rb_cObject" : literal_value(value.superclass)});
+
+              rb_funcall(#{name},#{intern_num :gc_register_object},0);
+            "
+          end
         elsif value.instance_of? Array
           init_extra << "
             #{name} = rb_ary_new3(#{value.size}, #{value.map{|x| literal_value x}.join(",")} );
@@ -1032,7 +1042,7 @@ module FastRuby
       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);
-      args_tree = call_tree[3]
+      args_tree = call_tree[3].reject{|st| st.respond_to?(:node_type) ? st[0] == :block_pass : false}
       method_tree = nil
 
       begin
@@ -1068,7 +1078,7 @@ module FastRuby
           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"
+            protected_block "last_expression = rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
             };
         }
       "
@@ -1078,7 +1088,7 @@ module FastRuby
         static VALUE #{funcname}(VALUE self,void* block,void* frame#{strargs_signature}){
         
           #{@frame_struct}* pframe = frame;
-          VALUE method_arguments[#{args_tree.size}] = {#{toprocstrargs}};
+          VALUE method_arguments[#{args_tree.size+1}] = {#{toprocstrargs},(VALUE)block};
           
           void* fptr = 0;
           
@@ -1097,12 +1107,12 @@ module FastRuby
           fptr = *#{address_name};
           
           #{
-            if args_tree.size < 25 and RUBY_VERSION =~ /^1\.8/
+            if args_tree.size < 25
             "
             if (fptr == 0) {
               fptr = *#{cfunc_address_name};
               if (fptr != 0) {
-                VALUE params[2] = {self,LONG2FIX(#{args_tree.size-1})};
+                VALUE params[2] = {self,PTR2NUM(#{args_tree.size-1})};
                 return ( (VALUE(*)(#{value_cast})) (fptr) )((VALUE)params,(VALUE)block,(VALUE)frame#{inprocstrargs});  
               }
             }
@@ -1111,9 +1121,64 @@ module FastRuby
           } 
           
           if (fptr == 0) {
-            return #{
-              protected_block "rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
-              };
+            if (block==0) {
+              return #{
+                protected_block "last_expression = rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
+                };
+
+            } else {
+              return #{
+                  protected_block "
+                        #{@block_struct} *pblock;
+                        pblock = (typeof(pblock))( ((VALUE*)method_arguments)[#{args_tree.size}] );
+                        last_expression = rb_iterate(
+                        #{anonymous_function{|name|
+                          "
+                            static VALUE #{name} (VALUE data) {
+                              VALUE* method_arguments = (VALUE*)data;
+                              return rb_funcall(
+                                ((VALUE*)method_arguments)[0], 
+                                #{intern_num mname.to_sym}, 
+                                #{args_tree.size-1}#{inprocstrargs});
+                            }
+                          "
+                        }},
+                          (VALUE)method_arguments,
+                          
+                        #{anonymous_function{|name|
+                          "
+                            static VALUE #{name} (VALUE arg_, VALUE param, int argc, VALUE* argv) {
+
+           VALUE arg;
+            #{
+            # TODO: access directly to argc and argv for optimal execution
+            if RUBY_VERSION =~ /^1\.9/ 
+              "
+                if (TYPE(arg_) == T_ARRAY) {
+                  if (_RARRAY_LEN(arg_) <= 1) {
+                    arg = rb_ary_new4(argc,argv);
+                  } else {
+                    arg = arg_;
+                  }
+                } else {
+                  arg = rb_ary_new4(argc,argv);
+                }
+              "
+            else
+              "arg = arg_;"
+            end
+            }
+        
+                              return rb_proc_call(param, arg);
+                            }
+                          "
+                        }},
+                          pblock->proc
+                        );
+                ", false, "method_arguments"
+                };
+            }
+
           } else {
             return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*)) (fptr) )(self,(VALUE)block,(VALUE)frame,#{args_tree.size-1},method_arguments+1);  
           }
@@ -1139,7 +1204,7 @@ module FastRuby
         static VALUE #{funcname}(VALUE* params, void* block,void* frame, #{strargs_signature}){
             VALUE self = params[0];
             VALUE method_arguments[26] = {#{toprocstrargs}};
-            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(FIX2LONG(params[1]),method_arguments,self);
+            return ( (VALUE(*)(int, VALUE*, VALUE)) (#{cfunc_real_address_name}) )(NUM2ULONG(params[1]),method_arguments,self);
         }
         "
       }
@@ -1147,7 +1212,7 @@ module FastRuby
       cfunc_wrapper_2 = anonymous_function{ |funcname| "
         static VALUE #{funcname}(VALUE* params, void* block,void* frame, #{strargs_signature}){
             VALUE self = params[0];
-            VALUE args = rb_ary_new3(FIX2LONG(params[1]),#{toprocstrargs});
+            VALUE args = rb_ary_new3(NUM2ULONG(params[1]),#{toprocstrargs});
             return ( (VALUE(*)(VALUE,VALUE)) (#{cfunc_real_address_name}) )(self,args);
         }
         "
@@ -1171,7 +1236,7 @@ module FastRuby
 
 
             VALUE fastruby_method = rb_funcall(recvtype, #{intern_num :fastruby_method}, 1, mname);
-            #{tree_pointer_name} = (VALUE*)FIX2LONG(fastruby_method_tree_pointer(fastruby_method));
+            #{tree_pointer_name} = (VALUE*)NUM2PTR(fastruby_method_tree_pointer(fastruby_method));
             
             ID id;
             ID default_id = rb_intern(\"default\");
@@ -1182,14 +1247,14 @@ module FastRuby
             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, LONG2FIX(id));
+              VALUE tmp = rb_hash_aref(rb_method_hash, PTR2NUM(id));
               if (tmp != Qnil) {
-                  address = (void*)FIX2LONG(tmp);
+                  address = (void*)NUM2PTR(tmp);
               }
               
-              tmp = rb_hash_aref(rb_method_hash, LONG2FIX(default_id));
+              tmp = rb_hash_aref(rb_method_hash, PTR2NUM(default_id));
               if (tmp != Qnil) {
-                 default_address = (void*)FIX2LONG(tmp);
+                 default_address = (void*)NUM2PTR(tmp);
               }
             }
             
@@ -1217,6 +1282,25 @@ module FastRuby
                 }
               }
 #endif
+#ifdef RUBY_1_9
+              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) {
+                  if (def->body.cfunc.argc == #{args_tree.size-1}) {
+                    *default_address = #{cfunc_wrapper};
+                    #{cfunc_real_address_name} = (void*)def->body.cfunc.func;
+                  } else if (def->body.cfunc.argc == -1) {
+                    *default_address = #{cfunc_wrapper_1};
+                    #{cfunc_real_address_name} = (void*)def->body.cfunc.func;
+                  } else if (def->body.cfunc.argc == -2) {
+                    *default_address = #{cfunc_wrapper_2};
+                    #{cfunc_real_address_name} = (void*)def->body.cfunc.func;
+                  }
+                }
+              }
+#endif
 
               if (recvtype != Qnil) { 
                 rb_funcall(
@@ -1224,8 +1308,8 @@ module FastRuby
                     #{intern_num :register_method_value}, 
                     3,
                     #{literal_value mname},
-                    LONG2FIX(default_id),
-                    LONG2FIX(default_address)
+                    PTR2NUM(default_id),
+                    PTR2NUM(default_address)
                     );
               }
             }
@@ -1239,8 +1323,8 @@ module FastRuby
                     #{intern_num :register_method_value}, 
                     3,
                     #{literal_value mname},
-                    LONG2FIX(id),
-                    LONG2FIX(address)
+                    PTR2NUM(id),
+                    PTR2NUM(address)
                     );
               }
   
@@ -1301,9 +1385,12 @@ module FastRuby
 
       anonymous_function{ |name| "
         static VALUE #{name}(VALUE param) {
-          VALUE last_expression = Qnil;
-          #{@frame_struct} frame, *pframe, *parent_frame;
-          #{@locals_struct} *plocals;
+          volatile VALUE last_expression = Qnil;
+          #{@frame_struct} frame;
+
+          typeof(frame)* volatile pframe;
+          typeof(frame)* volatile parent_frame;
+          #{@locals_struct}* volatile plocals;
 
           parent_frame = (void*)param;
 
@@ -1337,7 +1424,7 @@ module FastRuby
           #{code};
 
           // restore previous frame
-          typeof(pframe) original_frame = pframe;
+          volatile typeof(pframe) original_frame = pframe;
           pframe = parent_frame;
           #{not_jmp_code};