fastruby 0.0.8 → 0.0.9

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.0.9	Proc support
+
+		Enhanced lambda, proc and Proc.new hook by using nodes for method identification at runtime instead of method name
+
 0.0.8	Lambda support
 
 		Re-implemented break

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'fastruby'
-  s.version = '0.0.8'
+  s.version = '0.0.9'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/lib/fastruby/translator.rb

@@ -54,6 +54,7 @@ module FastRuby
         int rescue;
         VALUE last_error;
         void* stack_chunk;
+        VALUE next_recv;
       }"
 
       @block_struct = "struct {
@@ -80,7 +81,15 @@ module FastRuby
         rb_eval_string(#{ruby_code.inspect});
     	"
 
+      @lambda_node_gvar = add_global_name("NODE*", 0);
+      @proc_node_gvar = add_global_name("NODE*", 0);
+      @procnew_node_gvar = add_global_name("NODE*", 0);
 
+      init_extra << "
+        #{@lambda_node_gvar} = rb_method_node(rb_cObject, #{intern_num :lambda});
+        #{@proc_node_gvar} = rb_method_node(rb_cObject, #{intern_num :proc});
+        #{@procnew_node_gvar} = rb_method_node(CLASS_OF(rb_cProc), #{intern_num :new});
+      "
 
       @common_func = common_func
       if common_func
@@ -324,7 +333,7 @@ module FastRuby
         if call_args_tree.size > 1
 
           str_called_code_args = call_args_tree[1..-1].map{ |subtree| to_c subtree }.join(",")
-          str_recv = to_c recv_tree
+          str_recv = "pframe->next_recv"
 
           str_recv = "plocals->self" unless recv_tree
 
@@ -338,12 +347,25 @@ module FastRuby
             "
             }
 
+            rb_funcall_caller_code_with_lambda = rb_funcall_caller_code
         else
-          str_recv = to_c recv_tree
+          str_recv = "pframe->next_recv"
           str_recv = "plocals->self" unless recv_tree
 
-            execute_code = if mname == :lambda or mname == :proc
-              "VALUE ret = rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, 0);
+            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
               VALUE current_thread = rb_thread_current();
@@ -370,36 +392,32 @@ module FastRuby
               }
 
               return ret;
-              "
-            else
-              "return rb_funcall(#{str_recv}, #{intern_num call_tree[2]}, 0);"
-            end
-
-            rb_funcall_caller_code = proc { |name| "
-              static VALUE #{name}(VALUE param) {
-                // call to #{call_tree[2]}
-                #{str_lvar_initialization}
-                #{execute_code}
               }
             "
             }
-        end
 
-        target_escape_code = if mname == :lambda or mname == :proc
-        "
-              // create a fake parent frame representing the lambda method frame and a fake locals scope
-              #{@locals_struct} fake_locals;
-              #{@frame_struct} fake_frame;
+        end
 
-              fake_frame.plocals = (void*)&fake_locals;
-              fake_frame.parent_frame = 0;
+        rb_funcall_block_code_with_lambda = proc { |name| "
+          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+            // block for call to #{call_tree[2]}
+            VALUE last_expression = Qnil;
 
-              fake_locals.pframe = LONG2FIX(&fake_frame);
+            #{@frame_struct} frame;
+            #{@frame_struct} *pframe = (void*)&frame;
+            #{@locals_struct} *plocals = (void*)_plocals;
 
-              VALUE old_call_frame = ((typeof(fake_locals)*)(pframe->plocals))->call_frame;
-              ((typeof(fake_locals)*)(pframe->plocals))->call_frame = LONG2FIX(pframe);
+            frame.plocals = plocals;
+            frame.stack_chunk = 0;
+            frame.parent_frame = 0;
+            frame.return_value = Qnil;
+            frame.target_frame = &frame;
+            frame.exception = Qnil;
+            frame.rescue = 0;
 
-              frame.parent_frame = (void*)&fake_frame;
+              // 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);
 
               if (setjmp(frame.jmp) != 0) {
 
@@ -407,49 +425,97 @@ module FastRuby
                   if (pframe->target_frame == (void*)-3) {
                      return pframe->return_value;
                   } else if (pframe->target_frame == (void*)-1) {
-                     rb_funcall(((typeof(fake_locals)*)(pframe->plocals))->self, #{intern_num :raise}, 1, frame.exception);
+                     rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.exception);
                      return Qnil;
                   } else {
                     if (pframe->target_frame == (void*)FIX2LONG(plocals->pframe)) {
-                      ((typeof(fake_locals)*)(pframe->plocals))->call_frame = old_call_frame;
+                      ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
                       return pframe->return_value;
-                    } else if (pframe->target_frame == (void*)&fake_frame) {
-                      ((typeof(fake_locals)*)(pframe->plocals))->call_frame = old_call_frame;
-                      return fake_locals.return_value;
                     } else {
                       rb_raise(rb_eLocalJumpError, \"unexpected return\");
                     }
                   }
                 }
-                ((typeof(fake_locals)*)(pframe->plocals))->call_frame = old_call_frame;
+                ((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;
+          }
         "
-        else
-        "
-            if (setjmp(frame.jmp) != 0) {
-              if (pframe->target_frame != pframe) {
-                if (pframe->target_frame == (void*)-3) {
-                   return pframe->return_value;
-                }
+        }
 
-                VALUE ex = rb_funcall(
-                        #{literal_value FastRuby::Context::UnwindFastrubyFrame},
-                        #{intern_num :new},
-                        3,
-                        pframe->exception,
-                        LONG2FIX(pframe->target_frame),
-                        pframe->return_value
-                        );
+        rb_funcall_block_code_proc_new = proc { |name| "
+          static VALUE #{name}(VALUE arg, VALUE _plocals) {
+            // block for call to #{call_tree[2]}
+            VALUE last_expression = Qnil;
 
-                rb_funcall(plocals->self, #{intern_num :raise}, 1, ex);
+            #{@frame_struct} frame;
+            #{@frame_struct} *pframe = (void*)&frame;
+            #{@locals_struct} *plocals = (void*)_plocals;
+
+            frame.plocals = plocals;
+            frame.stack_chunk = 0;
+            frame.parent_frame = 0;
+            frame.return_value = Qnil;
+            frame.target_frame = &frame;
+            frame.exception = Qnil;
+            frame.rescue = 0;
+
+              // 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);
+
+              if (setjmp(frame.jmp) != 0) {
+                if (pframe->target_frame != pframe) {
+                  if (pframe->target_frame == (void*)-3) {
+                     return pframe->return_value;
+                  } else if (pframe->target_frame == (void*)-1) {
+                     rb_funcall(((typeof(plocals))(pframe->plocals))->self, #{intern_num :raise}, 1, frame.exception);
+                     return Qnil;
+                  } else {
+                    if (pframe->target_frame == (void*)FIX2LONG(plocals->pframe)) {
+
+                      if (plocals->active == Qfalse) {
+                        rb_raise(rb_eLocalJumpError,\"return from proc-closure\");
+                      } else {
+                        ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
+                        VALUE ex = rb_funcall(
+                                #{literal_value FastRuby::Context::UnwindFastrubyFrame},
+                                #{intern_num :new},
+                                3,
+                                pframe->exception,
+                                LONG2FIX(pframe->target_frame),
+                                pframe->return_value
+                                );
+
+                        rb_funcall(plocals->self, #{intern_num :raise}, 1, ex);
+                      }
+                    } else {
+                      rb_raise(rb_eLocalJumpError, \"unexpected return\");
+                    }
+                  }
                 }
-                return frame.return_value;
+
+                rb_raise(rb_eLocalJumpError, \"break from proc-closure\");
               }
 
+            #{str_arg_initialization}
+            #{str_impl}
+
+            ((typeof(plocals))(pframe->plocals))->call_frame = old_call_frame;
+
+            return last_expression;
+          }
         "
-        end
+        }
+
 
         rb_funcall_block_code = proc { |name| "
           static VALUE #{name}(VALUE arg, VALUE _plocals) {
@@ -468,14 +534,30 @@ module FastRuby
             frame.exception = Qnil;
             frame.rescue = 0;
 
-            #{target_escape_code}
+            if (setjmp(frame.jmp) != 0) {
+              if (pframe->target_frame != pframe) {
+                if (pframe->target_frame == (void*)-3) {
+                   return pframe->return_value;
+                }
+
+                VALUE ex = rb_funcall(
+                        #{literal_value FastRuby::Context::UnwindFastrubyFrame},
+                        #{intern_num :new},
+                        3,
+                        pframe->exception,
+                        LONG2FIX(pframe->target_frame),
+                        pframe->return_value
+                        );
+
+                rb_funcall(plocals->self, #{intern_num :raise}, 1, ex);
+                }
+                return frame.return_value;
+              }
 
 
             #{str_arg_initialization}
             #{str_impl}
 
-            #{"((typeof(fake_locals)*)(pframe->plocals))->call_frame = old_call_frame;" if mname == :lambda or mname == :proc}
-
             return last_expression;
           }
         "
@@ -617,7 +699,36 @@ module FastRuby
         } else {
           return #{
             frame_call(
-              protected_block("rb_iterate(#{anonymous_function(&rb_funcall_caller_code)}, (VALUE)pframe, #{anonymous_function(&rb_funcall_block_code)}, (VALUE)plocals)", true)
+              protected_block(inline_block("
+
+              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
+
+              NODE* node = rb_method_node(CLASS_OF(pframe->next_recv), #{intern_num mname});
+              void* caller_func;
+              void* block_func;
+
+              if (
+                node == #{@proc_node_gvar} ||
+                node == #{@lambda_node_gvar}
+                )  {
+
+                caller_func = #{anonymous_function(&rb_funcall_caller_code_with_lambda)};
+                block_func = #{anonymous_function(&rb_funcall_block_code_with_lambda)};
+              } else if (node == #{@procnew_node_gvar} && pframe->next_recv == rb_cProc) {
+                caller_func = #{anonymous_function(&rb_funcall_caller_code_with_lambda)};
+                block_func = #{anonymous_function(&rb_funcall_block_code_proc_new)};
+              } else {
+                caller_func = #{anonymous_function(&rb_funcall_caller_code)};
+                block_func = #{anonymous_function(&rb_funcall_block_code)};
+              }
+
+              return rb_iterate(
+                caller_func,
+                (VALUE)pframe,
+                block_func,
+                (VALUE)plocals);
+
+              "), true)
             )
           };
         }
@@ -735,7 +846,13 @@ module FastRuby
     end
 
     def to_c_return(tree)
-      "pframe->target_frame = ((typeof(pframe))FIX2LONG(plocals->pframe)); plocals->return_value = #{to_c(tree[1])}; pframe->return_value = plocals->return_value; longjmp(pframe->jmp, 1); return Qnil;\n"
+      inline_block "
+        pframe->target_frame = ((typeof(pframe))FIX2LONG(plocals->pframe));
+        plocals->return_value = #{to_c(tree[1])};
+        pframe->return_value = plocals->return_value;
+        longjmp(pframe->jmp, 1);
+        return Qnil;
+        "
     end
 
     def to_c_break(tree)
@@ -1125,6 +1242,7 @@ module FastRuby
         VALUE block_function_address;
         VALUE block_function_param;
         VALUE call_frame;
+        VALUE active;
         #{@locals.map{|l| "VALUE #{l};\n"}.join}
         #{args_tree[1..-1].map{|arg| "VALUE #{arg};\n"}.join};
         }"
@@ -1300,6 +1418,7 @@ module FastRuby
           int previous_stack_position = stack_chunk_get_current_position(frame.stack_chunk);
 
           plocals = (typeof(plocals))stack_chunk_alloc(frame.stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
+          plocals->active = Qtrue;
           plocals->pframe = LONG2FIX(&frame);
           frame.plocals = plocals;
 
@@ -1318,9 +1437,11 @@ module FastRuby
 
             if (pframe->target_frame != pframe) {
               // raise exception
+              plocals->active = Qfalse;
               return Qnil;
             }
 
+            plocals->active = Qfalse;
             return plocals->return_value;
           }
 
@@ -1342,6 +1463,7 @@ module FastRuby
             stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
           }
 
+          plocals->active = Qfalse;
           return ret;
 
         }"
@@ -1395,6 +1517,7 @@ module FastRuby
 
           plocals = (typeof(plocals))stack_chunk_alloc(frame.stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
           frame.plocals = plocals;
+          plocals->active = Qtrue;
           plocals->pframe = LONG2FIX(&frame);
           plocals->call_frame = LONG2FIX(0);
 
@@ -1405,6 +1528,8 @@ module FastRuby
 
           int aux = setjmp(pframe->jmp);
           if (aux != 0) {
+            plocals->active = Qfalse;
+
             stack_chunk_set_current_position(frame.stack_chunk, previous_stack_position);
 
             if (stack_chunk_instantiated) {
@@ -1447,6 +1572,7 @@ module FastRuby
             stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
           }
 
+          plocals->active = Qfalse;
           return __ret;
         }"
 
@@ -1676,9 +1802,9 @@ module FastRuby
 
       else # else recvtype
         if argnum == 0
-          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", false, repass_var)
+          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, 0)", true, repass_var)
         else
-          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", false, repass_var)
+          protected_block("rb_funcall(#{to_c recv}, #{intern_num tree[2]}, #{argnum}, #{strargs} )", true, repass_var)
         end
       end # if recvtype
     end
@@ -1718,6 +1844,7 @@ module FastRuby
         VALUE block_function_address;
         VALUE block_function_param;
         VALUE call_frame;
+        VALUE active;
         #{@locals.map{|l| "VALUE #{l};\n"}.join}
         }"
 
@@ -1777,6 +1904,7 @@ module FastRuby
             plocals = (typeof(plocals))stack_chunk_alloc(frame.stack_chunk ,sizeof(typeof(*plocals))/sizeof(void*));
 
             frame.plocals = plocals;
+            plocals->active = Qtrue;
             plocals->self = self;
             plocals->call_frame = LONG2FIX(0);
 
@@ -1789,6 +1917,7 @@ module FastRuby
               stack_chunk_reference_assign(stack_chunk_reference, rb_previous_stack_chunk);
             }
 
+            plocals->active = Qfalse;
             return Qnil;
           }
         "

data/lib/fastruby.rb

@@ -33,6 +33,6 @@ module FastRuby
   FastRuby.fastruby_script_path = File.expand_path(__FILE__)
   FastRuby.fastruby_load_path = File.expand_path(File.dirname(__FILE__))
 
-  VERSION = "0.0.8" unless defined? FastRuby::VERSION
+  VERSION = "0.0.9" unless defined? FastRuby::VERSION
 end
 

data/spec/block/lambda_spec.rb

@@ -178,4 +178,24 @@ describe FastRuby, "fastruby" do
     end
 
 
+    class ::LL8
+
+      alias alt_lambda lambda
+
+      fastruby "
+      def foo
+        lambda_obj = alt_lambda {
+          return 9
+        }
+
+        lambda_obj.call
+      end
+      "
+    end
+
+    it "should close lambda with return when renamed with alias" do
+       ll8 = ::LL8.new
+       ll8.foo.should be == 9
+    end
+
 end

data/spec/block/proc_spec.rb

@@ -0,0 +1,248 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::LN1
+    fastruby "
+      def foo
+        a = 16
+        proc {|x|
+          a+x
+        }
+      end
+    "
+  end
+
+  it "proc must be able to access local variables" do
+    ::LN1.new.foo.call(16).should be == 32
+  end
+
+    fastruby "
+  class ::LN2
+      def foo
+        a = 16
+        proc {|x|
+          a+x
+        }
+      end
+
+      def bar
+      end
+  end
+    "
+
+  it "proc must be able to access local variables, after another unrelated method is called" do
+    ll2 = ::LN2.new
+    proc_object = ll2.foo
+    ::LN2.new.bar
+    proc_object.call(16).should be == 32
+  end
+
+    fastruby "
+  class ::LN3
+      def foo(a)
+        proc {|x|
+          a+x
+        }
+      end
+
+      def bar(y)
+        proc_object = foo(16)
+        foo(160)
+        proc_object.call(y)
+      end
+  end
+    "
+
+  it "proc must be able to access local variables, after another unrelated method is called (from fastruby)" do
+    ll3 = ::LN3.new
+    ll3.bar(1).should be == 17
+  end
+
+    fastruby "
+  class ::LN4
+      def foo
+        proc {|x|
+          yield(x)
+        }
+      end
+
+      def bar
+        z = 99
+        foo do |x|
+          x+z
+        end
+      end
+
+      def xt
+        proc_object = bar()
+        proc_object.call(1)
+      end
+  end
+    "
+
+  it "proc must be able to access local variables of parent scopes through yield (from fastruby)" do
+    ll4 = ::LN4.new
+    ll4.xt.should be == 100
+  end
+
+  it "proc must be able to access local variables of parent scopes through yield" do
+    ll4 = ::LN4.new
+    proc_object = ll4.bar
+    proc_object.call(1).should be == 100
+  end
+
+  it "proc must be able to access local variables of parent scopes through yield on ruby" do
+    ll4 = ::LN4.new
+
+    a = 99
+
+    proc_object = ll4.foo do |x|
+      x+a
+    end
+    proc_object.call(1).should be == 100
+  end
+
+  def self.next_sentence(sname)
+    fastruby "
+      class ::LN5#{sname}
+          def foo
+            proc {
+              #{sname} 100
+            }
+          end
+      end
+    "
+
+    it "proc #{sname}'s must act as block next" do
+      eval("LN5"+sname).new.foo.call.should be == 100
+    end
+  end
+
+  next_sentence("next")
+  next_sentence("break")
+  next_sentence("return")
+
+  def self.illegal_jump(sname)
+    fastruby "
+      class ::LN6#{sname}
+          def foo
+            proc {
+              yield
+            }
+          end
+
+          def bar
+            foo do
+              #{sname} 9
+            end
+          end
+      end
+    "
+
+    it "#{sname} inside block should raise LocalJumpError" do
+       ll6 = eval("::LN6"+sname).new
+       lambda {
+         ll6.bar.call
+         }.should raise_error(LocalJumpError)
+    end
+  end
+
+  illegal_jump("return")
+  illegal_jump("break")
+
+
+    fastruby "
+    class ::LN7
+
+      def bar(l)
+        l.call
+        yield
+      end
+
+      def foo
+        lambda_obj = proc {
+        }
+
+        bar(lambda_obj) do
+          break 0
+        end
+      end
+    end
+    "
+
+    it "should break from block after calling lambda" do
+       ll7 = ::LN7.new
+       lambda {
+         ll7.foo.should be == 0
+         }.should_not raise_error
+    end
+
+  fastruby "
+  class LN9
+    def foo
+      f = Proc.new { return 'return from foo from inside proc' }
+      f.call
+      return 'return from foo'
+    end
+   end
+  "
+
+    it "should return from proc using Proc.new" do
+       ll9 = ::LN9.new
+       lambda {
+         ll9.foo.should be == 'return from foo from inside proc'
+         }.should_not raise_error
+    end
+
+  fastruby "
+  class LN10
+    def foo
+      f = Proc.new { return 'return from foo from inside proc' }
+      f
+    end
+   end
+  "
+
+    it "should raise invalid return from proc using Proc.new" do
+       ll10 = ::LN10.new
+       f = ll10.foo
+
+       lambda {
+         f.call
+       }.should raise_error(LocalJumpError)
+    end
+
+  fastruby "
+  class LN11
+    def foo
+      f = Proc.new { 9 }
+      f.call
+    end
+   end
+  "
+
+    it "should call proc defined using Proc.new" do
+       ll11 = ::LN11.new
+       lambda {
+         ll11.foo.should be == 9
+         }.should_not raise_error
+    end
+
+
+  fastruby "
+  class LN12
+    def foo
+      f = Proc.new { break }
+      f.call
+    end
+   end
+  "
+
+    it "should raise LocalJumpError from proc using Proc.new when break is used" do
+       ll12 = ::LN12.new
+       lambda {
+         ll12.foo
+         }.should raise_error(LocalJumpError)
+    end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fastruby
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - Dario Seminara
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-22 00:00:00 -03:00
+date: 2011-09-28 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -94,6 +94,7 @@ files:
 - spec/block/next_spec.rb
 - spec/block/break_spec.rb
 - spec/block/callcc_spec.rb
+- spec/block/proc_spec.rb
 - spec/block_spec.rb
 - spec/flow_control/case_spec.rb
 - spec/sugar_spec.rb