fastruby 0.0.14 → 0.0.15

data/lib/fastruby/translator/translator.rb

@@ -38,7 +38,6 @@ module FastRuby
     attr_reader :no_cache
     attr_reader :init_extra
     attr_reader :extra_code
-    attr_reader :yield_signature
     
     TranslatorModules.instance.load_under(FastRuby.fastruby_load_path + "/fastruby/translator/modules/")
     TranslatorModules.instance.modls.each do |modl|
@@ -68,6 +67,12 @@ module FastRuby
         void* block_function_param;
       }"
 
+        extra_code << "
+          static void frb_jump_tag(int state) {
+            VALUE exception = rb_funcall(#{literal_value FastRuby::JumpTagException}, #{intern_num :new},1,INT2FIX(state)); 
+            rb_exc_raise(exception);
+          }
+        "
 
       extra_code << "
         #include \"node.h\"
@@ -98,11 +103,13 @@ module FastRuby
       @lambda_node_gvar = add_global_name("NODE*", 0);
       @proc_node_gvar = add_global_name("NODE*", 0);
       @procnew_node_gvar = add_global_name("NODE*", 0);
+      @callcc_node_gvar = add_global_name("NODE*", 0);
 
       init_extra << "
         #{@lambda_node_gvar} = rb_method_node(rb_cObject, #{intern_num :lambda});
         #{@proc_node_gvar} = rb_method_node(rb_cObject, #{intern_num :proc});
         #{@procnew_node_gvar} = rb_method_node(CLASS_OF(rb_cProc), #{intern_num :new});
+        #{@callcc_node_gvar} = rb_method_node(rb_mKernel, #{intern_num :callcc});
       "
 
       @common_func = common_func
@@ -145,6 +152,7 @@ module FastRuby
 */
 
         "
+        
       end
     end
 
@@ -161,7 +169,7 @@ module FastRuby
       name
     end
 
-    def frame_call(inner_code)
+    def frame_call(inner_code, precode = "", postcode = "")
       inline_block "
 
 
@@ -181,24 +189,33 @@ module FastRuby
         VALUE old_call_frame = plocals->call_frame;
         plocals->call_frame = LONG2FIX(&call_frame);
 
+        #{precode}
+
                 int aux = setjmp(call_frame.jmp);
                 if (aux != 0) {
                   if (call_frame.targetted == 0) {
+                    #{postcode}
                     longjmp(old_pframe->jmp,aux);
                   }
 
                   if (aux == FASTRUBY_TAG_BREAK) {
                     plocals->call_frame = old_call_frame;
+                    #{postcode}
                     return call_frame.return_value;
                   } else if (aux == FASTRUBY_TAG_RETRY ) {
                     // do nothing and let the call execute again
                   } else {
                     plocals->call_frame = old_call_frame;
+                    #{postcode}
                     return call_frame.return_value;
                   }
                 }
+                
 
         VALUE ret = #{inner_code};
+        
+        #{postcode}
+        
         plocals->call_frame = old_call_frame;
         return ret;
       "
@@ -207,6 +224,7 @@ 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;
@@ -214,94 +232,10 @@ module FastRuby
         VALUE active;
         VALUE targetted;
         #{@locals.map{|l| "VALUE #{l};\n"}.join}
-        #{args_tree[1..-1].map{|arg| "VALUE #{arg.to_s.gsub("*","")};\n"}.join};
         }"
 
     end
 
-    def to_c_method_defs(tree)
-
-      method_name = tree[2]
-      args_tree = tree[3]
-
-      impl_tree = tree[4][1]
-
-      initialize_method_structs(args_tree)
-
-      strargs = if args_tree.size > 1
-        
-        "VALUE self, void* block_address, VALUE block_param, void* _parent_frame, #{args_tree[1..-1].map{|arg| "VALUE #{arg.to_s.gsub("*","")}" }.join(",") }"
-      else
-        "VALUE self, void* block_address, VALUE block_param, void* _parent_frame"
-      end
-
-      extra_code << "static VALUE #{@alt_method_name + "_real"}(#{strargs}) {
-        #{func_frame}
-
-        #{args_tree[1..-1].map { |arg|
-          arg = arg.to_s
-          arg.gsub!("*","")
-          "plocals->#{arg} = #{arg};\n"
-        }.join("") }
-
-        plocals->block_function_address = LONG2FIX(block_address);
-        plocals->block_function_param = LONG2FIX(block_param);
-
-        return #{to_c impl_tree};
-      }"
-
-      strargs2 = if args_tree.size > 1
-        "VALUE self, #{args_tree[1..-1].map{|arg| "VALUE #{arg}" }.join(",") }"
-      else
-        "VALUE self"
-      end
-
-      value_cast = ( ["VALUE"]*(args_tree.size+1) ).join(",")
-      strmethodargs = ""
-
-      if args_tree.size > 1
-        strmethodargs = "self,block_address,block_param,&frame,#{args_tree[1..-1].map(&:to_s).join(",") }"
-      else
-        strmethodargs = "self,block_address,block_param,&frame"
-      end
-
-      "
-      VALUE #{@alt_method_name}(#{strargs2}) {
-          #{@frame_struct} frame;
-          int argc = #{args_tree.size};
-          void* block_address = 0;
-          VALUE block_param = Qnil;
-
-          frame.plocals = 0;
-          frame.parent_frame = 0;
-          frame.return_value = Qnil;
-          frame.rescue = 0;
-          frame.targetted = 0;
-          frame.thread_data = rb_current_thread_data();
-
-          if (rb_block_given_p()) {
-            block_address = #{
-              anonymous_function{|name|
-              "static VALUE #{name}(int argc, VALUE* argv, VALUE param) {
-                return rb_yield_splat(rb_ary_new4(argc,argv));
-              }"
-              }
-            };
-
-            block_param = 0;
-          }
-
-          int aux = setjmp(frame.jmp);
-          if (aux != 0) {
-            rb_funcall(self, #{intern_num :raise}, 1, frame.thread_data->exception);
-          }
-
-
-          return #{@alt_method_name + "_real"}(#{strmethodargs});
-      }
-      "
-    end
-
     def add_main
       if options[:main]
 
@@ -374,20 +308,31 @@ module FastRuby
     end
 
     def to_c_method(tree, signature = nil)
-      method_name = tree[1]
-      args_tree = tree[2]
-      impl_tree = tree[3][1]
+      
+      if tree[0] == :defn
+        method_name = tree[1]
+        original_args_tree = tree[2]
+        block_argument = tree[2].find{|x| x.to_s[0] == ?&}
+        impl_tree = tree[3][1]
+      elsif tree[0] == :defs
+        method_name = tree[2]
+        original_args_tree = tree[3]
+        block_argument = tree[3].find{|x| x.to_s[0] == ?&}
+        impl_tree = tree[4][1]
+      end
+
+      args_tree = original_args_tree.select{|x| x.to_s[0] != ?&}
 
       if (options[:main])
-        initialize_method_structs(args_tree)
+        initialize_method_structs(original_args_tree)
 
         strargs = if args_tree.size > 1
-          "VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
+          "VALUE self, VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
         else
-          "VALUE block, VALUE _parent_frame"
+          "VALUE self, VALUE block, VALUE _parent_frame"
         end
 
-        ret = "VALUE #{@alt_method_name || method_name}() {
+        ret = "VALUE #{@alt_method_name || method_name}(VALUE self) {
 
           #{@locals_struct} *plocals;
           #{@frame_struct} frame;
@@ -404,7 +349,7 @@ module FastRuby
           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);
           }
@@ -425,6 +370,11 @@ module FastRuby
           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;
+          
           plocals->active = Qtrue;
           plocals->targetted = Qfalse;
           plocals->pframe = LONG2FIX(&frame);
@@ -444,6 +394,7 @@ module FastRuby
             }
 
             plocals->active = Qfalse;
+            frame.thread_data->last_plocals = old_parent_locals;
             return plocals->return_value;
           }
 
@@ -468,72 +419,131 @@ module FastRuby
           }
 
           plocals->active = Qfalse;
+          
+          frame.thread_data->last_plocals = old_parent_locals;
           return ret;
 
         }"
 
         add_main
-        ret
+        extra_code << ret
       else
 
-        initialize_method_structs(args_tree)
-
-        strargs = if args_tree.size > 1
-          "VALUE block, VALUE _parent_frame, #{(0..signature.size-1).map{|x| "VALUE arg#{x}"}.join(",")}"
-        else
-          "VALUE block, VALUE _parent_frame"
-        end
+        initialize_method_structs(original_args_tree)
         
-        is_splat_args = args_tree[1..-1].find{|x| x.to_s.match(/\*/) }
+        strargs = "VALUE self, VALUE block, VALUE _parent_frame, int argc, VALUE* argv"
         
-        if is_splat_args
+        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
+          }
           
-          i = -1
+        minargnum = maxargnum
           
-          read_arguments_code = args_tree[1..-2].map { |arg|
-              arg = arg.to_s
-              i = i + 1
-              "plocals->#{arg} = arg#{i};\n"
-            }.join("")
-            
-            arguments_array = [(signature.size-1) - (args_tree.size-2)] + (args_tree.size-2..signature.size-1).map{|x| "arg#{x}"}
-            
-          read_arguments_code << "
-            plocals->#{args_tree[-1].to_s.gsub("*","")} = rb_ary_new3(
-                  #{arguments_array.join(",")} 
-                  );
-          "
+        args_tree[1..-1].each do |subtree|
+          unless subtree.instance_of? Symbol
+            if subtree[0] == :block
+              minargnum = minargnum - (subtree.size-1)
+            end
+          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 >= args_tree.size-2
+        validate_arguments_code = if signature.size-1 < minargnum
             "
+              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{minargnum})\");
             "
-          else
+        elsif signature.size-1 > maxargnum
             "
-              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size} for #{args_tree.size-2})\");
+              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{maxargnum})\");
             "
-          end
-          
         else
+
+            default_block_tree = args_tree[1..-1].find{|subtree|
+              unless subtree.instance_of? Symbol
+                if subtree[0] == :block
+                  next true
+                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
+                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"
+                      else
+                        ""
+                      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
           
-          i = -1
           
-          read_arguments_code = args_tree[1..-1].map { |arg|
-              arg = arg.to_s
-              i = i + 1
-              "plocals->#{arg} = arg#{i};\n"
-            }.join("")
+            ""
+        end
 
-          validate_arguments_code = if signature.size-1 >= args_tree.size-1
-            "
-            "
-          else
-            "
-              rb_raise(rb_eArgError, \"wrong number of arguments (#{signature.size-1} for #{args_tree.size-1})\");
-            "
-          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))))
+
+          read_arguments_code << "
+            plocals->#{block_argument.to_s.gsub("&","")} = #{to_c proc_reyield_block_tree.to_fastruby_sexp};
+          "
         end
-        
 
         ret = "VALUE #{@alt_method_name || method_name}(#{strargs}) {
           #{validate_arguments_code}
@@ -576,6 +586,11 @@ module FastRuby
           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;
+          
           frame.plocals = plocals;
           plocals->active = Qtrue;
           plocals->targetted = Qfalse;
@@ -598,10 +613,14 @@ module FastRuby
               frame.thread_data->rb_stack_chunk = rb_previous_stack_chunk;
             }
 
-            if (plocals->targetted == Qfalse) {
+            if (plocals->targetted == Qfalse || aux != FASTRUBY_TAG_RETURN) {
+              frame.thread_data->last_plocals = old_parent_locals;
+              
               longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
             }
 
+            frame.thread_data->last_plocals = old_parent_locals;
+            
             return plocals->return_value;
           }
 
@@ -627,12 +646,21 @@ module FastRuby
           }
 
           plocals->active = Qfalse;
+          
+          frame.thread_data->last_plocals = old_parent_locals;
+          
           return __ret;
         }"
 
         add_main
-        ret
+        extra_code << ret
       end
+      
+      "
+        static VALUE dummy_#{method_name}_#{alt_method_name}_#{rand(1000000000000000000000000000000000)}(VALUE a) {
+          return Qnil;
+        }
+      "
     end
 
     def locals_accessor
@@ -646,6 +674,7 @@ module FastRuby
        @locals = locals
         @locals_struct = "struct {
         VALUE return_value;
+        VALUE parent_locals;
         VALUE pframe;
         VALUE block_function_address;
         VALUE block_function_param;
@@ -687,16 +716,6 @@ module FastRuby
       @on_block = old_on_block
     end
 
-    def with_extra_inference(extra_inference)
-      previous_infer_lvar_map = @infer_lvar_map
-      begin
-        @infer_lvar_map = @infer_lvar_map.merge(extra_inference)
-        yield
-      ensure
-        @infer_lvar_map = previous_infer_lvar_map
-      end
-    end
-
     def directive(tree)
       recv = tree[1]
       mname = tree[2]
@@ -779,14 +798,20 @@ module FastRuby
     def protected_block(inner_code, always_rescue = false,repass_var = nil, nolocals = false)
       body = nil
       rescue_args = nil
-      if repass_var
+
         body =  anonymous_function{ |name| "
           static VALUE #{name}(VALUE param) {
 
             #{@frame_struct} frame;
 
             typeof(frame)* pframe;
-            typeof(frame)* parent_frame = ((typeof(pframe))((void**)param)[0]);
+            
+            #{if repass_var
+            "typeof(frame)* parent_frame = ((typeof(pframe))((void**)param)[0]);"
+            else
+            "typeof(frame)* parent_frame = (typeof(pframe))param;"
+            end
+            }
 
             frame.parent_frame = 0;
             frame.return_value = Qnil;
@@ -794,6 +819,7 @@ module FastRuby
             frame.last_error = Qnil;
             frame.targetted = 0;
             frame.thread_data = parent_frame->thread_data;
+            frame.next_recv = parent_frame->next_recv;
             if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
 
             pframe = &frame;
@@ -810,84 +836,69 @@ module FastRuby
               if (frame.targetted == 1) {
                 return frame.return_value;
               } else {
-                rb_jump_tag(aux);
+                frb_jump_tag(aux);
               }
             }
 
-            VALUE #{repass_var} = (VALUE)((void**)param)[1];
+            #{if repass_var 
+              "VALUE #{repass_var} = (VALUE)((void**)param)[1];"
+            end
+            }
             return #{inner_code};
             }
           "
         }
 
+      if repass_var
         rescue_args = ""
         rescue_args = "(VALUE)(VALUE[]){(VALUE)pframe,(VALUE)#{repass_var}}"
       else
+        rescue_args = "(VALUE)pframe"
+      end
 
-        body = anonymous_function{ |name| "
-          static VALUE #{name}(VALUE param) {
-            #{@frame_struct} frame;
-
-            typeof(frame)* pframe;
-            typeof(frame)* parent_frame = (typeof(pframe))param;
-
-            frame.parent_frame = 0;
-            frame.return_value = Qnil;
-            frame.rescue = 0;
-            frame.last_error = Qnil;
-            frame.targetted = 0;
-            frame.thread_data = parent_frame->thread_data;
-            if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
-
-            pframe = &frame;
-
-            #{
-            nolocals ? "frame.plocals = 0;" : "#{@locals_struct}* plocals = parent_frame->plocals;
-            frame.plocals = plocals;
-            "
-            }
-
-            int aux = setjmp(frame.jmp);
-            if (aux != 0) {
-
-              if (frame.targetted == 1) {
-                return frame.return_value;
-              } else {
-                rb_jump_tag(aux);
+      wrapper_code = "
+            if (str.state >= 0x80) {
+              longjmp(pframe->jmp, str.state);
+            } else {
+              if (str.last_error != Qnil) {
+                  // raise emulation
+                  pframe->thread_data->exception = str.last_error;
+                  longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
+                  return Qnil;
               }
             }
-
-            return #{inner_code};
-            }
+        "
+        
+        return_err_struct = "struct {
+            VALUE last_error;
+            int state;
+          }
           "
-        }
-
-        rescue_args = "(VALUE)pframe"
-      end
-
-      wrapper_code = "        if (state != 0) {
-          if (state < 0x80) {
 
-            if (state == TAG_RAISE) {
-                // raise emulation
-                pframe->thread_data->exception = rb_eval_string(\"$!\");
-                longjmp(pframe->jmp, FASTRUBY_TAG_RAISE);
-                return Qnil;
+        rescue_body = anonymous_function{ |name| "
+          static VALUE #{name}(VALUE param, VALUE err) {
+            #{return_err_struct} *pstr = (void*)param;
+            
+            if (rb_obj_is_instance_of(err, #{literal_value FastRuby::JumpTagException})) {
+              pstr->state = FIX2INT(rb_funcall(err, #{intern_num :state}, 0));
             } else {
-              rb_jump_tag(state);
+              pstr->last_error = err;
             }
-          } else {
-            longjmp(pframe->jmp, state);
+            
+            return Qnil;
           }
-
-        }
         "
+      }
 
-      rescue_code = "rb_protect(#{body},#{rescue_args},&state)"
+      rescue_code = "rb_rescue2(#{body}, #{rescue_args}, #{rescue_body}, (VALUE)&str, rb_eException, (VALUE)0)"
 
       if always_rescue
         inline_block "
-          int state;
+          #{return_err_struct} str;
+          
+          str.state = 0;
+          str.last_error = Qnil;
+          
           pframe->last_error = Qnil;
           VALUE result = #{rescue_code};
 
@@ -898,7 +909,11 @@ module FastRuby
       else
         inline_block "
           VALUE result;
-          int state;
+          #{return_err_struct} str;
+          
+          str.state = 0;
+          str.last_error = Qnil;
+          
           pframe->last_error = Qnil;
 
           if (pframe->rescue) {
@@ -913,42 +928,6 @@ module FastRuby
       end
     end
 
-    def func_frame
-      "
-        #{@locals_struct} *plocals = malloc(sizeof(typeof(*plocals)));
-        #{@frame_struct} frame;
-        #{@frame_struct} *pframe;
-
-        frame.plocals = plocals;
-        frame.parent_frame = (void*)_parent_frame;
-        frame.return_value = Qnil;
-        frame.rescue = 0;
-        frame.targetted = 0;
-        frame.thread_data = ((typeof(pframe))_parent_frame)->thread_data;
-        if (frame.thread_data == 0) frame.thread_data = rb_current_thread_data();
-
-        plocals->pframe = LONG2FIX(&frame);
-        plocals->targetted = Qfalse;
-
-        pframe = (void*)&frame;
-
-        #{@block_struct} *pblock;
-        VALUE last_expression = Qnil;
-
-        int aux = setjmp(pframe->jmp);
-        if (aux != 0) {
-
-          if (plocals->targetted == Qfalse) {
-            longjmp(((typeof(pframe))_parent_frame)->jmp,aux);
-          }
-
-          return plocals->return_value;
-        }
-
-        plocals->self = self;
-      "
-    end
-
     def c_escape(str)
       str.inspect
     end
@@ -1102,7 +1081,7 @@ module FastRuby
               protected_block "rb_funcall(((VALUE*)method_arguments)[0], #{intern_num mname.to_sym}, #{args_tree.size-1}#{inprocstrargs});", false, "method_arguments"
               };
           } else {
-            return ( (VALUE(*)(#{value_cast})) (fptr) )(self,(VALUE)block,(VALUE)frame#{inprocstrargs});  
+            return ( (VALUE(*)(VALUE,VALUE,VALUE,int,VALUE*)) (fptr) )(self,(VALUE)block,(VALUE)frame,#{args_tree.size-1},method_arguments+1);  
           }
         }
         "