yarv-diff:288
From: ko1 atdot.net
Date: 20 Feb 2006 09:18:41 -0000
Subject: [yarv-diff:288] r452 - in trunk: . ext/win32ole sample
Author: ko1
Date: 2006-02-20 18:18:40 +0900 (Mon, 20 Feb 2006)
New Revision: 452
Modified:
trunk/
trunk/ChangeLog
trunk/eval_proc.c
trunk/ext/win32ole/.document
trunk/sample/test.rb
trunk/test.rb
trunk/yarvcore.c
Log:
r690@lermite: ko1 | 2006-02-20 18:18:05 +0900
* eval_proc.c : remove unused Binding functions and
set is_lambda of Proc used define_method
* yarvcore.c : support Proc#dup/clone, Binding#dup/clone
* sample/test.rb : remove unsupport features (Proc as Binding)
Property changes on: trunk
___________________________________________________________________
Name: svk:merge
- 81cd9672-7512-7e48-ae48-6936450e977d:/local/yarv/trunk:688
+ 81cd9672-7512-7e48-ae48-6936450e977d:/local/yarv/trunk:690
Modified: trunk/ChangeLog
===================================================================
--- trunk/ChangeLog 2006-02-20 07:35:08 UTC (rev 451)
+++ trunk/ChangeLog 2006-02-20 09:18:40 UTC (rev 452)
@@ -4,6 +4,16 @@
# from Mon, 03 May 2004 01:24:19 +0900
#
+2006-02-20(Mon) 17:54:58 +0900 Koichi Sasada <ko1 atdot.net>
+
+ * eval_proc.c : remove unused Binding functions and
+ set is_lambda of Proc used define_method
+
+ * yarvcore.c : support Proc#dup/clone, Binding#dup/clone
+
+ * sample/test.rb : remove unsupport features (Proc as Binding)
+
+
2006-02-20(Mon) 16:28:59 +0900 Koichi Sasada <ko1 atdot.net>
* common.mk : add a dependency to vm.c on eval_intern.h
Modified: trunk/eval_proc.c
===================================================================
--- trunk/eval_proc.c 2006-02-20 07:35:08 UTC (rev 451)
+++ trunk/eval_proc.c 2006-02-20 09:18:40 UTC (rev 452)
@@ -590,6 +590,8 @@
* #<B:0x401b39e8>
*/
+VALUE yarv_proc_dup(VALUE self);
+
static VALUE
rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
{
@@ -633,10 +635,12 @@
}
else if (yarv_obj_is_proc(body)) {
yarv_proc_t *proc;
+ body = yarv_proc_dup(body);
GetProcVal(body, proc);
if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) {
proc->block.iseq->defined_method_id = id;
proc->block.iseq->klass = mod;
+ proc->is_lambda = Qtrue;
}
node = NEW_BMETHOD(body);
}
@@ -1192,10 +1196,5 @@
void
Init_Binding()
{
- rb_cBinding = rb_define_class("Binding", rb_cObject);
- rb_undef_alloc_func(rb_cBinding);
- rb_undef_method(CLASS_OF(rb_cBinding), "new");
- // rb_define_method(rb_cBinding, "clone", proc_clone, 0);
- rb_define_method(rb_cBinding, "eval", bind_eval, -1);
- rb_define_global_function("binding", rb_f_binding, 0);
+
}
Modified: trunk/ext/win32ole/.document
===================================================================
--- trunk/ext/win32ole/.document 2006-02-20 07:35:08 UTC (rev 451)
+++ trunk/ext/win32ole/.document 2006-02-20 09:18:40 UTC (rev 452)
@@ -1 +0,0 @@
-win32ole.c
Modified: trunk/sample/test.rb
===================================================================
--- trunk/sample/test.rb 2006-02-20 07:35:08 UTC (rev 451)
+++ trunk/sample/test.rb 2006-02-20 09:18:40 UTC (rev 452)
@@ -1050,8 +1050,6 @@
argument_test(true, get_block(&lambda{|a,|}),1)
argument_test(false, get_block(&lambda{|a,|}),1,2)
-# Proc#clone is not supported
-if false
blk = get_block{11}
test_ok(blk.class == Proc)
test_ok(blk.to_proc.class == Proc)
@@ -1063,7 +1061,6 @@
test_ok(lmd.to_proc.class == Proc)
test_ok(lmd.clone.call == 44)
test_ok(get_block(&lmd).class == Proc)
-end
test_ok(Proc.new{|a,| a}.call(1,2,3) == 1)
argument_test(true, Proc.new{|a,|}, 1,2)
@@ -1752,16 +1749,18 @@
end
test_ok(!$bad)
-x = Proc.new{}
-eval "i4 = 1", x
-# test_ok(eval("i4", x) == 1)
-x = Proc.new{Proc.new{}}.call
-eval "i4 = 22", x
-# test_ok(eval("i4", x) == 22)
-$x = []
-x = Proc.new{Proc.new{}}.call
-eval "(0..9).each{|i5| $x[i5] = Proc.new{i5*2}}", x
-test_ok($x[4].call == 8)
+if false # unsupport
+ x = Proc.new{}
+ eval "i4 = 1", x
+ # test_ok(eval("i4", x) == 1)
+ x = Proc.new{Proc.new{}}.call
+ eval "i4 = 22", x
+ # test_ok(eval("i4", x) == 22)
+ $x = []
+ x = Proc.new{Proc.new{}}.call
+ eval "(0..9).each{|i5| $x[i5] = Proc.new{i5*2}}", x
+ test_ok($x[4].call == 8)
+end
x = binding
eval "i = 1", x
@@ -1790,20 +1789,22 @@
test_ok(eval("foo22") == 55)
}.call
-p1 = Proc.new{i7 = 0; Proc.new{i7}}.call
-test_ok(p1.call == 0)
-eval "i7=5", p1
-test_ok(p1.call == 5)
-test_ok(!defined?(i7))
+if false # unsupport Proc as Binding
+ p1 = Proc.new{i7 = 0; Proc.new{i7}}.call
+ test_ok(p1.call == 0)
+ eval "i7=5", p1
+ test_ok(p1.call == 5)
+ test_ok(!defined?(i7))
-p1 = Proc.new{i7 = 0; Proc.new{i7}}.call
-i7 = nil
-test_ok(p1.call == 0)
-eval "i7=1", p1
-test_ok(p1.call == 1)
-eval "i7=5", p1
-test_ok(p1.call == 5)
-test_ok(i7 == nil)
+ p1 = Proc.new{i7 = 0; Proc.new{i7}}.call
+ i7 = nil
+ test_ok(p1.call == 0)
+ eval "i7=1", p1
+ test_ok(p1.call == 1)
+ eval "i7=5", p1
+ test_ok(p1.call == 5)
+ test_ok(i7 == nil)
+end
test_check "system"
test_ok(`echo foobar` == "foobar\n")
Modified: trunk/test.rb
===================================================================
--- trunk/test.rb 2006-02-20 07:35:08 UTC (rev 451)
+++ trunk/test.rb 2006-02-20 09:18:40 UTC (rev 452)
@@ -1,644 +1,20 @@
-for d,*f in [[1,2,3]]; p d,f; end
-__END__
-def method_missing(m,&b) b end; p f{}
-__END__
-class Object; define_method(:foo){|*args| p args}; end; 0.foo(1,2,3)
-
-__END__
-[[1,2,3]].map{|a,b| p [a,b]}
-__END__
-
-p catch(:foo){
- 1.times{
- throw :foo
- }
-}
-p catch(:foo){
- throw :foo, false
-}
-p catch(:foo){
- throw :foo, nil
-}
-p catch(:foo){
- throw :foo, :ok
-}
-
-
-__END__
-
-ary = ['123']
-
-if target = ary.shift and /^[a-z-]+$/ =~ target
-
-end
-
-__END__
-
-100000.times{|i|
- Thread.new{}.join
- #p i
-}
-__END__
-
-
-a = Object.new
-def a.b=(x)
- p x
-end
-
-[1].each{|a.b[0]|
-
-}
-
-__END__
-
-
-c = {}
-[1].each do |c[:help]|
- p c
-end
-
-__END__
-
-def tarai( x, y, z )
- if x <= y
- then y
- else tarai(tarai(x-1, y, z),
- tarai(y-1, z, x),
- tarai(z-1, x, y))
- end
-end
-
-pid = fork(){
- tarai(12, 6, 0)
-}
-tarai(12, 6, 0)
-Process.waitpid(pid)
-p :exit
-
-__END__
-x = :sym;y = /reg/
-/reg/ =~ x
-__END__
-
-eval(':=(')
-
-__END__
-t = Thread.new{
- sleep
- }
- sleep 0.1
- t.raise
- while t.alive?
- Thread.pass
- end
-
- p begin
- t.join
- :ng
- rescue
- :ok
- end
-__END__
-
-p begin
- Thread.new{
- raise "ok"
- }.join
- rescue => e
- e
- end
-
-__END__
-
-
-1000000.times{|i|
- p i if i % 10 == 0
- t = Thread.new{}
- while t.alive?
- Thread.pass
- end
-}
-
-__END__
-
-1.times{
- begin
- p
- ensure
- foo = nil #noop = nil
- end
-}
-
-__END__
-
-
-
-p(@@x ||= 1)
-
-
-__END__
-p(@x||=1)
-p @x
-
-__END__
-
-
-unless defined?(@a) && @a
- @a = 1
-end
-
-__END__
-
-class A
- @@d = 3
- unless defined?(@@d) && @@d
- @@d = 1
- end
- #@@d ||= 1
- p @@d
-end
-
-
-__END__
-
-
-class TrueClass
- @@cvar = :TrueCvar
-end
-
-class FalseClass
- @@cvar = :FalseCvar
-end
-
-class FalseClass
- p true.instance_eval('@@cvar')
-end
-
-__END__
-
-
-obj = true
-obj.class.class_variable_set :@@cvar , 1
-p obj.instance_eval('@@cvar')
-
-__END__
-[[[1, 2], 3]].each{|a, b|
- p [a, b]
-}
-
-def f; yield []; end; f {|a,| p a}
-
-a, = []
-p a
-
-{1=>2}.each{|*e| p e}
-
-def f
- yield([1,2])
-end
-f{|*a| p a}
-
-__END__
-f = lambda {|r,| p r}
-f.call([], *[])
-
-f = lambda {|r| p r}
-f.call([])
-
-
-__END__
-
-
-def m
- proc{
- return :ng
- }
-end
-
-def call pr
- pr.call
-end
-
-pr = m()
-
-call pr
-
-p :exit
-
-__END__
-a = 1
-th = Thread.new{
- begin
- sleep 0.1
- ensure
- a = :ok
- end
-}
-Thread.pass
-th.kill
-th.join
-p a
-
-__END__
-
-class A
- def hoge
- :hoge
- end
-
- def foo
- :foo
- end
-end
-
-class B < A
- def memoize(name)
- B.instance_eval do
- define_method(name) do
- [name, super]
- end
- end
- end
-end
-
-b = B.new
-b.memoize(:hoge)
-b.memoize(:foo)
-p [b.foo, b.hoge]
-
-__END__
-
class C
- def m
- self.priv_m
- end
- private
- def priv_m
- end
-end
-
-C.new.m
-__END__
-
-
-
-Const = :hoge
-
-require 'irb'
-IRB.start(__FILE__)
-
-__END__
-load 'irb'
-
-__END__
-
-p Proc
-
-__END__
-
-require 'test/unit'
-
-class TestSafe < Test::Unit::TestCase
- def test_safe
- safe = $SAFE
- c = Class.new
- x = c.new
- p = proc {$SAFE += 1}
- c.class_eval {define_method(:inc, p)}
- assert_equal(safe + 1,
- proc {x.method(:inc).to_proc.call; $SAFE}.call)
- end
-end
-__END__
-
-p proc{
- # p 1
-}.to_s
-
-__END__
-
-[[1, 2]].each{|a, b| p [a, b]}
-
-__END__
-
-proc{|a, b| p [a, b]}.call(:x, :y)
-
-__END__
-def iter
- yield 1,2
-end
-
-iter{|a, b, c, *r|
- p [a,b,c,r]
-}
-
-__END__
-p proc {|a, b| [a, b] }.call([1,2])
-
-
-__END__
-
-Proc.new{|a, b| p [a, b]}.call(1, 2, 3)
-
-__END__
-{1=>2, 3=>4}.delete_if{|a,|
- p [a, ]
-}
-__END__
-
-
-def test_ok arg, foo=true
- p arg
-end
-
-def marity_test(m)
- method = self.method(m)
- test_ok(method.arity == method.to_proc.arity, 2)
-end
-marity_test(:test_ok)
-marity_test(:marity_test)
-marity_test(:p)
-
-__END__
-def f; yield [[]]; end; f {|a,| p a; test_ok(a == [])}
-def f; yield *[[]]; end; f {|a,| p a; test_ok(a == [])}
-
-__END__
-def f; yield []; end; f {|a,b,| p a; test_ok(a == nil)}
-def f; yield [1]; end; f {|a,| test_ok(a == 1)}
-def f; yield [nil]; end; f {|a,| test_ok(a == nil)}
-def f; yield [[]]; end; f {|a,| test_ok(a == [])}
-def f; yield [*[]]; end; f {|a,| test_ok(a == nil)}
-def f; yield [*[1]]; end; f {|a,| test_ok(a == 1)}
-def f; yield [*[1,2]]; end; f {|a,| test_ok(a == 1)}
-
-__END__
-
-f = lambda{|*x| p x; x}
-test_ok(f.call(42) == [42])
-test_ok(f.call([42]) == [[42]])
-test_ok(f.call([[42]]) == [[[42]]])
-test_ok(f.call([42,55]) == [[42,55]])
-test_ok(f.call(42,55) == [42,55])
-
-__END__
-
-
-__END__
-def iter
- yield 1
-end
-
-iter{|*x|p x}
-#iter{|*|p x}
-iter{|x,|p x}
-__END__
-
-lambda {|*x| p x}.call
-Proc.new{|*x| p x}.call
-__END__
-
-
-def iter
- yield 1, 2, 3, 4
-end
-
-iter{|x, y,|
- p [x, y]
-}
-
-
-__END__
-
-require 'set'
-
-set = Set.new(1..10)
-ret = set.delete_if { |i| p i; i > 10 }
-
-__END__
-
-p Proc === Proc.new{} #=> false
-__END__
-a = 1
-p []
-
-__END__
-
-require 'timeout'
-timeout(0.1){
-}
-loop{
-}
-
-
-__END__
-
-class C
- def m
- end
- alias mm m
- private :mm
-end
-
-p C.new.m # private method `m' called for #<C:0x00002a95eae8c0> (NoMethodError)
-p C.new.mm
-
-__END__
-
-class C
- def m
- 1.times{
- def m1
- end
- }
- end
-end
-
-C.new.m
-C.new.m1
-
-__END__
-fork do
- break
-end
-__END__
-
-Thread.new{
- eval("return")
-}.join
-
-__END__
-
-Thread.new{}.kill
-__END__
-Thread.new{}
-
-__END__
-def test_ok bool
- p bool
-end
-
-def get_block &b
- b
-end
-def argument_test a, b, c=nil, d=nil
-end
-
-argument_test(true, get_block(&lambda{||}))
-argument_test(false, get_block(&lambda{||}),1)
-argument_test(true, get_block(&lambda{|a,|}),1)
-argument_test(false, get_block(&lambda{|a,|}),1,2)
-
-begin; raise; rescue; end
-__END__
-
-__END__
-Thread.new{
- no_method()
-}.join
-
-__END__
-
-ObjectSpace.each_object{|o|
- p o.class
- o.to_s
-}
-__END__
-p([1].each.each)
-
-a = [1].each.each{|e| p e}
-
-__END__
-
-
-require 'test/unit'
-class TestFoo < Test::Unit::TestCase
- define_method(:test_foo){
+ define_method(:foo){
+ return :bar
}
end
+p C.new.foo
__END__
-p Proc.new{}
-
+Proc.new{}.dup.call
__END__
-require "rexml/document"
-include REXML # so that we don't have to prefix everything with REXML::...
-string = <<EOF
- <mydoc>
- <someelement attribute="nanoo">Text, text, text</someelement>
- </mydoc>
-EOF
-doc = Document.new string
-p doc
-
-__END__
-
-#!/usr/local/bin/ruby
-require 'webrick'
-include WEBrick
-
-s = HTTPServer.new( :Port => 20000 )
-
-# HTTPServer#mount(path, servletclass)
-# When a request referring "/hello" is received,
-# the HTTPServer get an instance of servletclass
-# and then call a method named do_"a HTTP method".
-
-class HelloServlet < HTTPServlet::AbstractServlet
- def do_GET(req, res)
- res.body = "<HTML>hello, world.</HTML>"
- res['Content-Type'] = "text/html"
- end
-end
-s.mount("/hello", HelloServlet)
-
-
-# HTTPServer#mount_proc(path){|req, res| ...}
-# You can mount also a block by `mount_proc'.
-# This block is called when GET or POST.
-
-s.mount_proc("/hello/again"){|req, res|
- res.body = "<HTML>hello (again)</HTML>"
- res['Content-Type'] = "text/html"
+pr = proc{
+ a = 1
+ p a
}
-trap("INT"){ s.shutdown }
-s.start
+pr.dup.call
-
-
-__END__
-p eval("proc{break :ok}").call
-
-__END__
-
-eval('proc{break}.call')
-
-__END__
-
-def iter &b
- eval('b.call')
-end
-
-iter{
- break
-}
-
-__END__
-
-
-def iter &b
- b
-end
-
-def m b
- b.call
- b
-end
-
-def iter2 &b
- m(b)
-end
-
-m(iter2{
- break
-})
-__END__
-iter{
- break
-}.call
-
-__END__
-
-proc{
- break
-}.call
-__END__
-def iter &b
- b.call
-end
-
-iter{
- break
-}
-
-
-__END__
-eval("
- proc{
- break
- }
- ").call
-__END__
-1.times{
- p 1
- proc{
- break
- }.call
- p 2
-}
-
Modified: trunk/yarvcore.c
===================================================================
--- trunk/yarvcore.c 2006-02-20 07:35:08 UTC (rev 451)
+++ trunk/yarvcore.c 2006-02-20 09:18:40 UTC (rev 452)
@@ -914,19 +914,34 @@
}
static VALUE
-proc_clone(VALUE self)
+proc_dup(VALUE self)
{
- rb_bug("proc_clone is not supported.");
- return Qnil;
+ VALUE procval = proc_alloc(cYarvProc);
+ yarv_proc_t *src, *dst;
+ GetProcVal(self, src);
+ GetProcVal(procval, dst);
+
+ dst->block = src->block;
+ dst->envval = src->envval;
+ dst->safe_level = dst->safe_level;
+ dst->special_cref_stack = src->special_cref_stack;
+
+ return procval;
}
+VALUE yarv_proc_dup(VALUE self)
+{
+ return proc_dup(self);
+}
static VALUE
-proc_dup(VALUE self)
+proc_clone(VALUE self)
{
- rb_bug("proc_dup is not supported.");
- return Qnil;
+ VALUE procval = proc_dup(self);
+ CLONESETUP(procval, self);
+ return procval;
}
+
/***************/
/* YarvBinding */
/***************/
@@ -967,7 +982,27 @@
return obj;
}
+static VALUE
+binding_dup(VALUE self)
+{
+ VALUE bindval = rb_obj_alloc(cYarvBinding);
+ yarv_binding_t *src, *dst;
+ GetBindingVal(self, src);
+ GetBindingVal(bindval, dst);
+ dst->env = src->env;
+ dst->cref_stack = src->cref_stack;
+ return bindval;
+}
+static VALUE
+binding_clone(VALUE self)
+{
+ VALUE bindval = binding_dup(self);
+ CLONESETUP(bindval, self);
+ return bindval;
+}
+
+
/********************************************************************/
static VALUE
@@ -1113,6 +1148,10 @@
/* declare YARVCore::VM::Binding */
cYarvBinding = rb_define_class_under(cYarvVM, "Binding", rb_cObject);
rb_define_alloc_func(cYarvBinding, binding_alloc);
+ rb_undef_method(CLASS_OF(cYarvBinding), "new");
+ rb_define_method(cYarvBinding, "clone", binding_clone, 0);
+ rb_define_method(cYarvBinding, "dup", binding_dup, 0);
+ rb_define_global_function("binding", rb_f_binding, 0);
/* misc */
--
ML: yarv-diff quickml.atdot.net
Info: http://www.atdot.net/~ko1/quickml