fastruby 0.0.14 → 0.0.15

data/lib/fastruby.rb

@@ -25,5 +25,5 @@ require "fastruby/custom_require"
 require "fastruby/set_tree"
 
 module FastRuby
-  VERSION = "0.0.14" unless defined? FastRuby::VERSION
+  VERSION = "0.0.15" unless defined? FastRuby::VERSION
 end

data/lib/targetted

@@ -0,0 +1,84 @@
+fastruby/translator/modules/variable.rb   27|      "rb_cvar_get(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]})"
+fastruby/translator/modules/variable.rb   31|      "__rb_cvar_set(CLASS_OF(plocals->self) != rb_cClass ? CLASS_OF(plocals->self) : plocals->self,#{intern_num tree[1]},#{to_c tree[2]},Qfalse)"
+fastruby/translator/modules/variable.rb   55|      "rb_const_get(CLASS_OF(plocals->self), #{intern_num(tree[1])})"
+fastruby/translator/modules/variable.rb  166|      "rb_ivar_defined(plocals->self,#{intern_num tree[1][1]}) ? #{literal_value "instance-variable"} : Qnil"
+fastruby/translator/modules/defn.rb   44|        rb_define_method(plocals->self, #{method_name.to_s.inspect}, #{anonymous_method_name}, -1 );
+fastruby/translator/modules/defn.rb   46|        #{global_klass_variable} = plocals->self;
+fastruby/translator/modules/method_group.rb  116|            plocals->active = Qtrue;
+fastruby/translator/modules/method_group.rb  117|            plocals->self = self;
+fastruby/translator/modules/method_group.rb  118|            plocals->targetted = Qfalse;
+fastruby/translator/modules/method_group.rb  119|            plocals->call_frame = LONG2FIX(0);
+fastruby/translator/modules/method_group.rb  130|            plocals->active = Qfalse;
+fastruby/translator/modules/iter.rb  106|          str_arg_initialization << "plocals->#{args_tree[1]} = arg;"
+fastruby/translator/modules/iter.rb  128|              str_arg_initialization << "plocals->#{arguments[i].last} = rb_ary_entry(arg,#{i});\n"
+fastruby/translator/modules/iter.rb  130|              str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(RARRAY(arg)->len-#{i});\n
+fastruby/translator/modules/iter.rb  134|                  rb_ary_store(plocals->#{arg.last.last},i-#{i},rb_ary_entry(arg,i));
+fastruby/translator/modules/iter.rb  146|          str_recv = "plocals->self" unless recv_tree
+fastruby/translator/modules/iter.rb  199|          str_recv = "plocals->self" unless recv_tree
+fastruby/translator/modules/iter.rb  276|                    if (plocals->targetted == 1) {
+fastruby/translator/modules/iter.rb  334|                      if (plocals->targetted == 1) {
+fastruby/translator/modules/iter.rb  335|                        if (plocals->active == Qfalse) {
+fastruby/translator/modules/iter.rb  336|                          printf(\"return plocals->active == Qfalse\\n\");
+fastruby/translator/modules/iter.rb  340|                          printf(\"return plocals->active == Qtrue\\n\");
+fastruby/translator/modules/iter.rb  447|          fastruby_str_arg_initialization = "plocals->#{args_tree[1]} = argv[0];"
+fastruby/translator/modules/iter.rb  454|              fastruby_str_arg_initialization << "plocals->#{arg.last} = #{i} < argc ? argv[#{i}] : Qnil;\n"
+fastruby/translator/modules/iter.rb  456|              fastruby_str_arg_initialization << "plocals->#{arg.last.last} = rb_ary_new2(#{arguments.size-1-i});\n
+fastruby/translator/modules/iter.rb  460|                  rb_ary_store(plocals->#{arg.last.last},i-#{i},argv[i]);
+fastruby/translator/modules/iter.rb  513|        str_recv = "plocals->self"
+fastruby/translator/modules/iter.rb  537|                VALUE old_call_frame = plocals->call_frame;
+fastruby/translator/modules/iter.rb  538|                plocals->call_frame = LONG2FIX(&call_frame);
+fastruby/translator/modules/iter.rb  551|                    plocals->call_frame = old_call_frame;
+fastruby/translator/modules/iter.rb  561|              pframe->next_recv = #{recv_tree ? to_c(recv_tree) : "plocals->self"};
+fastruby/translator/modules/iter.rb  649|                plocals->call_frame = old_call_frame;
+fastruby/translator/modules/iter.rb  658|                plocals->call_frame = old_call_frame;
+fastruby/translator/modules/block.rb   36|          if (FIX2LONG(plocals->block_function_address) == 0) {
+fastruby/translator/modules/block.rb   39|            return ((VALUE(*)(int,VALUE*,VALUE,VALUE))FIX2LONG(plocals->block_function_address))(size, block_args, FIX2LONG(plocals->block_function_param), (VALUE)pframe);
+fastruby/translator/modules/nonlocal.rb   27|        plocals->return_value = #{to_c(tree[1])};
+fastruby/translator/modules/nonlocal.rb   28|        plocals->targetted = 1;
+fastruby/translator/modules/nonlocal.rb   41|         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+fastruby/translator/modules/nonlocal.rb   47|         plocals->call_frame = LONG2FIX(0);
+fastruby/translator/modules/nonlocal.rb   60|         target_frame_ = (void*)FIX2LONG(plocals->call_frame);
+fastruby/translator/translator.rb  189|        VALUE old_call_frame = plocals->call_frame;
+fastruby/translator/translator.rb  190|        plocals->call_frame = LONG2FIX(&call_frame);
+fastruby/translator/translator.rb  202|                    plocals->call_frame = old_call_frame;
+fastruby/translator/translator.rb  208|                    plocals->call_frame = old_call_frame;
+fastruby/translator/translator.rb  219|        plocals->call_frame = old_call_frame;
+fastruby/translator/translator.rb  372|          plocals->active = Qtrue;
+fastruby/translator/translator.rb  373|          plocals->targetted = Qfalse;
+fastruby/translator/translator.rb  374|          plocals->pframe = LONG2FIX(&frame);
+fastruby/translator/translator.rb  390|            printf(\"plocals->active = Qfalse\\n\");
+fastruby/translator/translator.rb  391|            plocals->active = Qfalse;
+fastruby/translator/translator.rb  392|            return plocals->return_value;
+fastruby/translator/translator.rb  395|          plocals->self = self;
+fastruby/translator/translator.rb  400|            "plocals->#{arg} = #{arg};\n"
+fastruby/translator/translator.rb  403|          plocals->block_function_address = LONG2FIX(0);
+fastruby/translator/translator.rb  404|          plocals->block_function_param = LONG2FIX(Qnil);
+fastruby/translator/translator.rb  405|          plocals->call_frame = LONG2FIX(0);
+fastruby/translator/translator.rb  415|            printf(\"plocals->active = Qfalse\\n\");
+fastruby/translator/translator.rb  416|          plocals->active = Qfalse;
+fastruby/translator/translator.rb  494|                    "plocals->#{arg} = argv[#{i}];\n"
+fastruby/translator/translator.rb  516|                      plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new3(0);
+fastruby/translator/translator.rb  520|                      plocals->#{splat_arg.to_s.gsub("*","")} = rb_ary_new4(
+fastruby/translator/translator.rb  537|            plocals->#{block_argument.to_s.gsub("&","")} = #{to_c proc_reyield_block_tree.to_fastruby_sexp};
+fastruby/translator/translator.rb  583|          plocals->active = Qtrue;
+fastruby/translator/translator.rb  584|          plocals->targetted = Qfalse;
+fastruby/translator/translator.rb  585|          plocals->pframe = LONG2FIX(&frame);
+fastruby/translator/translator.rb  586|          plocals->call_frame = LONG2FIX(0);
+fastruby/translator/translator.rb  597|            printf(\"plocals->active = Qfalse\\n\");
+fastruby/translator/translator.rb  598|            plocals->active = Qfalse;
+fastruby/translator/translator.rb  607|            if (plocals->targetted == Qfalse) {
+fastruby/translator/translator.rb  615|            return plocals->return_value;
+fastruby/translator/translator.rb  618|          plocals->self = self;
+fastruby/translator/translator.rb  624|            plocals->block_function_address = LONG2FIX(pblock->block_function_address);
+fastruby/translator/translator.rb  625|            plocals->block_function_param = LONG2FIX(pblock->block_function_param);
+fastruby/translator/translator.rb  627|            plocals->block_function_address = LONG2FIX(0);
+fastruby/translator/translator.rb  628|            plocals->block_function_param = LONG2FIX(Qnil);
+fastruby/translator/translator.rb  639|            printf(\"plocals->active = Qfalse\\n\");
+fastruby/translator/translator.rb  640|          plocals->active = Qfalse;
+fastruby/translator/translator.rb  656|      "plocals->"
+fastruby/translator/translator.rb  721|        return "FIX2LONG(plocals->block_function_address) == 0 ? Qfalse : Qtrue"
+fastruby/translator/translator.rb  935|        plocals->pframe = LONG2FIX(&frame);
+fastruby/translator/translator.rb  936|        plocals->targetted = Qfalse;
+fastruby/translator/translator.rb  946|          if (plocals->targetted == Qfalse) {
+fastruby/translator/translator.rb  950|          return plocals->return_value;
+fastruby/translator/translator.rb  953|        plocals->self = self;

data/spec/block/arguments_spec.rb

@@ -0,0 +1,214 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::VO1
+    fastruby "
+      def foo(x)
+        yield(*x)
+      end
+    "
+  end
+
+  it "should allow pass splat arguments to yield" do
+    ::VO1.new.foo([1,2,3]) do |x,y,z|
+      x.should be == 1
+      y.should be == 2
+      z.should be == 3
+    end
+  end
+  
+  class ::VO2
+    fastruby "
+      def foo(x)
+        yield(1,*x)
+      end
+    "
+  end
+
+  it "should allow pass normal and splat arguments to yield" do
+    ::VO2.new.foo([2,3,4]) do |a,x,y,z|
+      a.should be == 1
+      x.should be == 2
+      y.should be == 3
+      z.should be == 4
+    end
+  end
+  
+  class ::VO3
+    fastruby "
+      def foo(x)
+        yield(1,2,*x)
+      end
+    "
+  end
+
+  it "should allow pass two normal args and one splat argument to yield" do
+    ::VO3.new.foo([3,4,5]) do |a,b,x,y,z|
+      a.should be == 1
+      b.should be == 2
+      x.should be == 3
+      y.should be == 4
+      z.should be == 5
+    end
+  end
+  
+  it "should take only the object argument when trying to splat a non-array" do
+    ::VO1.new.foo("non-array") do |x|
+      x.should be == "non-array"
+    end
+  end
+  
+  class ::VO4
+    
+    def bar
+      yield(1,2,3,4)
+    end
+    
+    fastruby "
+      def foo
+        bar do |*y|
+          y
+        end
+      end
+    "
+  end
+  
+  it "should allow masgn arguments on block passes" do
+    ::VO4.new.foo.should be == [1,2,3,4]
+  end
+  
+
+  class ::VO5
+    
+    fastruby "
+      def bar
+        yield(1,2,3,4)
+      end
+    
+      def foo
+        bar do |*y|
+          y
+        end
+      end
+    "
+  end
+  
+  it "should allow masgn arguments on block passes (fastruby call)" do
+    ::VO5.new.foo.should be == [1,2,3,4]
+  end
+  
+  
+  class ::VO6
+    
+    def bar
+      yield(1,2,3,4)
+    end
+    
+    fastruby "
+      def foo
+        bar do |a,b,*y|
+          y
+        end
+      end
+    "
+  end
+  
+  it "should allow normal arguments with masgn arguments on block passes" do
+    ::VO6.new.foo.should be == [3,4]
+  end
+  
+  class ::VO7
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call(32)
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block" do
+    ::VO7.new.foo.should be == [32]
+  end
+
+  class ::VO8
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call(32,33,34)
+      end
+    "
+  end
+
+  it "should allow multiple splat arguments on proc block" do
+    ::VO8.new.foo.should be == [32,33,34]
+  end
+  
+  class ::VO9
+      def bar
+        yield(32)
+      end
+    fastruby "
+      def foo
+        bar do |x|
+          x
+        end
+      end
+    "
+  end
+
+  it "should read single argument on block" do
+    ::VO9.new.foo.should be == 32
+  end
+
+
+  class ::VO10
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call([32])
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block when the argument is an array" do
+    ::VO10.new.foo.should be == [[32]]
+  end
+  
+
+  class ::VO11
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call([])
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block when the argument is an array empty" do
+    ::VO11.new.foo.should be == [[]]
+  end
+
+  class ::VO12
+    fastruby "
+      def foo
+        pr = proc do |*x|
+          x
+        end
+        pr.call()
+      end
+    "
+  end
+
+  it "should allow splat arguments on proc block when no arguments are passed" do
+    ::VO12.new.foo.should be == []
+  end
+  
+end

data/spec/block/block_as_proc_spec.rb

@@ -0,0 +1,98 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::VYE1
+    fastruby "
+      def foo(&block)
+      end
+    "
+  end
+
+  it "should allow method receiveing block" do
+    lambda {
+      ::VYE1.new.foo do
+        
+      end
+    }.should_not raise_error
+  end
+
+  class ::VYE2
+    fastruby "
+      def foo(&block)
+        block.call
+      end
+    "
+  end
+
+  it "should allow call block" do
+    lambda {
+      executed = 0
+      ::VYE2.new.foo do
+        executed = 1
+      end
+      
+      executed.should be == 1
+    }.should_not raise_error
+  end
+
+  class ::VYE3
+    fastruby "
+      def foo(&block)
+        block.call(64)
+      end
+    "
+  end
+
+  it "should allow call block with argument" do
+    lambda {
+      recv_a = 0
+      ::VYE3.new.foo do |a|
+        recv_a = a
+      end
+      
+      recv_a.should be == 64
+    }.should_not raise_error
+  end
+
+  class ::VYEE
+  end
+
+  class ::VYE4
+    fastruby "
+      def bar(x)
+        def x.foo(&block)
+        end
+      end
+    "
+  end
+
+  it "should allow singleton method receiveing block" do
+    x = ::VYEE.new
+    ::VYE4.new.bar(x)
+    x.foo do
+    end
+  end
+
+  class ::VYE5
+    fastruby "
+      def bar(x)
+        def x.foo(&block)
+          block.call
+        end
+      end
+    "
+  end
+
+  it "should allow singleton method receiveing and call block" do
+    x = ::VYEE.new
+    ::VYE5.new.bar(x)
+
+    executed = 0
+    x.foo do
+      executed = 1
+    end
+
+    executed.should be == 1
+  end
+
+end

data/spec/block/callcc_spec.rb

@@ -0,0 +1,233 @@
+require "fastruby"
+
+describe FastRuby, "fastruby" do
+  class ::N1
+    fastruby "
+      def bar(cc)
+        cc.call(75)
+      end
+
+      def foo
+        callcc do |cc|
+          bar(cc)
+        end
+      end
+    "
+  end
+
+  it "should execute callcc on fastruby" do
+    ::N1.new.foo.should be == 75
+  end
+
+  class ::N2
+   def bar(cc)
+     cc.call(76)
+   end
+
+    fastruby "
+      def foo
+        callcc do |cc|
+          bar(cc)
+        end
+      end
+    "
+  end
+
+  it "should execute callcc from ruby" do
+    ::N2.new.foo.should be == 76
+  end
+
+  class ::N3
+    fastruby "
+      def foo(n_)
+        n = n_
+
+        val = 0
+        cc = nil
+
+        x = callcc{|c| cc = c; nil}
+
+        val = val + x if x
+        n = n - 1
+
+        cc.call(n) if n > 0
+
+        val
+      end
+    "
+  end
+
+  it "should execute callcc from ruby using local variables" do
+    ::N3.new.foo(4).should be == 6
+  end
+
+  class ::N4
+    fastruby "
+      def foo(n_)
+        $n = n_
+
+        $val = 0
+        c = 0
+
+
+        x = callcc{|c| $cc_n4 = c; nil}
+
+        $val = $val + x if x
+        $n = $n - 1
+
+        $cc_n4.call($n) if $n > 0
+
+        $val
+      end
+    "
+  end
+
+  it "should execute callcc from ruby using global variables" do
+    ::N4.new.foo(4).should be == 6
+  end
+
+  class ::N5
+    fastruby "
+      def foo(n_)
+        $n = n_
+
+        $val = 0
+        c = 0
+        u = nil
+
+        x = callcc{|c| $cc_n4 = c; u = 44; nil}
+
+        $val = $val + x if x
+        $n = $n - 1
+
+        $cc_n4.call($n) if $n > 0
+
+        u
+      end
+    "
+  end
+
+  it "should execute callcc loops and preserve local variables" do
+    ::N5.new.foo(4).should be == 44
+  end
+
+  class ::N6
+    fastruby "
+    
+      def bar
+        a = 5555
+        
+        callcc do |cc|
+          $cc = cc
+        end
+        
+        a
+      end
+      
+      def another_method(n)
+        a = 9999
+	    another_method(n-1) if n>0
+      end
+    
+      def foo
+        
+        $called = nil
+        
+        ret = bar
+        another_method(200)
+        
+        unless $called
+          $called = 1
+          $cc.call
+        end
+        
+        ret
+      end
+    "
+  end
+
+  it "should execute callcc loops and preserve local variables when another method is called after callcc" do
+    ::N6.new.foo.should be == 5555
+  end
+  
+  
+  it "shouldn't raise LocalJumpError from proc being called on callcc de-initialized stack" do
+    
+fastruby <<ENDSTR
+
+class ::N7
+  def foo
+    val = nil
+    
+    pr = Proc.new do 
+      return val
+    end
+    
+    val = callcc do |cc|
+      $cc = cc
+    end
+    
+    pr.call
+  end
+
+  def bar
+    ret = foo
+
+    if ret.instance_of? Continuation
+      ret.call(4)
+    else
+      $cc.call(ret-1) if ret > 0
+    end
+  end
+end
+
+ENDSTR
+    
+    
+    n7 = ::N7.new
+    lambda {
+      n7.bar
+    }.should_not raise_error(LocalJumpError)
+  end
+  
+  it "should raise LocalJumpError from proc defined on abandoned stack after Continuation#call" do
+  
+fastruby <<ENDSTR
+class ::N8
+  def bar
+    ret = callcc do |cc|
+      $cc_n8 = cc
+    end
+    
+    if ret == 9
+      $pr_n8.call
+    end
+    
+    ret
+  end
+  
+  def foo3
+    $cc_n8.call(9)
+  end
+  
+  def foo2
+    $pr_n8 = Proc.new do
+      return
+    end
+    
+    foo3
+  end
+  
+  def foo
+    return if bar == 9
+    foo2
+  end
+end
+ENDSTR
+
+    n8 = ::N8.new
+    lambda {
+      n8.foo
+    }.should raise_error(LocalJumpError)
+  end  
+end