-assert_equal %q{[:false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :false, :false, :false, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :then, :false, :then, :then, :then, :false, :false, :false, :false, :false, :false, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :false, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :false, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :false, :then, :then, :then, :then, :then, :then, :then, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep, :then, :sep]}, %q{

- def make_perm ary, num

- base = make_perm(ary, num-1)

- conds = make_perm(['fv', 'tv'], 3)

- bangs = make_perm(['', '!'], 3)

- exprs = make_perm(['and', 'or'], 3)

- ['if', 'unless'].each{|syn|

- yield(syn, cs, bs, es)

- each_test{|syn, conds, bangs, exprs|

- c1, c2, c3 = conds

- bang1, bang2, bang3 = bangs

- #{syn} #{bang1}#{c1} #{e1} #{bang2}#{c2} #{e2} #{bang3}#{c3}

- each_test{|syn, conds, bangs, exprs|

- c1, c2, c3 = conds

- bang1, bang2, bang3 = bangs

- #{syn} #{bang1}#{c1} #{e1} #{bang2}#{c2} #{e2} #{bang3}#{c3}

-assert_equal %q{}, %q{

-assert_equal %q{method}, %q{

-assert_equal %q{}, %q{

-assert_equal %q{method}, %q{

-assert_equal %q{["method", "method", "method", "method", nil, nil, "method", "method", "method", nil]}, %q{

- [defined?(m1()), defined?(self.m1), defined?(C.new.m1),

- defined?(m2()), defined?(self.m2), defined?(C.new.m2),

- defined?(m3()), defined?(self.m3), defined?(C.new.m3)]

- C.new.test + [defined?(C.new.m3)]

-assert_equal %q{[nil, nil, nil, nil, "global-variable", "global-variable", nil, nil]}, %q{

- $ans = [defined?($1), defined?($2), defined?($3), defined?($4)]

- $ans + [defined?($1), defined?($2), defined?($3), defined?($4)]

-assert_equal %q{nilselftruefalse}, %q{

- defined?(nil) + defined?(self) +

- defined?(true) + defined?(false)

-assert_equal %q{}, %q{

-assert_equal %q{instance-variable}, %q{

-assert_equal %q{}, %q{

-assert_equal %q{class variable}, %q{

-assert_equal %q{}, %q{

-assert_equal %q{global-variable}, %q{

-assert_equal %q{}, %q{

- defined?(C_definedtest)

-assert_equal %q{constant}, %q{

- defined?(C_definedtest)

-assert_equal %q{}, %q{

- defined?(::C_definedtest)

-assert_equal %q{constant}, %q{

- defined?(::C_definedtest)

-assert_equal %q{}, %q{

- defined?(C_definedtestA::C_definedtestB::C_definedtestC)

-assert_equal %q{constant}, %q{

- class C_definedtestA

- class C_definedtestB

- C_definedtestC = 1

- defined?(C_definedtestA::C_definedtestB::C_definedtestC)

-assert_equal %q{30}, %q{

- if ib % 10 == 0 .. true

-assert_equal %q{63}, %q{

- if ib % 10 == 0 ... true

-assert_equal %q{[["NUM", "Type: NUM\n"], ["NUM", "123\n"], ["NUM", "456\n"], ["NUM", "Type: ARP\n"], ["NUM", "aaa\n"], ["NUM", "bbb\n"], ["NUM", "\f\n"], ["ARP", "Type: ARP\n"], ["ARP", "aaa\n"], ["ARP", "bbb\n"]]}, %q{

- unless ''.respond_to? :lines

-"this must not print

-this must not print

- if (t = l[/^Type: (.*)/, 1])..(/^\f/ =~ l)

-assert_equal %q{1}, %q{if true then 1 ; end}

-assert_equal %q{}, %q{if false then 1 ; end}

-assert_equal %q{1}, %q{if true then 1 ; else; 2; end}

-assert_equal %q{2}, %q{if false then 1 ; else; 2; end}

-assert_equal %q{}, %q{if true then ; elsif true then ; 1 ; end}

-assert_equal %q{1}, %q{if false then ; elsif true then ; 1 ; end}

-assert_equal %q{}, %q{unless true then 1 ; end}

-assert_equal %q{1}, %q{unless false then 1 ; end}

-assert_equal %q{2}, %q{unless true then 1 ; else; 2; end}

-assert_equal %q{1}, %q{unless false then 1 ; else; 2; end}

-assert_equal %q{1}, %q{1 if true}

-assert_equal %q{}, %q{1 if false}

-assert_equal %q{}, %q{1 if nil}

-assert_equal %q{}, %q{1 unless true}

-assert_equal %q{1}, %q{1 unless false}

-assert_equal %q{1}, %q{1 unless nil}

-assert_equal %q{1}, %q{1 || 2 || 3 || 4}

-assert_equal %q{1}, %q{1 || false || 3 || 4}

-assert_equal %q{2}, %q{nil || 2 || 3 || 4}

-assert_equal %q{2}, %q{false || 2 || 3 || 4}

-assert_equal %q{false}, %q{nil || false || nil || false}

-assert_equal %q{1}, %q{1 or 2 or 3 or 4}

-assert_equal %q{1}, %q{1 or false or 3 or 4}

-assert_equal %q{2}, %q{nil or 2 or 3 or 4}

-assert_equal %q{2}, %q{false or 2 or 3 or 4}

-assert_equal %q{false}, %q{nil or false or nil or false}

-assert_equal %q{elseng}, %q{

-assert_equal %q{ok}, %q{

-assert_equal %q{elseok}, %q{

-assert_equal %q{}, %q{

-assert_equal %q{ok}, %q{

- ary = [false, nil]

-assert_equal %q{ok}, %q{

- ary = [false, nil]

-assert_equal %q{ng}, %q{

- ary = [false, nil]

-assert_equal %q{ok}, %q{

- ary = [false, true]

-assert_equal %q{ok}, %q{

- ary = [false, true]

-assert_equal %q{}, %q{

-assert_equal %q{10}, %q{

-assert_equal %q{}, %q{

-assert_equal %q{11}, %q{

-assert_equal %q{1}, %q{

-def assert_syntax_error expected, code, message = ''

- assert_equal "#{expected}",

- "begin eval(%q{#{code}}, nil, '', 0)"'; rescue SyntaxError => e; e.message[/\A:(?:\d+:)? (.*)/, 1] end', message

-assert_syntax_error "unterminated string meets end of file", '().."', '[ruby-dev:29732]'

-assert_equal %q{[]}, %q{$&;[]}, '[ruby-dev:31068]'

-assert_syntax_error "syntax error, unexpected tSTAR, expecting '}'", %q{{*0}}, '[ruby-dev:31072]'

-assert_syntax_error "`@0' is not allowed as an instance variable name", %q{@0..0}, '[ruby-dev:31095]'

-assert_syntax_error "identifier $00 is not valid to get", %q{$00..0}, '[ruby-dev:31100]'

-assert_syntax_error "identifier $00 is not valid to set", %q{0..$00=1}

-assert_equal %q{0}, %q{[*0];0}, '[ruby-dev:31102]'

-assert_syntax_error "syntax error, unexpected ')'", %q{v0,(*,v1,) = 0}, '[ruby-dev:31104]'

-assert_equal %q{1}, %q{

- class << (ary=[]); def []; 0; end; def []=(x); super(0,x);end;end; ary[]+=1

-}, '[ruby-dev:31110]'

-assert_syntax_error "Can't set variable $1", %q{0..$1=1}, '[ruby-dev:31118]'

-assert_valid_syntax %q{1.times{1+(1&&next)}}, '[ruby-dev:31119]'

-assert_valid_syntax %q{x=-1;loop{x+=1&&redo if (x+=1).zero?}}, '[ruby-dev:31119]'

-assert_syntax_error %q{syntax error, unexpected $end}, %q{!}, '[ruby-dev:31243]'

-assert_equal %q{[nil]}, %q{[()]}, '[ruby-dev:31252]'

-assert_equal %q{true}, %q{!_=()}, '[ruby-dev:31263]'

-assert_equal 'ok', %q{while true; redo; end if 1 == 2; :ok}, '[ruby-dev:31360]'

-assert_equal 'ok', %q{

-}, '[ruby-dev:31373]'

-assert_equal 'ok', %q{

-}, '[ruby-dev:31373]'

-assert_equal 'ok', %q{

-assert_equal '3', %q{

- break 2 if (i+=1) > 1

-assert_equal '3', %q{

- break 2 if (i+=1) > 1

-assert_equal 'ok', %q{

-assert_equal '3', %q{

- break 2 if (i+=1) > 1

-assert_equal '3', %q{

- break 2 if (i+=1) > 1

-assert_equal '1', %q{

-assert_equal '2', %q{

-assert_match /invalid multibyte char/, %q{

- STDERR.reopen(STDOUT)

- eval("\"\xf0".force_encoding("utf-8"))

-}, '[ruby-dev:32429]'

-assert_equal 'true', %q{!false}

-assert_equal 'true', %q{1 == 1}

-assert_equal 'true', %q{1 != 2}

-assert_equal 'true', %q{

- class C; def !=(obj); true; end; end

-assert_equal 'true', %q{

- class C; def !@; true; end; end

-assert_normal_exit %q{

- eval "while true; return; end rescue p $!"

-}, '[ruby-dev:31663]'

-assert_equal '1', %q{

-assert_equal 'ok', %q{

- next if counter != 0

-}, '[ruby-core:14385]'

-assert_equal 'ok', %q{

- next if counter != 0

-}, '[ruby-core:14385]'

-assert_equal 'ok', %q{

- break if counter == 0

-}, 'reported by Yusuke ENDOH'

-assert_equal 'ok', %q{

- break if counter == 0

-}, 'reported by Yusuke ENDOH'

-assert_equal 'ok', %q{

- break if counter == 0

-}, 'reported by Yusuke ENDOH'

-assert_normal_exit %q{

- break if counter == 0

-}, 'reported by Yusuke ENDOH'

-assert_normal_exit %q{

- break if counter == 0

-}, 'reported by Yusuke ENDOH'

-assert_normal_exit %q{

- next if counter != 0

-}, 'reported by Yusuke ENDOH'

-assert_equal 'ok', %q{

- 1, 2, 3, 4, 5, 6, 7, 8,

-}, '[ruby-dev:32882]'

-assert_equal "1\n2\n", %q{

-assert_valid_syntax('1.times {|i|print (42),1;}', '[ruby-list:44479]')

-assert_equal 'ok', %q{

- if defined?(a(1).a)

-}, '[ruby-core:16010]'

-assert_equal 'ok', %q{

-}, '[ruby-core:16010]'

-assert_normal_exit %q{

-assert_equal 'ok', %q{

- class X < RuntimeError;end

-}, '[ruby-core:14537]'

-assert_equal 'ok', %q{

- (a[0] &&= true) == false ? :ok : :ng

-}, '[ruby-dev:34679]'

-assert_normal_exit %q{

- 100.times {|i| a << i << nil << nil }

-assert_equal 'ok', %q{

-}, '[ruby-dev:38968]'

-assert_equal 'ok', %q{

-}, '[ruby-dev:38980]'

-bug2415 = '[ruby-core:26961]'

-assert_normal_exit %q{

- def x(a=1, b, *rest); nil end

-assert_normal_exit %q{

- def x(a = 0.times do

- def y(a=1, b, *rest); nil; end

-assert_normal_exit %q{

- def x(a = 0.times do

-assert_normal_exit %q{

-}, '[ruby-dev:39861]'

-bug1240 = '[ruby-core:22637]'

-assert_valid_syntax('x y { "#{}".z { } }', bug1240)

-assert_valid_syntax('x y { "#{}".z do end }', bug1240)

-assert_valid_syntax('y "#{a 1}" do end', '[ruby-core:29579]')

-assert_normal_exit %q{

- s = defined?(raise + 1)

-}, '[ruby-core:30293]'

-assert_equal %q{ok}, %q{

-assert_equal %q{20100}, %q{

-assert_equal %q{5000}, %q{

- e.join(1000000000)

-assert_equal %q{5000}, %q{

-assert_equal %q{100}, %q{

- Thread.new{loop{Thread.pass}}

-assert_equal %q{ok}, %q{

- t.raise # raise to exited thread

-assert_equal %q{run}, %q{

-assert_equal %q{sleep}, %q{

-assert_equal %q{false}, %q{

-assert_equal %q{[ThreadGroup, true]}, %q{

- ptg = Thread.current.group

- ctg = Thread.current.group

- [ctg.class, ctg == ptg]

-assert_equal %q{[1, 1]}, %q{

- thg = ThreadGroup.new

- thg.add Thread.current

- [thg.list.size, ThreadGroup::Default.list.size]

-assert_equal %q{true}, %q{

- thg = ThreadGroup.new

- t = Thread.new{sleep 5}

- thg.list.include?(t)

-assert_equal %q{[true, nil, true]}, %q{

- [$a == $d, $b, $c != $d]

-assert_equal %q{11}, %q{

- Thread.current[:a] = 1

- Thread.current[:a] = 10

- Thread.current[:a]

- }.value + Thread.current[:a]

-assert_normal_exit %q{

- th = Thread.start(Thread.current) {|u| u.raise }

-}, '[ruby-dev:31371]'

-assert_equal 'true', %{

- t = Thread.new { loop {} }

- exit t.status != "run"

- rescue NotImplementedError

-assert_equal 'ok', %{

- open("zzz.rb", "w") do |f|

- Thread.new { fork { GC.start } }.join

- pid, status = Process.wait2

- $result = status.success? ? :ok : :ng

- rescue NotImplementedError

- require "./zzz.rb"

-assert_finish 3, %{

- th = Thread.new {sleep 2}

-assert_finish 3, %{

- th = Thread.new {sleep 2}

- Timeout.timeout(1) {th.join}

- rescue Timeout::Error

-assert_normal_exit %q{

- STDERR.reopen(STDOUT)

-assert_normal_exit %q{

-assert_equal 'ok', %q{

- t = Thread.new { while true do // =~ "" end }

- if /((ab)*(ab)*)*(b)/ =~ "ab"*7

- return :ng if $~.size != 5

-}, '[ruby-dev:34492]'

-assert_normal_exit %q{

- at_exit { Fiber.new{}.resume }

-assert_normal_exit %q{

- g = enum_for(:local_variables)

-}, '[ruby-dev:34128]'

-assert_normal_exit %q{

- g = enum_for(:block_given?)

-}, '[ruby-dev:34128]'

-assert_normal_exit %q{

- g = enum_for(:binding)

-}, '[ruby-dev:34128]'

-assert_normal_exit %q{

- g = "abc".enum_for(:scan, /./)

-}, '[ruby-dev:34128]'

-assert_normal_exit %q{

- g = Module.enum_for(:new)

-}, '[ruby-dev:34128]'

-assert_normal_exit %q{

- Fiber.new(&Object.method(:class_eval)).resume("foo")

-}, '[ruby-dev:34128]'

-assert_normal_exit %q{

- Thread.new("foo", &Object.method(:class_eval)).join

-}, '[ruby-dev:34128]'

-assert_equal 'ok', %q{

- Thread.new { Thread.stop }

-assert_equal 'ok', %q{

- m1, m2 = Mutex.new, Mutex.new

- Thread.new { m1.lock; sleep 1; m2.lock }

- m2.lock; sleep 1; m1.lock

-assert_equal 'ok', %q{

- Thread.new { m.lock }; sleep 1; m.lock

-assert_equal 'ok', %q{

- Thread.new { m.lock }; m.lock

-assert_equal 'ok', %q{

- Thread.new { m.lock }.join; m.lock

-assert_equal 'ok', %q{

- Thread.new { m.lock; sleep 2 }

-assert_equal 'ok', %q{

- Thread.new { m.lock; sleep 2; m.unlock }

-assert_equal 'ok', %q{

- t = Thread.new {`echo`}

-}, '[ruby-dev:35414]'

-assert_equal 'ok', %q{

- 10000.times { Thread.new(true) {|x| x == false } }

- rescue NoMemoryError, StandardError

-assert_equal 'ok', %{

- open("zzz.rb", "w") do |f|

- Thread.new { m.lock; sleep 1 }

- parent = Thread.current

- pid, status = Process.wait2

- $result = status.success? ? :ok : :ng

- rescue NotImplementedError

- require "./zzz.rb"

-assert_finish 3, %q{

- cond = ConditionVariable.new

- lock.synchronize do

- STDOUT.write "This is the child process.\n"

- STDOUT.write "Child process exiting.\n"

- Process.waitpid(pid)

- rescue NotImplementedError

-}, '[ruby-core:23572]'

-assert_equal 'ok', %q{

- Process.waitpid2(fork {sleep 1})[1].success? ? 'ok' : 'ng'

- rescue NotImplementedError

-assert_equal 'foo', %q{

- f = proc {|s| /#{ sleep 1; s }/o }

- [ Thread.new { f.call("foo"); nil },

- Thread.new { sleep 0.5; f.call("bar"); nil },

- ].each {|t| t.join }

- * \defgroup class Classes and their hierarchy.

- * \par Terminology

- * - class: same as in Ruby.

- * - singleton class: class for a particular object

- * - eigenclass: = singleton class

- * - metaclass: class of a class. metaclass is a kind of singleton class.

- * - metametaclass: class of a metaclass.

- * - meta^(n)-class: class of a meta^(n-1)-class.

- * - attached object: A singleton class knows its unique instance.

- * The instance is called the attached object for the singleton class.

-#include "ruby/ruby.h"

-#include "ruby/st.h"

-#include "method.h"

-#include "vm_core.h"

-static ID id_attached;

- * Allocates a struct RClass for a new class.

- * \param flags initial value for basic.flags of the returned class.

- * \param klass the class of the returned class.

- * \return an uninitialized Class object.

- * \pre \p klass must refer \c Class class or an ancestor of Class.

- * \pre \code (flags | T_CLASS) != 0 \endcode

- * \post the returned class can safely be \c #initialize 'd.

- * \note this function is not Class#allocate.

-class_alloc(VALUE flags, VALUE klass)

- rb_classext_t *ext = ALLOC(rb_classext_t);

- NEWOBJ(obj, struct RClass);

- OBJSETUP(obj, klass, flags);

- RCLASS_IV_TBL(obj) = 0;

- RCLASS_M_TBL(obj) = 0;

- RCLASS_SUPER(obj) = 0;

- RCLASS_IV_INDEX_TBL(obj) = 0;

- return (VALUE)obj;

- * A utility function that wraps class_alloc.

- * allocates a class and initializes safely.

- * \param super a class from which the new class derives.

- * \return a class object.

- * \pre \a super must be a class.

- * \post the metaclass of the new class is Class.

-rb_class_boot(VALUE super)

- VALUE klass = class_alloc(T_CLASS, rb_cClass);

- RCLASS_SUPER(klass) = super;

- RCLASS_M_TBL(klass) = st_init_numtable();

- * Ensures a class can be derived from super.

- * \param super a reference to an object.

- * \exception TypeError if \a super is not a Class or \a super is a singleton class.

-rb_check_inheritable(VALUE super)

- if (TYPE(super) != T_CLASS) {

- rb_raise(rb_eTypeError, "superclass must be a Class (%s given)",

- rb_obj_classname(super));

- if (RBASIC(super)->flags & FL_SINGLETON) {

- rb_raise(rb_eTypeError, "can't make subclass of singleton class");

- * Creates a new class.

- * \param super a class from which the new class derives.

- * \exception TypeError \a super is not inheritable.

- * \exception TypeError \a super is the Class class.

-rb_class_new(VALUE super)

- Check_Type(super, T_CLASS);

- rb_check_inheritable(super);

-struct clone_method_data {

-VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase);

-clone_method(ID mid, const rb_method_entry_t *me, struct clone_method_data *data)

- if (me->def && me->def->type == VM_METHOD_TYPE_ISEQ) {

- VALUE newiseqval = rb_iseq_clone(me->def->body.iseq->self, data->klass);

- GetISeqPtr(newiseqval, iseq);

- rb_add_method(data->klass, mid, VM_METHOD_TYPE_ISEQ, iseq, me->flag);

- rb_method_entry_set(data->klass, mid, me, me->flag);

-rb_mod_init_copy(VALUE clone, VALUE orig)

- rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);

- RCLASS_SUPER(clone) = RCLASS_SUPER(orig);

- if (RCLASS_IV_TBL(orig)) {

- if (RCLASS_IV_TBL(clone)) {

- st_free_table(RCLASS_IV_TBL(clone));

- RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(orig));

- CONST_ID(id, "__classpath__");

- st_delete(RCLASS_IV_TBL(clone), (st_data_t*)&id, 0);

- CONST_ID(id, "__classid__");

- st_delete(RCLASS_IV_TBL(clone), (st_data_t*)&id, 0);

- if (RCLASS_M_TBL(orig)) {

- struct clone_method_data data;

- if (RCLASS_M_TBL(clone)) {

- extern void rb_free_m_table(st_table *tbl);

- rb_free_m_table(RCLASS_M_TBL(clone));

- data.tbl = RCLASS_M_TBL(clone) = st_init_numtable();

- data.klass = clone;

- st_foreach(RCLASS_M_TBL(orig), clone_method,

- (st_data_t)&data);

-rb_class_init_copy(VALUE clone, VALUE orig)

- if (orig == rb_cBasicObject) {

- rb_raise(rb_eTypeError, "can't copy the root class");

- if (RCLASS_SUPER(clone) != 0 || clone == rb_cBasicObject) {

- if (FL_TEST(orig, FL_SINGLETON)) {

- rb_raise(rb_eTypeError, "can't copy singleton class");

-rb_singleton_class_clone(VALUE obj)

- struct clone_method_data data;

- VALUE clone = class_alloc(RBASIC(klass)->flags, 0);

- RCLASS_SUPER(clone) = RCLASS_SUPER(klass);

- if (RCLASS_IV_TBL(klass)) {

- RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(klass));

- RCLASS_M_TBL(clone) = st_init_numtable();

- data.tbl = RCLASS_M_TBL(clone);

- data.klass = (VALUE)clone;

- st_foreach(RCLASS_M_TBL(klass), clone_method,

- (st_data_t)&data);

- * Attach a object to a singleton class.

- * @pre \a klass is the singleton class of \a obj.

-rb_singleton_class_attached(VALUE klass, VALUE obj)

- if (!RCLASS_IV_TBL(klass)) {

- RCLASS_IV_TBL(klass) = st_init_numtable();

- st_insert(RCLASS_IV_TBL(klass), id_attached, obj);

-#define METACLASS_OF(k) RBASIC(k)->klass

- * whether k is a meta^(n)-class of Class class

- * @retval 1 if \a k is a meta^(n)-class of Class class (n >= 0)

- * @retval 0 otherwise

-#define META_CLASS_OF_CLASS_CLASS_P(k) (METACLASS_OF(k) == k)

- * ensures \a klass belongs to its own eigenclass.

- * @return the eigenclass of \a klass

- * @post \a klass belongs to the returned eigenclass.

- * i.e. the attached object of the eigenclass is \a klass.

- * @note this macro creates a new eigenclass if necessary.

-#define ENSURE_EIGENCLASS(klass) \

- (rb_ivar_get(METACLASS_OF(klass), id_attached) == klass ? METACLASS_OF(klass) : make_metaclass(klass))

- * Creates a metaclass of \a klass

- * \param klass a class

- * \return created metaclass for the class

- * \pre \a klass is a Class object

- * \pre \a klass has no singleton class.

- * \post the class of \a klass is the returned class.

- * \post the returned class is meta^(n+1)-class when \a klass is a meta^(n)-klass for n >= 0

-static inline VALUE

-make_metaclass(VALUE klass)

- VALUE metaclass = rb_class_boot(Qundef);

- FL_SET(metaclass, FL_SINGLETON);

- rb_singleton_class_attached(metaclass, klass);

- if (META_CLASS_OF_CLASS_CLASS_P(klass)) {

- METACLASS_OF(klass) = METACLASS_OF(metaclass) = metaclass;

- VALUE tmp = METACLASS_OF(klass); /* for a meta^(n)-class klass, tmp is meta^(n)-class of Class class */

- METACLASS_OF(klass) = metaclass;

- METACLASS_OF(metaclass) = ENSURE_EIGENCLASS(tmp);

- super = RCLASS_SUPER(klass);

- while (FL_TEST(super, T_ICLASS)) super = RCLASS_SUPER(super);

- RCLASS_SUPER(metaclass) = super ? ENSURE_EIGENCLASS(super) : rb_cClass;

- OBJ_INFECT(metaclass, RCLASS_SUPER(metaclass));

- * Creates a singleton class for \a obj.

- * \pre \a obj must not a immediate nor a special const.

- * \pre \a obj must not a Class object.

- * \pre \a obj has no singleton class.

-static inline VALUE

-make_singleton_class(VALUE obj)

- VALUE orig_class = RBASIC(obj)->klass;

- VALUE klass = rb_class_boot(orig_class);

- METACLASS_OF(klass) = METACLASS_OF(rb_class_real(orig_class));

-boot_defclass(const char *name, VALUE super)

- extern st_table *rb_class_tbl;

- VALUE obj = rb_class_boot(super);

- ID id = rb_intern(name);

- rb_name_class(obj, id);

- st_add_direct(rb_class_tbl, id, obj);

- rb_const_set((rb_cObject ? rb_cObject : obj), id, obj);

-Init_class_hierarchy(void)

- id_attached = rb_intern("__attached__");

- rb_cBasicObject = boot_defclass("BasicObject", 0);

- rb_cObject = boot_defclass("Object", rb_cBasicObject);

- rb_cModule = boot_defclass("Module", rb_cObject);

- rb_cClass = boot_defclass("Class", rb_cModule);

- RBASIC(rb_cClass)->klass

- = RBASIC(rb_cModule)->klass

- = RBASIC(rb_cObject)->klass

- = RBASIC(rb_cBasicObject)->klass

- * Creates a new *singleton class* for an object.

- * \pre \a obj has no singleton class.

- * \note DO NOT USE the function in an extension libraries. Use \ref rb_singleton_class.

- * \param obj An object.

- * \param unused ignored.

- * \return The singleton class of the object.

-rb_make_metaclass(VALUE obj, VALUE unused)

- if (BUILTIN_TYPE(obj) == T_CLASS) {

- return make_metaclass(obj);

- return make_singleton_class(obj);

- * Defines a new class.

- * \param id ignored

- * \param super A class from which the new class will derive. NULL means \c Object class.

- * \return the created class

- * \throw TypeError if super is not a \c Class object.

- * \note the returned class will not be associated with \a id.

- * You must explicitly set a class name if necessary.

-rb_define_class_id(ID id, VALUE super)

- * Calls Class#inherited.

- * \param super A class which will be called #inherited.

- * NULL means Object class.

- * \param klass A Class object which derived from \a super

- * \return the value \c Class#inherited's returns

- * \pre Each of \a super and \a klass must be a \c Class object.

-rb_class_inherited(VALUE super, VALUE klass)

- CONST_ID(inherited, "inherited");

- return rb_funcall(super, inherited, 1, klass);

- * Defines a top-level class.

- * \param name name of the class

- * \param super a class from which the new class will derive.

- * NULL means \c Object class.

- * \return the created class

- * \throw TypeError if the constant name \a name is already taken but

- * the constant is not a \c Class.

- * \throw NameError if the class is already defined but the class can not

- * be reopened because its superclass is not \a super.

- * \post top-level constant named \a name refers the returned class.

- * \note if a class named \a name is already defined and its superclass is

- * \a super, the function just returns the defined class.

-rb_define_class(const char *name, VALUE super)

- if (rb_class_real(RCLASS_SUPER(klass)) != super) {

- rb_raise(rb_eTypeError, "superclass mismatch for class %s", name);

- rb_name_class(klass, id);

- * Defines a class under the namespace of \a outer.

- * \param outer a class which contains the new class.

- * \param name name of the new class

- * \param super a class from which the new class will derive.

- * NULL means \c Object class.

- * \return the created class

- * \throw TypeError if the constant name \a name is already taken but

- * the constant is not a \c Class.

- * \throw NameError if the class is already defined but the class can not

- * be reopened because its superclass is not \a super.

- * \post top-level constant named \a name refers the returned class.

- * \note if a class named \a name is already defined and its superclass is

- * \a super, the function just returns the defined class.

-rb_define_class_under(VALUE outer, const char *name, VALUE super)

- return rb_define_class_id_under(outer, rb_intern(name), super);

- * Defines a class under the namespace of \a outer.

- * \param outer a class which contains the new class.

- * \param id name of the new class

- * \param super a class from which the new class will derive.

- * NULL means \c Object class.

- * \return the created class

- * \throw TypeError if the constant name \a name is already taken but

- * the constant is not a \c Class.

- * \throw NameError if the class is already defined but the class can not

- * be reopened because its superclass is not \a super.

- * \post top-level constant named \a name refers the returned class.

- * \note if a class named \a name is already defined and its superclass is

- * \a super, the function just returns the defined class.

-rb_define_class_id_under(VALUE outer, ID id, VALUE super)

- rb_raise(rb_eTypeError, "%s is not a class", rb_id2name(id));

- if (rb_class_real(RCLASS_SUPER(klass)) != super) {

- rb_name_error(id, "%s is already defined", rb_id2name(id));

- rb_class2name(outer), rb_id2name(id));

- rb_set_class_path_string(klass, outer, rb_id2str(id));

-rb_module_new(void)

- VALUE mdl = class_alloc(T_MODULE, rb_cModule);

- RCLASS_M_TBL(mdl) = st_init_numtable();

-rb_define_module_id(ID id)

-rb_define_module(const char *name)

-rb_define_module_under(VALUE outer, const char *name)

- return rb_define_module_id_under(outer, rb_intern(name));

-rb_define_module_id_under(VALUE outer, ID id)

- rb_set_class_path_string(module, outer, rb_id2str(id));

-include_class_new(VALUE module, VALUE super)

- VALUE klass = class_alloc(T_ICLASS, rb_cClass);

- if (!RCLASS_IV_TBL(module)) {

- RCLASS_IV_TBL(module) = st_init_numtable();

- RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);

- RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);

- RCLASS_SUPER(klass) = super;

-rb_include_module(VALUE klass, VALUE module)

- if (!OBJ_UNTRUSTED(klass)) {

- int superclass_seen = FALSE;

- if (RCLASS_M_TBL(klass) == RCLASS_M_TBL(module))

- for (p = RCLASS_SUPER(klass); p; p = RCLASS_SUPER(p)) {

- if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {

- c = p; /* move insertion point */

- superclass_seen = TRUE;

- c = RCLASS_SUPER(c) = include_class_new(module, RCLASS_SUPER(c));

- module = RCLASS_SUPER(module);

- * mod.included_modules -> array

- * Returns the list of modules included in mod.

- * Mixin.included_modules #=> []

- * Outer.included_modules #=> [Mixin]

-rb_mod_included_modules(VALUE mod)

- for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) {

- * mod.include?(module) -> true or false

- * Returns <code>true</code> if module is included in

- * mod or one of mod's ancestors.

- * B.include?(A) #=> true

- * C.include?(A) #=> true

- * A.include?(A) #=> false

-rb_mod_include_p(VALUE mod, VALUE mod2)

- for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) {

- * mod.ancestors -> array

- * Returns a list of modules included in mod (including

- * mod itself).

- * include Comparable

- * Mod.ancestors #=> [Mod, Comparable, Math]

- * Math.ancestors #=> [Math]

-rb_mod_ancestors(VALUE mod)

- for (p = mod; p; p = RCLASS_SUPER(p)) {

-ins_methods_push(ID name, long type, VALUE ary, long visi)

- rb_ary_push(ary, ID2SYM(name));

-ins_methods_i(ID name, long type, VALUE ary)

-ins_methods_prot_i(ID name, long type, VALUE ary)

-ins_methods_priv_i(ID name, long type, VALUE ary)

-ins_methods_pub_i(ID name, long type, VALUE ary)

-method_entry(ID key, const rb_method_entry_t *me, st_table *list)

- if (key == ID_ALLOCATOR) {

- return ST_CONTINUE;

- if (UNDEFINED_METHOD_ENTRY_P(me)) {

- type = -1; /* none */

- type = VISI(me->flag);

-class_instance_method_list(int argc, VALUE *argv, VALUE mod, int obj, int (*func) (ID, long, VALUE))

- for (; mod; mod = RCLASS_SUPER(mod)) {

- st_foreach(RCLASS_M_TBL(mod), method_entry, (st_data_t)list);

- if (obj && FL_TEST(mod, FL_SINGLETON)) continue;

- * mod.instance_methods(include_super=true) -> array

- * Returns an array containing the names of the public and protected instance

- * methods in the receiver. For a module, these are the public and protected methods;

- * for a class, they are the instance (not singleton) methods. With no

- * argument, or with an argument that is <code>false</code>, the

- * instance methods in mod are returned, otherwise the methods

- * in mod and mod's superclasses are returned.

- * def method1() end

- * def method2() end

- * def method3() end

- * A.instance_methods #=> [:method1]

- * B.instance_methods(false) #=> [:method2]

- * C.instance_methods(false) #=> [:method3]

- * C.instance_methods(true).length #=> 43

-rb_class_instance_methods(int argc, VALUE *argv, VALUE mod)

- return class_instance_method_list(argc, argv, mod, 0, ins_methods_i);

- * mod.protected_instance_methods(include_super=true) -> array

- * Returns a list of the protected instance methods defined in

- * mod. If the optional parameter is not <code>false</code>, the

- * methods of any ancestors are included.

-rb_class_protected_instance_methods(int argc, VALUE *argv, VALUE mod)

- return class_instance_method_list(argc, argv, mod, 0, ins_methods_prot_i);

- * mod.private_instance_methods(include_super=true) -> array

- * Returns a list of the private instance methods defined in

- * mod. If the optional parameter is not <code>false</code>, the

- * methods of any ancestors are included.

- * def method1() end

- * private :method1

- * def method2() end

- * Mod.instance_methods #=> [:method2]

- * Mod.private_instance_methods #=> [:method1]

-rb_class_private_instance_methods(int argc, VALUE *argv, VALUE mod)

- return class_instance_method_list(argc, argv, mod, 0, ins_methods_priv_i);

- * mod.public_instance_methods(include_super=true) -> array

- * Returns a list of the public instance methods defined in mod.

- * If the optional parameter is not <code>false</code>, the methods of

- * any ancestors are included.

-rb_class_public_instance_methods(int argc, VALUE *argv, VALUE mod)

- return class_instance_method_list(argc, argv, mod, 0, ins_methods_pub_i);

- * obj.methods -> array

- * Returns a list of the names of methods publicly accessible in

- * obj. This will include all the methods accessible in

- * obj's ancestors.

- * k.methods[0..9] #=> [:kMethod, :freeze, :nil?, :is_a?,

- * # :class, :instance_variable_set,

- * # :methods, :extend, :__send__, :instance_eval]

- * k.methods.length #=> 42

-rb_obj_methods(int argc, VALUE *argv, VALUE obj)

- return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);

- rb_scan_args(argc, argv, "1", &recur);

- if (RTEST(recur)) {

- return rb_obj_singleton_methods(argc, argv, obj);

- * obj.protected_methods(all=true) -> array

- * Returns the list of protected methods accessible to obj. If

- * the all parameter is set to <code>false</code>, only those methods

- * in the receiver will be listed.

-rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj)

- return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);

- * obj.private_methods(all=true) -> array

- * Returns the list of private methods accessible to obj. If

- * the all parameter is set to <code>false</code>, only those methods

- * in the receiver will be listed.

-rb_obj_private_methods(int argc, VALUE *argv, VALUE obj)

- return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);

- * obj.public_methods(all=true) -> array

- * Returns the list of public methods accessible to obj. If

- * the all parameter is set to <code>false</code>, only those methods

- * in the receiver will be listed.

-rb_obj_public_methods(int argc, VALUE *argv, VALUE obj)

- return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);

- * obj.singleton_methods(all=true) -> array

- * Returns an array of the names of singleton methods for obj.

- * If the optional all parameter is true, the list will include

- * methods in modules included in obj.

- * Only public and protected singleton methods are returned.

- * def Single.four() end

- * Single.singleton_methods #=> [:four]

- * a.singleton_methods(false) #=> [:two, :one]

- * a.singleton_methods #=> [:two, :one, :three]

-rb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj)

- rb_scan_args(argc, argv, "01", &recur);

- st_foreach(RCLASS_M_TBL(klass), method_entry, (st_data_t)list);

- klass = RCLASS_SUPER(klass);

- st_foreach(RCLASS_M_TBL(klass), method_entry, (st_data_t)list);

- klass = RCLASS_SUPER(klass);

- * \defgroup defmethod Defining methods

- * There are some APIs to define a method from C.

- * These API takes a C function as a method body.

- * \par Method body functions

- * Method body functions must return a VALUE and

- * can be one of the following form:

- * <dt>Fixed number of parameters</dt>

- * This form is a normal C function, excepting it takes

- * a receiver object as the first argument.

- * static VALUE my_method(VALUE self, VALUE x, VALUE y);

- * <dt>argc and argv style</dt>

- * This form takes three parameters: \a argc, \a argv and \a self.

- * \a self is the receiver. \a argc is the number of arguments.

- * \a argv is a pointer to an array of the arguments.

- * static VALUE my_method(int argc, VALUE *argv, VALUE self);

- * <dt>Ruby array style</dt>

- * This form takes two parameters: self and args.

- * \a self is the receiver. \a args is an Array object which

- * contains the arguments.

- * static VALUE my_method(VALUE self, VALUE args);

- * \par Number of parameters

- * Method defining APIs takes the number of parameters which the

- * method will takes. This number is called \a argc.

- * <dt>zero or positive number</dt>

- * <dd>This means the method body function takes a fixed number of parameters</dd>

- * <dd>This means the method body function is "argc and argv" style.</dd>

- * <dd>This means the method body function is "self and args" style.</dd>

-rb_define_method_id(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc)

- rb_add_method_cfunc(klass, mid, func, argc, NOEX_PUBLIC);

-rb_define_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)

- rb_add_method_cfunc(klass, rb_intern(name), func, argc, NOEX_PUBLIC);

-rb_define_protected_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)

- rb_add_method_cfunc(klass, rb_intern(name), func, argc, NOEX_PROTECTED);

-rb_define_private_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)

- rb_add_method_cfunc(klass, rb_intern(name), func, argc, NOEX_PRIVATE);

-rb_undef_method(VALUE klass, const char *name)

- rb_add_method(klass, rb_intern(name), VM_METHOD_TYPE_UNDEF, 0, NOEX_UNDEF);

- * \addtogroup class

- * Returns the singleton class of \a obj. Creates it if necessary.

- * \note DO NOT expose the returned singleton class to

- * outside of class.c.

- * Use \ref rb_singleton_class instead for

- * consistency of the metaclass hierarchy.

-singleton_class_of(VALUE obj)

- rb_ivar_get(RBASIC(obj)->klass, id_attached) == obj) {

- if (OBJ_UNTRUSTED(obj)) {

- OBJ_UNTRUST(klass);

- FL_UNSET(klass, FL_UNTRUSTED);

- * Returns the singleton class of \a obj. Creates it if necessary.

- * \param obj an arbitrary object.

- * \throw TypeError if \a obj is a Fixnum or a Symbol.

- * \return the singleton class.

- * \post \a obj has its own singleton class.

- * \post if \a obj is a class,

- * the returned singleton class also has its own

- * singleton class in order to keep consistency of the

- * inheritance structure of metaclasses.

- * \note a new singleton class will be created

- * if \a obj does not have it.

- * \note the singleton classes for nil, true and false are:

- * NilClass, TrueClass and FalseClass.

-rb_singleton_class(VALUE obj)

- VALUE klass = singleton_class_of(obj);

- /* ensures an exposed class belongs to its own eigenclass */

- if (TYPE(obj) == T_CLASS) ENSURE_EIGENCLASS(klass);

- * \addtogroup defmethod

- * Defines a singleton method for \a obj.

- * \param obj an arbitrary object

- * \param name name of the singleton method

- * \param func the method body

- * \param argc the number of parameters, or -1 or -2. see \ref defmethod.

-rb_define_singleton_method(VALUE obj, const char *name, VALUE (*func)(ANYARGS), int argc)

- rb_define_method(singleton_class_of(obj), name, func, argc);

- * Defines a module function for \a module.

- * \param module an module or a class.

- * \param name name of the function

- * \param func the method body

- * \param argc the number of parameters, or -1 or -2. see \ref defmethod.

-rb_define_module_function(VALUE module, const char *name, VALUE (*func)(ANYARGS), int argc)

- * Defines a global function

- * \param name name of the function

- * \param func the method body

- * \param argc the number of parameters, or -1 or -2. see \ref defmethod.

-rb_define_global_function(const char *name, VALUE (*func)(ANYARGS), int argc)

- * Defines an alias of a method.

- * \param klass the class which the original method belongs to

- * \param name1 a new name for the method

- * \param name2 the original name of the method

-rb_define_alias(VALUE klass, const char *name1, const char *name2)

- * Defines (a) public accessor method(s) for an attribute.

- * \param klass the class which the attribute will belongs to

- * \param name name of the attribute

- * \param read a getter method for the attribute will be defined if \a read is non-zero.

- * \param write a setter method for the attribute will be defined if \a write is non-zero.

-rb_define_attr(VALUE klass, const char *name, int read, int write)

- rb_attr(klass, rb_intern(name), read, write, FALSE);

-rb_obj_basic_to_s_p(VALUE obj)

- const rb_method_entry_t *me = rb_method_entry(CLASS_OF(obj), rb_intern("to_s"));

- if (me && me->def && me->def->type == VM_METHOD_TYPE_CFUNC &&

- me->def->body.cfunc.func == rb_any_to_s)

- int f_var = 0, f_block = 0;

- int n_lead = 0, n_opt = 0, n_trail = 0, n_mand;

- n_lead = *p - '0';

- if (ISDIGIT(*p)) {

- n_trail = *p - '0';

- if (ISDIGIT(*p)) {

- n_trail = *p - '0';

- rb_fatal("bad scan arg format: %s", fmt);

- n_mand = n_lead + n_trail;

- if (argc < n_mand)

- va_start(vargs, fmt);

- /* capture leading mandatory arguments */

- for (i = n_lead; i-- > 0; ) {

- var = va_arg(vargs, VALUE *);

- if (var) *var = argv[argi];

- /* capture optional arguments */

- for (i = n_opt; i-- > 0; ) {

- var = va_arg(vargs, VALUE *);

- if (argi < argc - n_trail) {

- if (var) *var = argv[argi];

- if (var) *var = Qnil;

- /* capture variable length arguments */

- int n_var = argc - argi - n_trail;

- var = va_arg(vargs, VALUE *);

- if (var) *var = rb_ary_new4(n_var, &argv[argi]);

- /* capture trailing mandatory arguments */

- for (i = n_trail; i-- > 0; ) {

- var = va_arg(vargs, VALUE *);

- if (var) *var = argv[argi];

- /* capture iterator block */

- var = va_arg(vargs, VALUE *);

- rb_raise(rb_eArgError, "wrong number of arguments (%d for %d..%d%s)",

- argc, n_mand, n_mand + n_opt, f_var ? "+" : "");

- rb_raise(rb_eArgError, "wrong number of arguments (%d for %d%s)",

- argc, n_mand, f_var ? "+" : "");

-bin: $(PROGRAM) $(WPROGRAM)

-.SUFFIXES: .inc .h .c .y .i

-SPEC_GIT_BASE = git://github.com/rubyspec

-MSPEC_GIT_URL = $(SPEC_GIT_BASE)/mspec.git

-RUBYSPEC_GIT_URL = $(SPEC_GIT_BASE)/rubyspec.git

-STATIC_RUBY = static-ruby

-EXTCONF = extconf.rb

-RBCONFIG = ./.rbconfig.time

-LIBRUBY_EXTS = ./.libruby-with-ext.time

-REVISION_H = ./.revision.time

-RDOCOUT = $(EXTOUT)/rdoc

-ID_H_TARGET = -id.h-

-DMYEXT = dmyext.$(OBJEXT)

-NORMALMAINOBJ = main.$(OBJEXT)

-MAINOBJ = $(NORMALMAINOBJ)

-DLDOBJS = $(DMYEXT)

-MINIOBJS = $(ARCHMINIOBJS) dmyencoding.$(OBJEXT) dmyversion.$(OBJEXT) miniprelude.$(OBJEXT)

-COMMONOBJS = array.$(OBJEXT) \

- bignum.$(OBJEXT) \

- compar.$(OBJEXT) \

- complex.$(OBJEXT) \

- dln_find.$(OBJEXT) \

- enumerator.$(OBJEXT) \

- marshal.$(OBJEXT) \

- numeric.$(OBJEXT) \

- object.$(OBJEXT) \

- process.$(OBJEXT) \

- random.$(OBJEXT) \

- rational.$(OBJEXT) \

- regcomp.$(OBJEXT) \

- regenc.$(OBJEXT) \

- regerror.$(OBJEXT) \

- regexec.$(OBJEXT) \

- regparse.$(OBJEXT) \

- regsyntax.$(OBJEXT) \

- signal.$(OBJEXT) \

- sprintf.$(OBJEXT) \

- strftime.$(OBJEXT) \

- string.$(OBJEXT) \

- struct.$(OBJEXT) \

- transcode.$(OBJEXT) \

- variable.$(OBJEXT) \

- compile.$(OBJEXT) \

- vm_dump.$(OBJEXT) \

- thread.$(OBJEXT) \

- $(BUILTIN_ENCOBJS) \

- $(BUILTIN_TRANSOBJS) \

-EXPORTOBJS = dln.$(OBJEXT) \

- encoding.$(OBJEXT) \

- version.$(OBJEXT) \

-OBJS = $(EXPORTOBJS) prelude.$(OBJEXT)

-GOLFOBJS = goruby.$(OBJEXT) golf_prelude.$(OBJEXT)

-PRELUDE_SCRIPTS = $(srcdir)/prelude.rb $(srcdir)/enc/prelude.rb $(srcdir)/gem_prelude.rb

-PRELUDES = prelude.c miniprelude.c

-GOLFPRELUDES = golf_prelude.c

-SCRIPT_ARGS = --dest-dir="$(DESTDIR)" \

- --extout="$(EXTOUT)" \

- --mflags="$(MFLAGS)" \

- --make-flags="$(MAKEFLAGS)"

-EXTMK_ARGS = $(SCRIPT_ARGS) --extension $(EXTS) --extstatic $(EXTSTATIC) \

- --make-flags="MINIRUBY='$(MINIRUBY)'" --

-INSTRUBY = $(MINIRUBY) $(srcdir)/tool/rbinstall.rb

-INSTRUBY_ARGS = $(SCRIPT_ARGS) \

- --data-mode=$(INSTALL_DATA_MODE) \

- --prog-mode=$(INSTALL_PROG_MODE) \

- --installed-list $(INSTALLED_LIST)

-INSTALL_PROG_MODE = 0755

-INSTALL_DATA_MODE = 0644

-PRE_LIBRUBY_UPDATE = $(MINIRUBY) -e 'ARGV[1] or File.unlink(ARGV[0]) rescue nil' -- \

- $(LIBRUBY_EXTS) $(LIBRUBY_SO_UPDATE)

-TESTSDIR = $(srcdir)/test

-TESTWORKDIR = testwork

-TESTRUN_SCRIPT = $(srcdir)/test.rb

-BOOTSTRAPRUBY = $(BASERUBY)

-COMPILE_PRELUDE = $(MINIRUBY) -I$(srcdir) $(srcdir)/tool/compile_prelude.rb

- @$(RUNCMD) $(MKMAIN_CMD) $(MAKE)

-exts: $(MKMAIN_CMD)

-$(MKMAIN_CMD): $(MKFILES) incs $(PREP) $(RBCONFIG) $(LIBRUBY)

- @$(MINIRUBY) $(srcdir)/ext/extmk.rb --make="$(MAKE)" --command-output=$@ $(EXTMK_ARGS)

-prog: $(PROGRAM) $(WPROGRAM)

-loadpath: $(PREP) PHONY

- $(MINIRUBY) -e 'p $$:'

-$(PREP): $(MKFILES)

-miniruby$(EXEEXT): config.status $(NORMALMAINOBJ) $(MINIOBJS) $(COMMONOBJS) $(DMYEXT) $(ARCHFILE)

-GORUBY = go$(RUBY_INSTALL_NAME)

-golf: $(LIBRUBY) $(GOLFOBJS) PHONY

- $(MAKE) $(MFLAGS) MAINOBJ="$(GOLFOBJS)" PROGRAM=$(GORUBY)$(EXEEXT) program

-capi: doc/capi/.timestamp PHONY

-doc/capi/.timestamp: Doxyfile $(PREP)

- @$(MAKEDIRS) doc/capi

- $(MINIRUBY) -e 'File.open("doc/capi/.timestamp", "w"){|f| f.puts(Time.now)}'

-Doxyfile: $(srcdir)/template/Doxyfile.tmpl $(PREP) $(srcdir)/tool/generic_erb.rb $(RBCONFIG)

- $(MINIRUBY) $(srcdir)/tool/generic_erb.rb -o $@ $(srcdir)/template/Doxyfile.tmpl \

- --srcdir="$(srcdir)" --miniruby="$(MINIRUBY)"

-program: $(PROGRAM)

-$(PROGRAM): $(LIBRUBY) $(MAINOBJ) $(OBJS) $(EXTOBJS) $(SETUP) $(PREP)

-$(LIBRUBY_A): $(OBJS) $(DMYEXT) $(ARCHFILE)

-$(LIBRUBY_SO): $(OBJS) $(DLDOBJS) $(LIBRUBY_A) $(PREP) $(LIBRUBY_SO_UPDATE) $(BUILTIN_ENCOBJS)

-$(STATIC_RUBY)$(EXEEXT): $(MAINOBJ) $(DLDOBJS) $(EXTOBJS) $(LIBRUBY_A)

- $(PURIFY) $(CC) $(MAINOBJ) $(DLDOBJS) $(EXTOBJS) $(LIBRUBY_A) $(MAINLIBS) $(EXTLIBS) $(LIBS) $(OUTFLAG)$@ $(LDFLAGS) $(XLDFLAGS)

-ruby.imp: $(EXPORTOBJS)

- @$(NM) -Pgp $(EXPORTOBJS) | \

- awk 'BEGIN{print "#!"}; $$2~/^[BDT]$$/&&$$1!~/^(Init_|.*_threadptr_|\.)/{print $$1}' | \

-install: install-$(INSTALLDOC)

-docs: $(DOCTARGETS)

-install-all: docs pre-install-all do-install-all post-install-all

-pre-install-all:: pre-install-local pre-install-ext pre-install-doc

-do-install-all: $(PROGRAM)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=all --rdoc-output="$(RDOCOUT)"

-post-install-all:: post-install-local post-install-ext post-install-doc

-install-nodoc: pre-install-nodoc do-install-nodoc post-install-nodoc

-pre-install-nodoc:: pre-install-local pre-install-ext

-do-install-nodoc: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --mantype="$(MANTYPE)"

-post-install-nodoc:: post-install-local post-install-ext

-install-local: pre-install-local do-install-local post-install-local

-pre-install-local:: pre-install-bin pre-install-lib pre-install-man

-do-install-local: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=local --mantype="$(MANTYPE)"

-post-install-local:: post-install-bin post-install-lib post-install-man

-install-ext: pre-install-ext do-install-ext post-install-ext

-pre-install-ext:: pre-install-ext-arch pre-install-ext-comm

-do-install-ext: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=ext

-post-install-ext:: post-install-ext-arch post-install-ext-comm

-install-arch: pre-install-arch do-install-arch post-install-arch

-pre-install-arch:: pre-install-bin pre-install-ext-arch

-do-install-arch: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=bin --install=ext-arch

-post-install-arch:: post-install-bin post-install-ext-arch

-install-comm: pre-install-comm do-install-comm post-install-comm

-pre-install-comm:: pre-install-lib pre-install-ext-comm pre-install-man

-do-install-comm: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=lib --install=ext-comm --install=man

-post-install-comm:: post-install-lib post-install-ext-comm post-install-man

-install-bin: pre-install-bin do-install-bin post-install-bin

-pre-install-bin:: install-prereq

-do-install-bin: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=bin

-install-lib: pre-install-lib do-install-lib post-install-lib

-pre-install-lib:: install-prereq

-do-install-lib: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=lib

-install-ext-comm: pre-install-ext-comm do-install-ext-comm post-install-ext-comm

-pre-install-ext-comm:: install-prereq

-do-install-ext-comm: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=ext-comm

-post-install-ext-comm::

-install-ext-arch: pre-install-ext-arch do-install-ext-arch post-install-ext-arch

-pre-install-ext-arch:: install-prereq

-do-install-ext-arch: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=ext-arch

-post-install-ext-arch::

-install-man: pre-install-man do-install-man post-install-man

-pre-install-man:: install-prereq

-do-install-man: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=man --mantype="$(MANTYPE)"

-install-capi: capi pre-install-capi do-install-capi post-install-capi

-pre-install-capi:: install-prereq

-do-install-capi: $(PREP)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=capi

-post-install-capi::

-what-where: no-install

-no-install: no-install-$(INSTALLDOC)

-what-where-all: no-install-all

-no-install-all: pre-no-install-all dont-install-all post-no-install-all

-pre-no-install-all:: pre-no-install-local pre-no-install-ext pre-no-install-doc

-dont-install-all: $(PROGRAM)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=all --rdoc-output="$(RDOCOUT)"

-post-no-install-all:: post-no-install-local post-no-install-ext post-no-install-doc

-what-where-nodoc: no-install-nodoc

-no-install-nodoc: pre-no-install-nodoc dont-install-nodoc post-no-install-nodoc

-pre-no-install-nodoc:: pre-no-install-local pre-no-install-ext

-dont-install-nodoc: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --mantype="$(MANTYPE)"

-post-no-install-nodoc:: post-no-install-local post-no-install-ext

-what-where-local: no-install-local

-no-install-local: pre-no-install-local dont-install-local post-no-install-local

-pre-no-install-local:: pre-no-install-bin pre-no-install-lib pre-no-install-man

-dont-install-local: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=local --mantype="$(MANTYPE)"

-post-no-install-local:: post-no-install-bin post-no-install-lib post-no-install-man

-what-where-ext: no-install-ext

-no-install-ext: pre-no-install-ext dont-install-ext post-no-install-ext

-pre-no-install-ext:: pre-no-install-ext-arch pre-no-install-ext-comm

-dont-install-ext: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=ext

-post-no-install-ext:: post-no-install-ext-arch post-no-install-ext-comm

-what-where-arch: no-install-arch

-no-install-arch: pre-no-install-arch dont-install-arch post-no-install-arch

-pre-no-install-arch:: pre-no-install-bin pre-no-install-ext-arch

-dont-install-arch: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=bin --install=ext-arch

-post-no-install-arch:: post-no-install-lib post-no-install-man post-no-install-ext-arch

-what-where-comm: no-install-comm

-no-install-comm: pre-no-install-comm dont-install-comm post-no-install-comm

-pre-no-install-comm:: pre-no-install-lib pre-no-install-ext-comm pre-no-install-man

-dont-install-comm: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=lib --install=ext-comm --install=man

-post-no-install-comm:: post-no-install-lib post-no-install-ext-comm post-no-install-man

-what-where-bin: no-install-bin

-no-install-bin: pre-no-install-bin dont-install-bin post-no-install-bin

-pre-no-install-bin:: install-prereq

-dont-install-bin: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=bin

-post-no-install-bin::

-what-where-lib: no-install-lib

-no-install-lib: pre-no-install-lib dont-install-lib post-no-install-lib

-pre-no-install-lib:: install-prereq

-dont-install-lib: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=lib

-post-no-install-lib::

-what-where-ext-comm: no-install-ext-comm

-no-install-ext-comm: pre-no-install-ext-comm dont-install-ext-comm post-no-install-ext-comm

-pre-no-install-ext-comm:: install-prereq

-dont-install-ext-comm: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=ext-comm

-post-no-install-ext-comm::

-what-where-ext-arch: no-install-ext-arch

-no-install-ext-arch: pre-no-install-ext-arch dont-install-ext-arch post-no-install-ext-arch

-pre-no-install-ext-arch:: install-prereq

-dont-install-ext-arch: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=ext-arch

-post-no-install-ext-arch::

-what-where-man: no-install-man

-no-install-man: pre-no-install-man dont-install-man post-no-install-man

-pre-no-install-man:: install-prereq

-dont-install-man: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=man --mantype="$(MANTYPE)"

-post-no-install-man::

-install-doc: rdoc pre-install-doc do-install-doc post-install-doc

-pre-install-doc:: install-prereq

-do-install-doc: $(PROGRAM)

- $(INSTRUBY) --make="$(MAKE)" $(INSTRUBY_ARGS) --install=rdoc --rdoc-output="$(RDOCOUT)"

- @echo Generating RDoc documentation

- $(XRUBY) "$(srcdir)/bin/rdoc" --no-force-update --all --ri --op "$(RDOCOUT)" $(RDOCFLAGS) "$(srcdir)"

-what-where-doc: no-install-doc

-no-install-doc: pre-no-install-doc dont-install-doc post-no-install-doc

-pre-no-install-doc:: install-prereq

-dont-install-doc:: $(PREP)

- $(INSTRUBY) -n --make="$(MAKE)" $(INSTRUBY_ARGS) --install=rdoc --rdoc-output="$(RDOCOUT)"

-post-no-install-doc::

-CLEAR_INSTALLED_LIST = clear-installed-list

-install-prereq: $(CLEAR_INSTALLED_LIST) PHONY

-clear-installed-list: PHONY

- @> $(INSTALLED_LIST) set MAKE="$(MAKE)"

-clean: clean-ext clean-local clean-enc clean-golf clean-rdoc clean-extout

-clean-local:: PHONY

- @$(RM) $(OBJS) $(MINIOBJS) $(MAINOBJ) $(LIBRUBY_A) $(LIBRUBY_SO) $(LIBRUBY) $(LIBRUBY_ALIASES)

- @$(RM) $(PROGRAM) $(WPROGRAM) miniruby$(EXEEXT) dmyext.$(OBJEXT) $(ARCHFILE) .*.time

- @$(RM) *.inc y.tab.c y.output encdb.h transdb.h

- @$(RM) $(GORUBY)$(EXEEXT) $(GOLFOBJS)

-clean-extout: PHONY

- @-$(RMDIRS) $(EXTOUT)/$(arch)

-distclean: distclean-ext distclean-local distclean-enc distclean-golf distclean-extout

-distclean-local:: clean-local

- @$(RM) $(MKFILES) rbconfig.rb yasmdata.rb encdb.h

- @$(RM) config.cache config.log config.status config.status.lineno $(PRELUDES)

- @$(RM) *~ *.bak *.stackdump core *.core gmon.out $(PREP)

-distclean-ext:: PHONY

-distclean-golf: clean-golf

- @$(RM) $(GOLFPRELUDES)

-distclean-rdoc: PHONY

-distclean-extout: clean-extout

- @-$(RMDIRS) $(EXTOUT)

-realclean:: realclean-ext realclean-local realclean-enc realclean-golf realclean-extout

-realclean-local:: distclean-local

- @$(RM) parse.c parse.h lex.c newline.c revision.h id.h

-realclean-golf: distclean-golf

-realclean-extout: distclean-extout

-clean-enc distclean-enc realclean-enc:

- @echo $(@:-enc=ing) encodings

- @-$(MAKE) -f $(ENC_MK) $(MFLAGS) $(@:-enc=)

-check: test test-all

-check-ruby: test test-ruby

-btest: miniruby$(EXEEXT) $(TEST_RUNNABLE)-btest

- $(BOOTSTRAPRUBY) "$(srcdir)/bootstraptest/runner.rb" --ruby="$(MINIRUBY)" $(OPTS)

-btest-ruby: miniruby$(EXEEXT) $(RBCONFIG) $(PROGRAM) $(TEST_RUNNABLE)-btest-ruby

-no-btest-ruby: PHONY

-yes-btest-ruby: PHONY

- @$(RUNRUBY) "$(srcdir)/bootstraptest/runner.rb" --ruby="$(PROGRAM) -I$(srcdir)/lib" -q $(OPTS)

-test-sample: miniruby$(EXEEXT) $(RBCONFIG) $(PROGRAM) $(TEST_RUNNABLE)-test-sample

-no-test-sample: PHONY

-yes-test-sample: PHONY

- @$(RUNRUBY) $(srcdir)/tool/rubytest.rb

-test-knownbugs: test-knownbug

-test-knownbug: miniruby$(EXEEXT) $(PROGRAM) $(RBCONFIG) $(TEST_RUNNABLE)-test-knownbug

-no-test-knownbug: PHONY

-yes-test-knownbug: PHONY

- -$(RUNRUBY) "$(srcdir)/bootstraptest/runner.rb" --ruby="$(PROGRAM)" $(OPTS) $(srcdir)/KNOWNBUGS.rb

-test: test-sample btest-ruby test-knownbug

-test-all: $(TEST_RUNNABLE)-test-all

-yes-test-all: PHONY

- $(RUNRUBY) "$(srcdir)/test/runner.rb" $(TESTS)

-test-ruby: $(TEST_RUNNABLE)-test-ruby

-no-test-ruby: PHONY

-yes-test-ruby: PHONY

- $(RUNRUBY) "$(srcdir)/test/runner.rb" ruby

- $(MAKEDIRS) "$(EXTCONFDIR)"

- $(RUNRUBY) -C "$(EXTCONFDIR)" $(EXTCONF) $(EXTCONFARGS)

-$(RBCONFIG): $(srcdir)/tool/mkconfig.rb config.status $(PREP)

- @$(MINIRUBY) $(srcdir)/tool/mkconfig.rb -timestamp=$@ \

- -install_name=$(RUBY_INSTALL_NAME) \

- -so_name=$(RUBY_SO_NAME) rbconfig.rb

-encs enc trans: $(ENC_MK) $(LIBRUBY) $(PREP)

- $(MAKE) -f $(ENC_MK) RUBY="$(MINIRUBY)" MINIRUBY="$(MINIRUBY)" $(MFLAGS) $@

-enc: {$(VPATH)}encdb.h

-trans: {$(VPATH)}transdb.h

-$(ENC_MK): $(srcdir)/enc/make_encmake.rb $(srcdir)/enc/Makefile.in $(srcdir)/enc/depend \

- $(srcdir)/lib/mkmf.rb $(RBCONFIG)

- $(MINIRUBY) $(srcdir)/enc/make_encmake.rb --builtin-encs="$(BUILTIN_ENCOBJS)" --builtin-transes="$(BUILTIN_TRANSOBJS)" $@ $(ENCS)

-.PRECIOUS: $(MKFILES)

-.PHONY: PHONY all fake prereq incs srcs preludes help

-.PHONY: test install install-nodoc install-doc dist

-.PHONY: loadpath golf capi rdoc install-prereq clear-installed-list

-.PHONY: clean clean-ext clean-local clean-enc clean-golf clean-rdoc clean-extout

-.PHONY: distclean distclean-ext distclean-local distclean-enc distclean-golf distclean-extout

-.PHONY: realclean realclean-ext realclean-local realclean-enc realclean-golf realclean-extout

-.PHONY: check test test-all btest btest-ruby test-sample test-knownbug

-.PHONY: run runruby parse benchmark benchmark-each tbench gdb gdb-ruby

-.PHONY: update-mspec update-rubyspec test-rubyspec

-{$(VPATH)}parse.c: {$(VPATH)}parse.y $(srcdir)/tool/ytab.sed

-parse.h {$(VPATH)}parse.h: {$(VPATH)}parse.c

- $(YACC) -d $(YFLAGS) -o y.tab.c $(SRC_FILE)

- sed -f $(srcdir)/tool/ytab.sed -e "/^#/s!y\.tab\.c!$@!" y.tab.c > $@.new

- sed -e "/^#line.*y\.tab\.h/d;/^#line.*parse\.y/d" y.tab.h > $(@:.c=.h).new

- @$(IFCHANGE) $(@:.c=.h) $(@:.c=.h).new

- @$(RM) y.tab.c y.tab.h

-acosh.$(OBJEXT): {$(VPATH)}acosh.c

-alloca.$(OBJEXT): {$(VPATH)}alloca.c {$(VPATH)}config.h

-crypt.$(OBJEXT): {$(VPATH)}crypt.c

-dup2.$(OBJEXT): {$(VPATH)}dup2.c

-erf.$(OBJEXT): {$(VPATH)}erf.c

-finite.$(OBJEXT): {$(VPATH)}finite.c

-flock.$(OBJEXT): {$(VPATH)}flock.c

-memcmp.$(OBJEXT): {$(VPATH)}memcmp.c

-memmove.$(OBJEXT): {$(VPATH)}memmove.c

-mkdir.$(OBJEXT): {$(VPATH)}mkdir.c

-strchr.$(OBJEXT): {$(VPATH)}strchr.c

-strdup.$(OBJEXT): {$(VPATH)}strdup.c

-strerror.$(OBJEXT): {$(VPATH)}strerror.c

-strstr.$(OBJEXT): {$(VPATH)}strstr.c

-strtod.$(OBJEXT): {$(VPATH)}strtod.c

-strtol.$(OBJEXT): {$(VPATH)}strtol.c

-nt.$(OBJEXT): {$(VPATH)}nt.c

-os2.$(OBJEXT): {$(VPATH)}os2.c

-dl_os2.$(OBJEXT): {$(VPATH)}dl_os2.c

-ia64.$(OBJEXT): {$(VPATH)}ia64.s

- $(CC) $(CFLAGS) -c $<

-win32.$(OBJEXT): {$(VPATH)}win32.c $(RUBY_H_INCLUDES)

-RUBY_H_INCLUDES = {$(VPATH)}ruby.h {$(VPATH)}config.h {$(VPATH)}defines.h \

- {$(VPATH)}intern.h {$(VPATH)}missing.h {$(VPATH)}st.h

-ENCODING_H_INCLUDES= {$(VPATH)}encoding.h {$(VPATH)}oniguruma.h

-ID_H_INCLUDES = {$(VPATH)}id.h

-VM_CORE_H_INCLUDES = {$(VPATH)}vm_core.h {$(VPATH)}vm_opts.h \

- {$(VPATH)}thread_$(THREAD_MODEL).h \

- {$(VPATH)}node.h {$(VPATH)}method.h $(ID_H_INCLUDES)

-array.$(OBJEXT): {$(VPATH)}array.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h

-bignum.$(OBJEXT): {$(VPATH)}bignum.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h

-class.$(OBJEXT): {$(VPATH)}class.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-compar.$(OBJEXT): {$(VPATH)}compar.c $(RUBY_H_INCLUDES)

-complex.$(OBJEXT): {$(VPATH)}complex.c $(RUBY_H_INCLUDES)

-dir.$(OBJEXT): {$(VPATH)}dir.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h \

- $(ENCODING_H_INCLUDES)

-dln.$(OBJEXT): {$(VPATH)}dln.c {$(VPATH)}dln.h $(RUBY_H_INCLUDES)

-dln_find.$(OBJEXT): {$(VPATH)}dln_find.c {$(VPATH)}dln.h $(RUBY_H_INCLUDES)

-dmydln.$(OBJEXT): {$(VPATH)}dmydln.c dln.$(OBJEXT)

-dmyext.$(OBJEXT): {$(VPATH)}dmyext.c

-dmyencoding.$(OBJEXT): {$(VPATH)}dmyencoding.c $(RUBY_H_INCLUDES) \

- {$(VPATH)}regenc.h {$(VPATH)}util.h $(ENCODING_H_INCLUDES) \

- {$(VPATH)}encoding.c

-encoding.$(OBJEXT): {$(VPATH)}encoding.c $(RUBY_H_INCLUDES) \

- $(ENCODING_H_INCLUDES) {$(VPATH)}regenc.h {$(VPATH)}util.h

-enum.$(OBJEXT): {$(VPATH)}enum.c $(RUBY_H_INCLUDES) {$(VPATH)}node.h \

-enumerator.$(OBJEXT): {$(VPATH)}enumerator.c $(RUBY_H_INCLUDES)

-error.$(OBJEXT): {$(VPATH)}error.c {$(VPATH)}known_errors.inc \

- $(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) $(ENCODING_H_INCLUDES) \

-eval.$(OBJEXT): {$(VPATH)}eval.c {$(VPATH)}eval_intern.h {$(VPATH)}vm.h \

- $(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) {$(VPATH)}eval_error.c \

- {$(VPATH)}eval_jump.c {$(VPATH)}debug.h {$(VPATH)}gc.h {$(VPATH)}iseq.h

-load.$(OBJEXT): {$(VPATH)}load.c {$(VPATH)}eval_intern.h \

- {$(VPATH)}util.h $(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) \

- {$(VPATH)}dln.h {$(VPATH)}debug.h

-file.$(OBJEXT): {$(VPATH)}file.c $(RUBY_H_INCLUDES) {$(VPATH)}io.h \

- $(ENCODING_H_INCLUDES) {$(VPATH)}util.h {$(VPATH)}dln.h

-gc.$(OBJEXT): {$(VPATH)}gc.c $(RUBY_H_INCLUDES) {$(VPATH)}re.h \

- {$(VPATH)}regex.h $(ENCODING_H_INCLUDES) $(VM_CORE_H_INCLUDES) \

- {$(VPATH)}gc.h {$(VPATH)}io.h {$(VPATH)}eval_intern.h {$(VPATH)}util.h \

-hash.$(OBJEXT): {$(VPATH)}hash.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h

-inits.$(OBJEXT): {$(VPATH)}inits.c $(RUBY_H_INCLUDES)

-io.$(OBJEXT): {$(VPATH)}io.c $(RUBY_H_INCLUDES) {$(VPATH)}io.h \

- {$(VPATH)}util.h $(ENCODING_H_INCLUDES) {$(VPATH)}dln.h

-main.$(OBJEXT): {$(VPATH)}main.c $(RUBY_H_INCLUDES) {$(VPATH)}debug.h \

-marshal.$(OBJEXT): {$(VPATH)}marshal.c $(RUBY_H_INCLUDES) {$(VPATH)}io.h \

- $(ENCODING_H_INCLUDES) {$(VPATH)}util.h

-math.$(OBJEXT): {$(VPATH)}math.c $(RUBY_H_INCLUDES)

-node.$(OBJEXT): {$(VPATH)}node.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES)

-numeric.$(OBJEXT): {$(VPATH)}numeric.c $(RUBY_H_INCLUDES) \

- {$(VPATH)}util.h $(ENCODING_H_INCLUDES)

-object.$(OBJEXT): {$(VPATH)}object.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h

-pack.$(OBJEXT): {$(VPATH)}pack.c $(RUBY_H_INCLUDES) {$(VPATH)}encoding.h \

- {$(VPATH)}oniguruma.h

-parse.$(OBJEXT): {$(VPATH)}parse.c $(RUBY_H_INCLUDES) {$(VPATH)}node.h \

- $(ENCODING_H_INCLUDES) $(ID_H_INCLUDES) {$(VPATH)}regenc.h \

- {$(VPATH)}regex.h {$(VPATH)}util.h {$(VPATH)}lex.c \

- {$(VPATH)}defs/keywords {$(VPATH)}id.c {$(VPATH)}parse.y \

-proc.$(OBJEXT): {$(VPATH)}proc.c {$(VPATH)}eval_intern.h \

- $(RUBY_H_INCLUDES) {$(VPATH)}gc.h $(VM_CORE_H_INCLUDES) \

-process.$(OBJEXT): {$(VPATH)}process.c $(RUBY_H_INCLUDES) \

- {$(VPATH)}util.h {$(VPATH)}io.h $(ENCODING_H_INCLUDES) {$(VPATH)}dln.h \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-random.$(OBJEXT): {$(VPATH)}random.c $(RUBY_H_INCLUDES)

-range.$(OBJEXT): {$(VPATH)}range.c $(RUBY_H_INCLUDES) \

- $(ENCODING_H_INCLUDES)

-rational.$(OBJEXT): {$(VPATH)}rational.c $(RUBY_H_INCLUDES)

-re.$(OBJEXT): {$(VPATH)}re.c $(RUBY_H_INCLUDES) {$(VPATH)}re.h \

- {$(VPATH)}regex.h $(ENCODING_H_INCLUDES) {$(VPATH)}util.h \

- {$(VPATH)}regint.h {$(VPATH)}regenc.h

-regcomp.$(OBJEXT): {$(VPATH)}regcomp.c {$(VPATH)}regparse.h \

- {$(VPATH)}regint.h {$(VPATH)}regenc.h {$(VPATH)}oniguruma.h \

- $(RUBY_H_INCLUDES)

-regenc.$(OBJEXT): {$(VPATH)}regenc.c {$(VPATH)}regint.h \

- {$(VPATH)}regenc.h {$(VPATH)}oniguruma.h $(RUBY_H_INCLUDES)

-regerror.$(OBJEXT): {$(VPATH)}regerror.c {$(VPATH)}regint.h \

- {$(VPATH)}regenc.h {$(VPATH)}oniguruma.h $(RUBY_H_INCLUDES)

-regexec.$(OBJEXT): {$(VPATH)}regexec.c {$(VPATH)}regint.h \

- {$(VPATH)}regenc.h {$(VPATH)}oniguruma.h $(RUBY_H_INCLUDES)

-regparse.$(OBJEXT): {$(VPATH)}regparse.c {$(VPATH)}regparse.h \

- {$(VPATH)}regint.h {$(VPATH)}regenc.h {$(VPATH)}oniguruma.h \

- $(RUBY_H_INCLUDES)

-regsyntax.$(OBJEXT): {$(VPATH)}regsyntax.c {$(VPATH)}regint.h \

- {$(VPATH)}regenc.h {$(VPATH)}oniguruma.h $(RUBY_H_INCLUDES)

-ruby.$(OBJEXT): {$(VPATH)}ruby.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h \

- $(ENCODING_H_INCLUDES) {$(VPATH)}eval_intern.h $(VM_CORE_H_INCLUDES) \

- {$(VPATH)}dln.h {$(VPATH)}debug.h

-safe.$(OBJEXT): {$(VPATH)}safe.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-signal.$(OBJEXT): {$(VPATH)}signal.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-sprintf.$(OBJEXT): {$(VPATH)}sprintf.c $(RUBY_H_INCLUDES) {$(VPATH)}re.h \

- {$(VPATH)}regex.h {$(VPATH)}vsnprintf.c $(ENCODING_H_INCLUDES)

-st.$(OBJEXT): {$(VPATH)}st.c {$(VPATH)}config.h {$(VPATH)}defines.h \

- {$(VPATH)}st.h {$(VPATH)}ruby.h {$(VPATH)}missing.h {$(VPATH)}intern.h

-strftime.$(OBJEXT): {$(VPATH)}strftime.c {$(VPATH)}ruby.h \

- {$(VPATH)}config.h {$(VPATH)}defines.h {$(VPATH)}missing.h \

- {$(VPATH)}intern.h {$(VPATH)}st.h {$(VPATH)}timev.h

-string.$(OBJEXT): {$(VPATH)}string.c $(RUBY_H_INCLUDES) {$(VPATH)}re.h \

- {$(VPATH)}regex.h $(ENCODING_H_INCLUDES)

-struct.$(OBJEXT): {$(VPATH)}struct.c $(RUBY_H_INCLUDES)

-thread.$(OBJEXT): {$(VPATH)}thread.c {$(VPATH)}eval_intern.h \

- $(RUBY_H_INCLUDES) {$(VPATH)}gc.h $(VM_CORE_H_INCLUDES) \

- {$(VPATH)}debug.h {$(VPATH)}thread_$(THREAD_MODEL).c

-transcode.$(OBJEXT): {$(VPATH)}transcode.c $(RUBY_H_INCLUDES) \

- $(ENCODING_H_INCLUDES) {$(VPATH)}transcode_data.h

-cont.$(OBJEXT): {$(VPATH)}cont.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}gc.h {$(VPATH)}eval_intern.h \

-time.$(OBJEXT): {$(VPATH)}time.c $(RUBY_H_INCLUDES) \

- $(ENCODING_H_INCLUDES) {$(VPATH)}timev.h

-util.$(OBJEXT): {$(VPATH)}util.c $(RUBY_H_INCLUDES) {$(VPATH)}util.h

-variable.$(OBJEXT): {$(VPATH)}variable.c $(RUBY_H_INCLUDES) \

- {$(VPATH)}node.h {$(VPATH)}util.h {$(VPATH)}encoding.h \

- {$(VPATH)}oniguruma.h

-version.$(OBJEXT): {$(VPATH)}version.c $(RUBY_H_INCLUDES) \

- {$(VPATH)}version.h $(srcdir)/revision.h {$(VPATH)}config.h

-dmyversion.$(OBJEXT): {$(VPATH)}dmyversion.c version.$(OBJEXT)

-compile.$(OBJEXT): {$(VPATH)}compile.c {$(VPATH)}iseq.h \

- $(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) {$(VPATH)}insns.inc \

- {$(VPATH)}insns_info.inc {$(VPATH)}optinsn.inc {$(VPATH)}debug.h \

- {$(VPATH)}optunifs.inc {$(VPATH)}opt_sc.inc

-iseq.$(OBJEXT): {$(VPATH)}iseq.c {$(VPATH)}gc.h {$(VPATH)}iseq.h \

- $(RUBY_H_INCLUDES) $(VM_CORE_H_INCLUDES) {$(VPATH)}insns.inc \

- {$(VPATH)}insns_info.inc {$(VPATH)}node_name.inc {$(VPATH)}debug.h

-vm.$(OBJEXT): {$(VPATH)}vm.c {$(VPATH)}gc.h {$(VPATH)}iseq.h \

- {$(VPATH)}eval_intern.h $(RUBY_H_INCLUDES) $(ENCODING_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}vm_method.c {$(VPATH)}vm_eval.c \

- {$(VPATH)}vm_insnhelper.c {$(VPATH)}vm_insnhelper.h {$(VPATH)}vm_exec.c \

- {$(VPATH)}vm_exec.h {$(VPATH)}insns.def {$(VPATH)}vmtc.inc \

- {$(VPATH)}vm.inc {$(VPATH)}insns.inc {$(VPATH)}debug.h

-vm_dump.$(OBJEXT): {$(VPATH)}vm_dump.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-debug.$(OBJEXT): {$(VPATH)}debug.c $(RUBY_H_INCLUDES) \

- $(ENCODING_H_INCLUDES) $(VM_CORE_H_INCLUDES) {$(VPATH)}eval_intern.h \

- {$(VPATH)}util.h {$(VPATH)}debug.h

-id.$(OBJEXT): {$(VPATH)}id.c $(RUBY_H_INCLUDES) $(ID_H_INCLUDES)

-miniprelude.$(OBJEXT): {$(VPATH)}miniprelude.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-prelude.$(OBJEXT): {$(VPATH)}prelude.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-golf_prelude.$(OBJEXT): {$(VPATH)}golf_prelude.c $(RUBY_H_INCLUDES) \

- $(VM_CORE_H_INCLUDES) {$(VPATH)}debug.h

-goruby.$(OBJEXT): {$(VPATH)}goruby.c {$(VPATH)}main.c $(RUBY_H_INCLUDES) \

- {$(VPATH)}debug.h {$(VPATH)}node.h

-ascii.$(OBJEXT): {$(VPATH)}ascii.c {$(VPATH)}regenc.h {$(VPATH)}config.h \

- {$(VPATH)}defines.h {$(VPATH)}oniguruma.h

-us_ascii.$(OBJEXT): {$(VPATH)}us_ascii.c {$(VPATH)}regenc.h \

- {$(VPATH)}config.h {$(VPATH)}defines.h {$(VPATH)}oniguruma.h

-unicode.$(OBJEXT): {$(VPATH)}unicode.c {$(VPATH)}regint.h \

- {$(VPATH)}config.h {$(VPATH)}defines.h {$(VPATH)}regenc.h \

- {$(VPATH)}oniguruma.h {$(VPATH)}st.h {$(VPATH)}ruby.h \

- {$(VPATH)}missing.h {$(VPATH)}intern.h {$(VPATH)}enc/unicode/name2ctype.h

-utf_8.$(OBJEXT): {$(VPATH)}utf_8.c {$(VPATH)}regenc.h {$(VPATH)}config.h \

- {$(VPATH)}defines.h {$(VPATH)}oniguruma.h

-newline.c: $(srcdir)/enc/trans/newline.trans $(srcdir)/tool/transcode-tblgen.rb

- $(BASERUBY) "$(srcdir)/tool/transcode-tblgen.rb" -vo newline.c $(srcdir)/enc/trans/newline.trans

-newline.$(OBJEXT): {$(VPATH)}newline.c {$(VPATH)}defines.h \

- {$(VPATH)}intern.h {$(VPATH)}missing.h {$(VPATH)}st.h \

- {$(VPATH)}transcode_data.h {$(VPATH)}ruby.h {$(VPATH)}config.h

-INSNS2VMOPT = --srcdir="$(srcdir)"

-{$(VPATH)}minsns.inc: $(srcdir)/template/minsns.inc.tmpl

-{$(VPATH)}opt_sc.inc: $(srcdir)/template/opt_sc.inc.tmpl

-{$(VPATH)}optinsn.inc: $(srcdir)/template/optinsn.inc.tmpl

-{$(VPATH)}optunifs.inc: $(srcdir)/template/optunifs.inc.tmpl

-{$(VPATH)}insns.inc: $(srcdir)/template/insns.inc.tmpl

-{$(VPATH)}insns_info.inc: $(srcdir)/template/insns_info.inc.tmpl

-{$(VPATH)}vmtc.inc: $(srcdir)/template/vmtc.inc.tmpl

-{$(VPATH)}vm.inc: $(srcdir)/template/vm.inc.tmpl

-srcs: {$(VPATH)}parse.c {$(VPATH)}lex.c {$(VPATH)}newline.c srcs-ext srcs-enc

-EXT_SRCS = $(srcdir)/ext/ripper/ripper.c

-srcs-ext: $(EXT_SRCS)

-srcs-enc: $(ENC_MK)

- $(MAKE) -f $(ENC_MK) RUBY="$(MINIRUBY)" MINIRUBY="$(MINIRUBY)" $(MFLAGS) srcs

-incs: $(INSNS) {$(VPATH)}node_name.inc {$(VPATH)}encdb.h {$(VPATH)}transdb.h {$(VPATH)}known_errors.inc \

- $(srcdir)/revision.h $(REVISION_H) enc/unicode/name2ctype.h

-id.h: parse.h $(srcdir)/tool/generic_erb.rb $(srcdir)/template/id.h.tmpl

- $(BASERUBY) $(srcdir)/tool/generic_erb.rb --output=$@ \

- $(srcdir)/template/id.h.tmpl --vpath=$(VPATH) parse.h

-node_name.inc: {$(VPATH)}node.h

- $(BASERUBY) -n $(srcdir)/tool/node_name.rb $? > $@

-encdb.h: $(PREP) $(srcdir)/tool/generic_erb.rb $(srcdir)/template/encdb.h.tmpl

- $(MINIRUBY) $(srcdir)/tool/generic_erb.rb -c -o $@ $(srcdir)/template/encdb.h.tmpl $(srcdir)/enc enc

-transdb.h: $(PREP) srcs-enc $(srcdir)/tool/generic_erb.rb $(srcdir)/template/transdb.h.tmpl

- $(MINIRUBY) $(srcdir)/tool/generic_erb.rb -c -o $@ $(srcdir)/template/transdb.h.tmpl $(srcdir)/enc/trans enc/trans

-known_errors.inc: $(srcdir)/template/known_errors.inc.tmpl $(srcdir)/defs/known_errors.def

- $(BASERUBY) $(srcdir)/tool/generic_erb.rb -c -o $@ $(srcdir)/template/known_errors.inc.tmpl $(srcdir)/defs/known_errors.def

-miniprelude.c: $(srcdir)/tool/compile_prelude.rb $(srcdir)/prelude.rb

- $(BASERUBY) -I$(srcdir) $(srcdir)/tool/compile_prelude.rb $(srcdir)/prelude.rb $@

-prelude.c: $(srcdir)/tool/compile_prelude.rb $(RBCONFIG) \

- $(srcdir)/lib/rubygems/defaults.rb $(srcdir)/lib/rubygems/custom_require.rb \

- $(PRELUDE_SCRIPTS) $(PREP)

- $(COMPILE_PRELUDE) $(PRELUDE_SCRIPTS) $@

-golf_prelude.c: $(srcdir)/tool/compile_prelude.rb $(RBCONFIG) $(srcdir)/prelude.rb $(srcdir)/golf_prelude.rb $(PREP)

- $(COMPILE_PRELUDE) $(srcdir)/golf_prelude.rb $@

-prereq: incs srcs preludes

-preludes: {$(VPATH)}miniprelude.c

-preludes: {$(srcdir)}golf_prelude.c

-$(srcdir)/revision.h:

-$(REVISION_H): $(srcdir)/version.h $(srcdir)/ChangeLog $(srcdir)/tool/file2lastrev.rb $(REVISION_FORCE)

- @-$(BASERUBY) $(srcdir)/tool/file2lastrev.rb --revision.h "$(srcdir)" > "$(srcdir)/revision.tmp"

- @$(IFCHANGE) "--timestamp=$@" "$(srcdir)/revision.h" "$(srcdir)/revision.tmp"

- $(CHDIR) $(@D) && $(exec) $(MAKE) -f depend $(MFLAGS) top_srcdir=../.. srcdir=.

-run: miniruby$(EXEEXT) PHONY

- $(MINIRUBY) $(TESTRUN_SCRIPT) $(RUNOPT)

-runruby: $(PROGRAM) PHONY

- $(RUNRUBY) $(TESTRUN_SCRIPT)

-parse: miniruby$(EXEEXT) PHONY

- $(MINIRUBY) $(srcdir)/tool/parse.rb $(TESTRUN_SCRIPT)

-COMPARE_RUBY = $(BASERUBY)

-benchmark: $(PROGRAM) PHONY

- $(BASERUBY) $(srcdir)/benchmark/driver.rb -v \

- --executables="$(COMPARE_RUBY); $(RUNRUBY)" \

- --pattern='bm_' --directory=$(srcdir)/benchmark $(OPTS)

-benchmark-each: $(PROGRAM) PHONY

- $(BASERUBY) $(srcdir)/benchmark/driver.rb -v \

- --executables="$(COMPARE_RUBY); $(RUNRUBY)" \

- --pattern=$(ITEM) --directory=$(srcdir)/benchmark $(OPTS)

-tbench: $(PROGRAM) PHONY

- $(BASERUBY) $(srcdir)/benchmark/driver.rb -v \

- --executables="$(COMPARE_RUBY); $(RUNRUBY)" \

- --pattern='bmx_' --directory=$(srcdir)/benchmark $(OPTS)

- echo b ruby_debug_breakpoint > run.gdb

- echo '# handle SIGINT nostop' >> run.gdb

- echo '# handle SIGPIPE nostop' >> run.gdb

- echo '# b rb_longjmp' >> run.gdb

- echo source $(srcdir)/breakpoints.gdb >> run.gdb

- echo source $(srcdir)/.gdbinit >> run.gdb

- echo run >> run.gdb

-gdb: miniruby$(EXEEXT) run.gdb PHONY

- gdb -x run.gdb --quiet --args $(MINIRUBY) $(TESTRUN_SCRIPT)

-gdb-ruby: $(PROGRAM) run.gdb PHONY

- gdb -x run.gdb --quiet --args $(PROGRAM) $(TESTRUN_SCRIPT)

- $(BASERUBY) $(srcdir)/tool/make-snapshot tmp $(RELNAME)

- -@$(MAKE) $(MFLAGS) REVISION_FORCE=PHONY "$(REVISION_H)"

-info: info-program info-libruby_a info-libruby_so info-arch

- @echo PROGRAM=$(PROGRAM)

- @echo LIBRUBY_A=$(LIBRUBY_A)

- @echo LIBRUBY_SO=$(LIBRUBY_SO)

- @echo arch=$(arch)

- @echo " Makefile of Ruby"

- @echo " all (default): builds all of below"

- @echo " miniruby: builds only miniruby"

- @echo " encs: builds encodings"

- @echo " exts: builds extensions"

- @echo " main: builds encodings, extensions and ruby"

- @echo " docs: builds documents"

- @echo " run: runs test.rb by miniruby"

- @echo " runruby: runs test.rb by ruby you just built"

- @echo " gdb: runs test.rb by miniruby under gdb"

- @echo " gdb-ruby: runs test.rb by ruby under gdb"

- @echo " check: equals make test test-all"

- @echo " test: ruby core tests"

- @echo " test-all: all ruby tests"

- @echo " test-rubyspec run RubySpec test suite"

- @echo " update-rubyspec update local copy of RubySpec"

- @echo " benchmark benchmark this ruby and COMPARE_RUBY"

- @echo " install: install all ruby distributions"

- @echo " install-nodoc: install without rdoc"

- @echo " clean: clean built objects"

- @echo " golf: for golfers"

- @echo "see DeveloperHowto for more detail: "

- @echo " http://redmine.ruby-lang.org/wiki/ruby/DeveloperHowto"

-#include "ruby/ruby.h"

-rb_cmperr(VALUE x, VALUE y)

- if (NIL_P(c)) return Qfalse;

- * obj == other -> true or false

-cmp_equal(VALUE x, VALUE y)

- * obj > other -> true or false

-cmp_gt(VALUE x, VALUE y)

- * obj >= other -> true or false

-cmp_ge(VALUE x, VALUE y)

- * obj < other -> true or false

-cmp_lt(VALUE x, VALUE y)

- * obj <= other -> true or false

-cmp_le(VALUE x, VALUE y)

- * obj.between?(min, max) -> true or false

-cmp_between(VALUE x, VALUE min, VALUE max)

- * greater than the other object. If the other object is not comparable

- * then the <code><=></code> operator should return nil.

- * <code>Comparable</code> uses

-Init_Comparable(void)

-#define rb_intern(str) rb_intern_const(str)

-/**********************************************************************

- compile.c - ruby node tree -> VM instruction sequence

- created at: 04/01/01 03:42:15 JST

-**********************************************************************/

-#include "ruby/ruby.h"

-#define USE_INSN_STACK_INCREASE 1

-#include "vm_core.h"

-#include "insns.inc"

-#include "insns_info.inc"

-#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))

-#define FIXNUM_INC(n, i) ((n)+(INT2FIX(i)&~FIXNUM_FLAG))

-#define FIXNUM_OR(n, i) ((n)|INT2FIX(i))

-typedef struct iseq_link_element {

- ISEQ_ELEMENT_NONE = INT2FIX(0x00),

- ISEQ_ELEMENT_LABEL = INT2FIX(0x01),

- ISEQ_ELEMENT_INSN = INT2FIX(0x02),

- ISEQ_ELEMENT_ADJUST = INT2FIX(0x03)

- struct iseq_link_element *next;

- struct iseq_link_element *prev;

-typedef struct iseq_link_anchor {

- LINK_ELEMENT anchor;

- LINK_ELEMENT *last;

-typedef struct iseq_label_data {

- LINK_ELEMENT link;

-typedef struct iseq_insn_data {

- LINK_ELEMENT link;

- enum ruby_vminsn_type insn_id;

-typedef struct iseq_adjust_data {

- LINK_ELEMENT link;

-struct ensure_range {

- struct ensure_range *next;

-struct iseq_compile_data_ensure_node_stack {

- NODE *ensure_node;

- struct iseq_compile_data_ensure_node_stack *prev;

- struct ensure_range *erange;

- * debug function(macro) interface depend on CPDEBUG

- * if it is less than 0, runtime option is in effect.

- * 0: no debug output

- * 1: show node type

- * 2: show node important parameters

- * 5: show other parameters

- * 10: show every AST array

-#define compile_debug CPDEBUG

-#define compile_debug iseq->compile_data->option->debug_level

-NORETURN(PRINTF_ARGS(void rb_compile_bug(const char*, int, const char*, ...), 3, 4));

-#define compile_debug_print_indent(level) \

- ruby_debug_print_indent(level, compile_debug, gl_node_level * 2)

-#define debugp(header, value) (void) \

- (compile_debug_print_indent(1) && \

- ruby_debug_print_value(1, compile_debug, header, value))

-#define debugi(header, id) (void) \

- (compile_debug_print_indent(1) && \

- ruby_debug_print_id(1, compile_debug, header, id))

-#define debugp_param(header, value) (void) \

- (compile_debug_print_indent(1) && \

- ruby_debug_print_value(1, compile_debug, header, value))

-#define debugp_verbose(header, value) (void) \

- (compile_debug_print_indent(2) && \

- ruby_debug_print_value(2, compile_debug, header, value))

-#define debugp_verbose_node(header, value) (void) \

- (compile_debug_print_indent(10) && \

- ruby_debug_print_value(10, compile_debug, header, value))

-#define debug_node_start(node) ((void) \

- (compile_debug_print_indent(1) && \

- (ruby_debug_print_node(1, CPDEBUG, "", (NODE *)node), gl_node_level)), \

-#define debug_node_end() gl_node_level --;

-static inline VALUE

-r_value(VALUE value)

-#define debugi(header, id) r_id(id)

-#define debugp(header, value) r_value(value)

-#define debugp_verbose(header, value) r_value(value)

-#define debugp_verbose_node(header, value) r_value(value)

-#define debugp_param(header, value) r_value(value)

-#define debug_node_start(node) ((void)0)

-#define debug_node_end() ((void)0)

-#if CPDEBUG > 1 || CPDEBUG < 0

-PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);

-#define debugs if (compile_debug_print_indent(1)) ruby_debug_printf

-#define debug_compile(msg, v) ((void)(compile_debug_print_indent(1) && fputs(msg, stderr)), (v))

-#define debugs if(0)printf

-#define debug_compile(msg, v) (v)

-/* create new label */

-#define NEW_LABEL(l) new_label_body(iseq, l)

-#define iseq_filename(iseq) \

- (((rb_iseq_t*)DATA_PTR(iseq))->filename)

-#define iseq_filepath(iseq) \

- (((rb_iseq_t*)DATA_PTR(iseq))->filepath)

-#define NEW_ISEQVAL(node, name, type, line_no) \

- new_child_iseq(iseq, node, name, 0, type, line_no)

-#define NEW_CHILD_ISEQVAL(node, name, type, line_no) \

- new_child_iseq(iseq, node, name, iseq->self, type, line_no)

-/* add instructions */

-#define ADD_SEQ(seq1, seq2) \

- APPEND_LIST(seq1, seq2)

-/* add an instruction */

-#define ADD_INSN(seq, line, insn) \

- ADD_ELEM(seq, (LINK_ELEMENT *) new_insn_body(iseq, line, BIN(insn), 0))

-/* add an instruction with label operand */

-#define ADD_INSNL(seq, line, insn, label) \

- ADD_ELEM(seq, (LINK_ELEMENT *) \

- new_insn_body(iseq, line, BIN(insn), 1, (VALUE)label))

-/* add an instruction with some operands (1, 2, 3, 5) */

-#define ADD_INSN1(seq, line, insn, op1) \

- ADD_ELEM(seq, (LINK_ELEMENT *) \

- new_insn_body(iseq, line, BIN(insn), 1, (VALUE)op1))

-#define ADD_INSN2(seq, line, insn, op1, op2) \

- ADD_ELEM(seq, (LINK_ELEMENT *) \

- new_insn_body(iseq, line, BIN(insn), 2, (VALUE)op1, (VALUE)op2))

-#define ADD_INSN3(seq, line, insn, op1, op2, op3) \

- ADD_ELEM(seq, (LINK_ELEMENT *) \

- new_insn_body(iseq, line, BIN(insn), 3, (VALUE)op1, (VALUE)op2, (VALUE)op3))

-/* Specific Insn factory */

-#define ADD_SEND(seq, line, id, argc) \

- ADD_SEND_R(seq, line, id, argc, (VALUE)Qfalse, (VALUE)INT2FIX(0))

-#define ADD_CALL_RECEIVER(seq, line) \

- ADD_INSN(seq, line, putnil)

-#define ADD_CALL(seq, line, id, argc) \

- ADD_SEND_R(seq, line, id, argc, (VALUE)Qfalse, (VALUE)INT2FIX(VM_CALL_FCALL_BIT))

-#define ADD_CALL_WITH_BLOCK(seq, line, id, argc, block) \

- ADD_SEND_R(seq, line, id, argc, block, (VALUE)INT2FIX(VM_CALL_FCALL_BIT))

-#define ADD_SEND_R(seq, line, id, argc, block, flag) \

- ADD_ELEM(seq, (LINK_ELEMENT *) \

- new_insn_send(iseq, line, \

- (VALUE)id, (VALUE)argc, (VALUE)block, (VALUE)flag))

-#define ADD_TRACE(seq, line, event) \

- if ((event) == RUBY_EVENT_LINE && iseq->coverage && \

- (line) != iseq->compile_data->last_coverable_line) { \

- RARRAY_PTR(iseq->coverage)[(line) - 1] = INT2FIX(0); \

- iseq->compile_data->last_coverable_line = (line); \

- ADD_INSN1(seq, line, trace, INT2FIX(RUBY_EVENT_COVERAGE)); \

- if (iseq->compile_data->option->trace_instruction) { \

- ADD_INSN1(seq, line, trace, INT2FIX(event)); \

-#define ADD_LABEL(seq, label) \

- ADD_ELEM(seq, (LINK_ELEMENT *) label)

-#define ADD_ADJUST(seq, line, label) \

- ADD_ELEM(seq, (LINK_ELEMENT *) new_adjust_body(iseq, label, line))

-#define ADD_ADJUST_RESTORE(seq, label) \

- ADD_ELEM(seq, (LINK_ELEMENT *) new_adjust_body(iseq, label, -1))

-#define ADD_CATCH_ENTRY(type, ls, le, iseqv, lc) \

- (rb_ary_push(iseq->compile_data->catch_table_ary, \

- rb_ary_new3(5, type, \

- (VALUE)(ls) | 1, (VALUE)(le) | 1, \

- iseqv, (VALUE)(lc) | 1)))

-#define COMPILE(anchor, desc, node) \

- (debug_compile("== " desc "\n", \

- iseq_compile_each(iseq, anchor, node, 0)))

-/* compile node, this node's value will be popped */

-#define COMPILE_POPED(anchor, desc, node) \

- (debug_compile("== " desc "\n", \

- iseq_compile_each(iseq, anchor, node, 1)))

-/* compile node, which is popped when 'poped' is true */

-#define COMPILE_(anchor, desc, node, poped) \

- (debug_compile("== " desc "\n", \

- iseq_compile_each(iseq, anchor, node, poped)))

-#define OPERAND_AT(insn, idx) \

- (((INSN*)(insn))->operands[idx])

-#define INSN_OF(insn) \

- (((INSN*)(insn))->insn_id)

-#define COMPILE_ERROR(strs) \

- VALUE tmp = GET_THREAD()->errinfo; \

- if (compile_debug) rb_compile_bug strs; \

- GET_THREAD()->errinfo = iseq->compile_data->err_info; \

- rb_compile_error strs; \

- iseq->compile_data->err_info = GET_THREAD()->errinfo; \

- GET_THREAD()->errinfo = tmp; \

-#define ERROR_ARGS ruby_sourcefile, nd_line(node),

-#define COMPILE_OK 1

-#define COMPILE_NG 0

-/* leave name uninitialized so that compiler warn if INIT_ANCHOR is

-#define DECL_ANCHOR(name) \

- LINK_ANCHOR *name, name##_body__ = {{0,},}

-#define INIT_ANCHOR(name) \

- (name##_body__.last = &name##_body__.anchor, name = &name##_body__)

-#define hide_obj(obj) do {OBJ_FREEZE(obj); RBASIC(obj)->klass = 0;} while (0)

-#include "optinsn.inc"

-#if OPT_INSTRUCTIONS_UNIFICATION

-#include "optunifs.inc"

-#define ISEQ_ARG iseq,

-#define ISEQ_ARG_DECLARE rb_iseq_t *iseq,

-#define ISEQ_ARG_DECLARE

-#define gl_node_level iseq->compile_data->node_level

-static void debug_list(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor);

-static void dump_disasm_list(LINK_ELEMENT *elem);

-static int insn_data_length(INSN *iobj);

-static int insn_data_line_no(INSN *iobj);

-static int calc_sp_depth(int depth, INSN *iobj);

-static void ADD_ELEM(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor, LINK_ELEMENT *elem);

-static INSN *new_insn_body(rb_iseq_t *iseq, int line_no, int insn_id, int argc, ...);

-static LABEL *new_label_body(rb_iseq_t *iseq, long line);

-static ADJUST *new_adjust_body(rb_iseq_t *iseq, LABEL *label, int line);

-static int iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * n, int);

-static int iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR *anchor);

-static int iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor);

-static int iseq_insns_unification(rb_iseq_t *iseq, LINK_ANCHOR *anchor);

-static int iseq_set_local_table(rb_iseq_t *iseq, ID *tbl);

-static int iseq_set_exception_local_table(rb_iseq_t *iseq);

-static int iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *anchor, NODE * node);

-static int iseq_set_sequence_stackcaching(rb_iseq_t *iseq, LINK_ANCHOR *anchor);

-static int iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor);

-static int iseq_set_exception_table(rb_iseq_t *iseq);

-static int iseq_set_optargs_table(rb_iseq_t *iseq);

- * To make Array to LinkedList, use link_anchor

-verify_list(ISEQ_ARG_DECLARE const char *info, LINK_ANCHOR *anchor)

- LINK_ELEMENT *list, *plist;

- if (!compile_debug) return;

- list = anchor->anchor.next;

- plist = &anchor->anchor;

- if (plist != list->prev) {

- list = list->next;

- if (anchor->last != plist && anchor->last != 0) {

- rb_bug("list verify error: %08x (%s)", flag, info);

-#define verify_list(info, anchor) verify_list(iseq, info, anchor)

- * elem1, elem2 => elem1, elem2, elem

-ADD_ELEM(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor, LINK_ELEMENT *elem)

- elem->prev = anchor->last;

- anchor->last->next = elem;

- anchor->last = elem;

- verify_list("add", anchor);

-#define ADD_ELEM(anchor, elem) ADD_ELEM(iseq, anchor, elem)

-iseq_add_mark_object(rb_iseq_t *iseq, VALUE v)

- if (!SPECIAL_CONST_P(v)) {

- rb_ary_push(iseq->mark_ary, v);

- return COMPILE_OK;

-#define ruby_sourcefile RSTRING_PTR(iseq->filename)

-iseq_add_mark_object_compile_time(rb_iseq_t *iseq, VALUE v)

- if (!SPECIAL_CONST_P(v)) {

- rb_ary_push(iseq->compile_data->mark_ary, v);

- return COMPILE_OK;

-rb_iseq_compile_node(VALUE self, NODE *node)

- GetISeqPtr(self, iseq);

- COMPILE(ret, "nil", node);

- iseq_set_local_table(iseq, 0);

- else if (nd_type(node) == NODE_SCOPE) {

- /* iseq type of top, method, class, block */

- iseq_set_local_table(iseq, node->nd_tbl);

- iseq_set_arguments(iseq, ret, node->nd_args);

- switch (iseq->type) {

- case ISEQ_TYPE_BLOCK: {

- LABEL *start = iseq->compile_data->start_label = NEW_LABEL(0);

- LABEL *end = iseq->compile_data->end_label = NEW_LABEL(0);

- ADD_LABEL(ret, start);

- COMPILE(ret, "block body", node->nd_body);

- ADD_LABEL(ret, end);

- /* wide range catch handler must put at last */

- ADD_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, 0, start);

- ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, 0, end);

- case ISEQ_TYPE_CLASS: {

- ADD_TRACE(ret, FIX2INT(iseq->line_no), RUBY_EVENT_CLASS);

- COMPILE(ret, "scoped node", node->nd_body);

- ADD_TRACE(ret, nd_line(node), RUBY_EVENT_END);

- case ISEQ_TYPE_METHOD: {

- ADD_TRACE(ret, FIX2INT(iseq->line_no), RUBY_EVENT_CALL);

- COMPILE(ret, "scoped node", node->nd_body);

- ADD_TRACE(ret, nd_line(node), RUBY_EVENT_RETURN);

- COMPILE(ret, "scoped node", node->nd_body);

- switch (iseq->type) {

- case ISEQ_TYPE_METHOD:

- case ISEQ_TYPE_CLASS:

- case ISEQ_TYPE_BLOCK:

- case ISEQ_TYPE_EVAL:

- case ISEQ_TYPE_MAIN:

- case ISEQ_TYPE_TOP:

- rb_compile_error(ERROR_ARGS "compile/should not be reached: %s:%d",

- __FILE__, __LINE__);

- case ISEQ_TYPE_RESCUE:

- iseq_set_exception_local_table(iseq);

- COMPILE(ret, "rescue", node);

- case ISEQ_TYPE_ENSURE:

- iseq_set_exception_local_table(iseq);

- COMPILE_POPED(ret, "ensure", node);

- case ISEQ_TYPE_DEFINED_GUARD:

- iseq_set_local_table(iseq, 0);

- COMPILE(ret, "defined guard", node);

- rb_bug("unknown scope");

- if (iseq->type == ISEQ_TYPE_RESCUE || iseq->type == ISEQ_TYPE_ENSURE) {

- ADD_INSN2(ret, 0, getdynamic, INT2FIX(2), INT2FIX(0));

- ADD_INSN1(ret, 0, throw, INT2FIX(0) /* continue throw */ );

- ADD_INSN(ret, iseq->compile_data->last_line, leave);

- return iseq_setup(iseq, ret);

-rb_iseq_translate_threaded_code(rb_iseq_t *iseq)

-#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE

- extern const void **rb_vm_get_insns_address_table(void);

-#if OPT_DIRECT_THREADED_CODE

- const void * const *table = rb_vm_get_insns_address_table();

- iseq->iseq_encoded = ALLOC_N(VALUE, iseq->iseq_size);

- MEMCPY(iseq->iseq_encoded, iseq->iseq, VALUE, iseq->iseq_size);

- for (i = 0; i < iseq->iseq_size; /* */ ) {

- int insn = (int)iseq->iseq_encoded[i];

- int len = insn_len(insn);

- iseq->iseq_encoded[i] = (VALUE)table[insn];

- iseq->iseq_encoded = iseq->iseq;

- return COMPILE_OK;

-/*********************************************/

-/* definition of data structure for compiler */

-/*********************************************/

-compile_data_alloc(rb_iseq_t *iseq, size_t size)

- struct iseq_compile_data_storage *storage =

- iseq->compile_data->storage_current;

- if (storage->pos + size > storage->size) {

- unsigned long alloc_size = storage->size * 2;

- if (alloc_size < size) {

- storage->next = (void *)ALLOC_N(char, alloc_size +

- iseq_compile_data_storage));

- storage = iseq->compile_data->storage_current = storage->next;

- storage->next = 0;

- storage->size = alloc_size;

- storage->buff = (char *)(&storage->buff + 1);

- ptr = (void *)&storage->buff[storage->pos];

- storage->pos += size;

-compile_data_alloc_insn(rb_iseq_t *iseq)

- return (INSN *)compile_data_alloc(iseq, sizeof(INSN));

-compile_data_alloc_label(rb_iseq_t *iseq)

- return (LABEL *)compile_data_alloc(iseq, sizeof(LABEL));

-compile_data_alloc_adjust(rb_iseq_t *iseq)

- return (ADJUST *)compile_data_alloc(iseq, sizeof(ADJUST));

- * elem1, elemX => elem1, elem2, elemX

-INSERT_ELEM_NEXT(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)

- elem2->next = elem1->next;

- elem2->prev = elem1;

- elem1->next = elem2;

- if (elem2->next) {

- elem2->next->prev = elem2;

- * elemX, elem1 => elemX, elem2, elem1

-INSERT_ELEM_PREV(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)

- elem2->prev = elem1->prev;

- elem2->next = elem1;

- elem1->prev = elem2;

- if (elem2->prev) {

- elem2->prev->next = elem2;

- * elemX, elem1, elemY => elemX, elem2, elemY

-REPLACE_ELEM(LINK_ELEMENT *elem1, LINK_ELEMENT *elem2)

- elem2->prev = elem1->prev;

- elem2->next = elem1->next;

- if (elem1->prev) {

- elem1->prev->next = elem2;

- if (elem1->next) {

- elem1->next->prev = elem2;

-REMOVE_ELEM(LINK_ELEMENT *elem)

- elem->prev->next = elem->next;

- elem->next->prev = elem->prev;

-static LINK_ELEMENT *

-FIRST_ELEMENT(LINK_ANCHOR *anchor)

- return anchor->anchor.next;

-static LINK_ELEMENT *

-LAST_ELEMENT(LINK_ANCHOR *anchor)

- return anchor->last;

-static LINK_ELEMENT *

-POP_ELEMENT(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor)

- LINK_ELEMENT *elem = anchor->last;

- anchor->last = anchor->last->prev;

- anchor->last->next = 0;

- verify_list("pop", anchor);

-#define POP_ELEMENT(anchor) POP_ELEMENT(iseq, anchor)

-static LINK_ELEMENT *

-SHIFT_ELEMENT(LINK_ANCHOR *anchor)

- LINK_ELEMENT *elem = anchor->anchor.next;

- anchor->anchor.next = elem->next;

-LIST_SIZE(LINK_ANCHOR *anchor)

- LINK_ELEMENT *elem = anchor->anchor.next;

- elem = elem->next;

-LIST_SIZE_ZERO(LINK_ANCHOR *anchor)

- if (anchor->anchor.next == 0) {

- * anc1: e1, e2, e3

- * anc1: e1, e2, e3, e4, e5

- * anc2: e4, e5 (broken)

-APPEND_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc1, LINK_ANCHOR *anc2)

- if (anc2->anchor.next) {

- anc1->last->next = anc2->anchor.next;

- anc2->anchor.next->prev = anc1->last;

- anc1->last = anc2->last;

- verify_list("append", anc1);

-#define APPEND_LIST(anc1, anc2) APPEND_LIST(iseq, anc1, anc2)

- * anc1: e1, e2, e3

- * anc1: e4, e5, e1, e2, e3

- * anc2: e4, e5 (broken)

-INSERT_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc1, LINK_ANCHOR *anc2)

- if (anc2->anchor.next) {

- LINK_ELEMENT *first = anc1->anchor.next;

- anc1->anchor.next = anc2->anchor.next;

- anc1->anchor.next->prev = &anc1->anchor;

- anc2->last->next = first;

- first->prev = anc2->last;

- anc1->last = anc2->last;

- verify_list("append", anc1);

-#define INSERT_LIST(anc1, anc2) INSERT_LIST(iseq, anc1, anc2)

- * anc1: e1, e2, e3

- * anc2: e1, e2, e3

-SWAP_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc1, LINK_ANCHOR *anc2)

- LINK_ANCHOR tmp = *anc2;

- verify_list("swap1", anc1);

- verify_list("swap2", anc2);

-#define SWAP_LIST(anc1, anc2) SWAP_LIST(iseq, anc1, anc2)

-static LINK_ANCHOR *

-REVERSE_LIST(ISEQ_ARG_DECLARE LINK_ANCHOR *anc)

- LINK_ELEMENT *first, *last, *elem, *e;

- first = &anc->anchor;

- elem = first->next;

- anc->anchor.next = last;

- elem->next = elem->prev;

- first->next = last;

- last->prev = first;

- anc->last->next = 0;

- verify_list("reverse", anc);

-#define REVERSE_LIST(anc) REVERSE_LIST(iseq, anc)

-debug_list(ISEQ_ARG_DECLARE LINK_ANCHOR *anchor)

- LINK_ELEMENT *list = FIRST_ELEMENT(anchor);

- printf("anch: %p, frst: %p, last: %p\n", &anchor->anchor,

- anchor->anchor.next, anchor->last);

- printf("curr: %p, next: %p, prev: %p, type: %d\n", list, list->next,

- list->prev, FIX2INT(list->type));

- list = list->next;

- dump_disasm_list(anchor->anchor.next);

- verify_list("debug list", anchor);

-#define debug_list(anc) debug_list(iseq, anc)

-new_label_body(rb_iseq_t *iseq, long line)

- LABEL *labelobj = compile_data_alloc_label(iseq);

- labelobj->link.type = ISEQ_ELEMENT_LABEL;

- labelobj->link.next = 0;

- labelobj->label_no = iseq->compile_data->label_no++;

- labelobj->sc_state = 0;

- labelobj->sp = -1;

-new_adjust_body(rb_iseq_t *iseq, LABEL *label, int line)

- ADJUST *adjust = compile_data_alloc_adjust(iseq);

- adjust->link.type = ISEQ_ELEMENT_ADJUST;

- adjust->link.next = 0;

- adjust->label = label;

- adjust->line_no = line;

-new_insn_core(rb_iseq_t *iseq, int line_no,

- int insn_id, int argc, VALUE *argv)

- INSN *iobj = compile_data_alloc_insn(iseq);

- /* printf("insn_id: %d, line: %d\n", insn_id, line_no); */

- iobj->link.type = ISEQ_ELEMENT_INSN;

- iobj->link.next = 0;

- iobj->insn_id = insn_id;

- iobj->line_no = line_no;

- iobj->operands = argv;

- iobj->operand_size = argc;

- iobj->sc_state = 0;

-new_insn_body(rb_iseq_t *iseq, int line_no, int insn_id, int argc, ...)

- VALUE *operands = 0;

- va_init_list(argv, argc);

- operands = (VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * argc);

- for (i = 0; i < argc; i++) {

- VALUE v = va_arg(argv, VALUE);

- return new_insn_core(iseq, line_no, insn_id, argc, operands);

-new_insn_send(rb_iseq_t *iseq, int line_no,

- VALUE id, VALUE argc, VALUE block, VALUE flag)

- (VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * 5);

- operands[1] = argc;

- operands[2] = block;

- operands[3] = flag;

- operands[4] = INT2FIX(iseq->ic_size++);

- iobj = new_insn_core(iseq, line_no, BIN(send), 5, operands);

-new_child_iseq(rb_iseq_t *iseq, NODE *node,

- VALUE name, VALUE parent, VALUE type, int line_no)

- debugs("[new_child_iseq]> ---------------------------------------\n");

- ret = rb_iseq_new_with_opt(node, name, iseq_filename(iseq->self), iseq_filepath(iseq->self), INT2FIX(line_no),

- parent, type, iseq->compile_data->option);

- debugs("[new_child_iseq]< ---------------------------------------\n");

- iseq_add_mark_object(iseq, ret);

-iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR *anchor)

- /* debugs("[compile step 2] (iseq_array_to_linkedlist)\n"); */

- if (compile_debug > 5)

- dump_disasm_list(FIRST_ELEMENT(anchor));

- debugs("[compile step 3.1 (iseq_optimize)]\n");

- iseq_optimize(iseq, anchor);

- if (compile_debug > 5)

- dump_disasm_list(FIRST_ELEMENT(anchor));

- if (iseq->compile_data->option->instructions_unification) {

- debugs("[compile step 3.2 (iseq_insns_unification)]\n");

- iseq_insns_unification(iseq, anchor);

- if (compile_debug > 5)

- dump_disasm_list(FIRST_ELEMENT(anchor));

- if (iseq->compile_data->option->stack_caching) {

- debugs("[compile step 3.3 (iseq_set_sequence_stackcaching)]\n");

- iseq_set_sequence_stackcaching(iseq, anchor);

- if (compile_debug > 5)

- dump_disasm_list(FIRST_ELEMENT(anchor));

- debugs("[compile step 4.1 (iseq_set_sequence)]\n");

- iseq_set_sequence(iseq, anchor);

- if (compile_debug > 5)

- dump_disasm_list(FIRST_ELEMENT(anchor));

- debugs("[compile step 4.2 (iseq_set_exception_table)]\n");

- iseq_set_exception_table(iseq);

- debugs("[compile step 4.3 (set_optargs_table)] \n");

- iseq_set_optargs_table(iseq);

- debugs("[compile step 5 (iseq_translate_threaded_code)] \n");

- rb_iseq_translate_threaded_code(iseq);

- if (compile_debug > 1) {

- VALUE str = rb_iseq_disasm(iseq->self);

- printf("%s\n", StringValueCStr(str));

- debugs("[compile step: finish]\n");

-iseq_set_exception_local_table(rb_iseq_t *iseq)

- ID id_dollar_bang;

- CONST_ID(id_dollar_bang, "#$!");

- iseq->local_table = (ID *)ALLOC_N(ID *, 1);

- iseq->local_table_size = 1;

- iseq->local_size = iseq->local_table_size + 1;

- iseq->local_table[0] = id_dollar_bang;

- return COMPILE_OK;

-get_dyna_var_idx_at_raw(rb_iseq_t *iseq, ID id)

- for (i = 0; i < iseq->local_table_size; i++) {

- if (iseq->local_table[i] == id) {

-get_local_var_idx(rb_iseq_t *iseq, ID id)

- int idx = get_dyna_var_idx_at_raw(iseq->local_iseq, id);

- rb_bug("get_local_var_idx: %d", idx);

-get_dyna_var_idx(rb_iseq_t *iseq, ID id, int *level, int *ls)

- int lv = 0, idx = -1;

- idx = get_dyna_var_idx_at_raw(iseq, id);

- iseq = iseq->parent_iseq;

- rb_bug("get_dyna_var_idx: -1");

- *ls = iseq->local_size;

-iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)

- debugs("iseq_set_arguments: %s\n", node_args ? "" : "0");

- NODE *node_aux = node_args->nd_next;

- NODE *node_opt = node_args->nd_opt;

- int last_comma = 0;

- NODE *node_init = 0;

- if (nd_type(node_args) != NODE_ARGS) {

- rb_bug("iseq_set_arguments: NODE_ARGS is expected, but %s",

- ruby_node_name(nd_type(node_args)));

- * new argument information:

- * NODE_ARGS [m: int, o: NODE_OPT_ARG, ->]

- * NODE_ARGS_AUX [r: ID, b: ID, ->]

- * NODE_ARGS_AUX [Pst: id, Plen: int, init: NODE*]

- * optarg information:

- * NODE_OPT_ARGS [idx, expr, next ->]

- * NODE_AND(m_init, p_init)

- * if "r" is 1, it's means "{|x,|}" type block parameter.

- iseq->argc = (int)node_args->nd_frml;

- debugs(" - argc: %d\n", iseq->argc);

- rest_id = node_aux->nd_rest;

- if (rest_id == 1) {

- block_id = (ID)node_aux->nd_body;

- node_aux = node_aux->nd_next;

- ID post_start_id = node_aux->nd_pid;

- iseq->arg_post_start = get_dyna_var_idx_at_raw(iseq, post_start_id);

- iseq->arg_post_len = (int)node_aux->nd_plen;

- node_init = node_aux->nd_next;

- NODE *node = node_opt;

- VALUE labels = rb_ary_tmp_new(1);

- label = NEW_LABEL(nd_line(node));

- rb_ary_push(labels, (VALUE)label | 1);

- ADD_LABEL(optargs, label);

- COMPILE_POPED(optargs, "optarg", node->nd_body);

- node = node->nd_next;

- label = NEW_LABEL(nd_line(node_args));

- rb_ary_push(labels, (VALUE)label | 1);

- ADD_LABEL(optargs, label);

- iseq->arg_opts = i;

- iseq->arg_opt_table = ALLOC_N(VALUE, i);

- MEMCPY(iseq->arg_opt_table, RARRAY_PTR(labels), VALUE, i);

- for (j = 0; j < i; j++) {

- iseq->arg_opt_table[j] &= ~1;

- rb_ary_clear(labels);

- iseq->arg_opts = 0;

- if (node_init->nd_1st) { /* m_init */

- COMPILE_POPED(optargs, "init arguments (m)", node_init->nd_1st);

- if (node_init->nd_2nd) { /* p_init */

- COMPILE_POPED(optargs, "init arguments (p)", node_init->nd_2nd);

- iseq->arg_rest = get_dyna_var_idx_at_raw(iseq, rest_id);

- if (iseq->arg_rest == -1) {

- rb_bug("arg_rest: -1");

- if (iseq->arg_post_start == 0) {

- iseq->arg_post_start = iseq->arg_rest + 1;

- iseq->arg_block = get_dyna_var_idx_at_raw(iseq, block_id);

- if (iseq->arg_opts != 0 || iseq->arg_post_len != 0 ||

- iseq->arg_rest != -1 || iseq->arg_block != -1) {

- iseq->arg_simple = 0;

- /* set arg_size: size of arguments */

- if (iseq->arg_block != -1) {

- iseq->arg_size = iseq->arg_block + 1;

- else if (iseq->arg_post_len) {

- iseq->arg_size = iseq->arg_post_start + iseq->arg_post_len;

- else if (iseq->arg_rest != -1) {

- iseq->arg_size = iseq->arg_rest + 1;

- else if (iseq->arg_opts) {

- iseq->arg_size = iseq->argc + iseq->arg_opts - 1;

- iseq->arg_size = iseq->argc;

- iseq->arg_simple = 1;

- iseq->arg_size = iseq->argc;

- if (iseq->type == ISEQ_TYPE_BLOCK) {

- if (iseq->arg_opts == 0 && iseq->arg_post_len == 0 && iseq->arg_rest == -1) {

- if (iseq->argc == 1 && last_comma == 0) {

- iseq->arg_simple |= 0x02;

- iseq->arg_simple = 1;

- return COMPILE_OK;

-iseq_set_local_table(rb_iseq_t *iseq, ID *tbl)

- iseq->local_table = (ID *)ALLOC_N(ID *, size);

- MEMCPY(iseq->local_table, tbl, ID *, size);

- iseq->local_size = iseq->local_table_size = size;

- iseq->local_size += 1;

- if (lfp == dfp ) { // top, class, method

- debugs("iseq_set_local_table: %d, %d\n", iseq->local_size, iseq->local_table_size);

- return COMPILE_OK;

-cdhash_cmp(VALUE val, VALUE lit)

- if (val == lit) return 0;

- if (SPECIAL_CONST_P(lit)) {

- return val != lit;

- if (SPECIAL_CONST_P(val) || BUILTIN_TYPE(val) != BUILTIN_TYPE(lit)) {

- if (BUILTIN_TYPE(lit) == T_STRING) {

- return rb_str_hash_cmp(lit, val);

- return !rb_eql(lit, val);

-cdhash_hash(VALUE a)

- if (SPECIAL_CONST_P(a)) return (st_index_t)a;

- if (TYPE(a) == T_STRING) return rb_str_hash(a);

- VALUE hval = rb_hash(a);

- return (st_index_t)FIX2LONG(hval);

-static const struct st_hash_type cdhash_type = {

- ruby insn object array -> raw instruction sequence

-iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor)

- struct iseq_insn_info_entry *insn_info_table;

- LINK_ELEMENT *list;

- VALUE *generated_iseq;

- int k, pos, sp, stack_max = 0, line = 0;

- /* set label position */

- list = FIRST_ELEMENT(anchor);

- switch (list->type) {

- case ISEQ_ELEMENT_INSN:

- iobj = (INSN *)list;

- line = iobj->line_no;

- pos += insn_data_length(iobj);

- case ISEQ_ELEMENT_LABEL:

- lobj = (LABEL *)list;

- lobj->position = pos;

- case ISEQ_ELEMENT_NONE:

- case ISEQ_ELEMENT_ADJUST:

- ADJUST *adjust = (ADJUST *)list;

- if (adjust->line_no != -1) {

- pos += 2 /* insn + 1 operand */;

- dump_disasm_list(FIRST_ELEMENT(anchor));

- dump_disasm_list(list);

- rb_compile_error(RSTRING_PTR(iseq->filename), line,

- "error: set_sequence");

- list = list->next;

- /* make instruction sequence */

- generated_iseq = ALLOC_N(VALUE, pos);

- insn_info_table = ALLOC_N(struct iseq_insn_info_entry, k);

- iseq->ic_entries = ALLOC_N(struct iseq_inline_cache_entry, iseq->ic_size);

- MEMZERO(iseq->ic_entries, struct iseq_inline_cache_entry, iseq->ic_size);

- list = FIRST_ELEMENT(anchor);

- switch (list->type) {

- case ISEQ_ELEMENT_INSN:

- const char *types;

- iobj = (INSN *)list;

- sp = calc_sp_depth(sp, iobj);

- if (sp > stack_max) {

- /* fprintf(stderr, "insn: %-16s, sp: %d\n", insn_name(iobj->insn_id), sp); */

- operands = iobj->operands;

- insn = iobj->insn_id;

- generated_iseq[pos] = insn;

- types = insn_op_types(insn);

- len = insn_len(insn);

- /* operand check */

- if (iobj->operand_size != len - 1) {

- /* printf("operand size miss! (%d, %d)\n", iobj->operand_size, len); */

- dump_disasm_list(list);

- rb_compile_error(RSTRING_PTR(iseq->filename), iobj->line_no,

- "operand size miss! (%d for %d)",

- iobj->operand_size, len - 1);

- xfree(generated_iseq);

- xfree(insn_info_table);

- for (j = 0; types[j]; j++) {

- char type = types[j];

- /* printf("--> [%c - (%d-%d)]\n", type, k, j); */

- /* label(destination position) */

- lobj = (LABEL *)operands[j];

- rb_compile_error(RSTRING_PTR(iseq->filename), iobj->line_no,

- if (lobj->sp == -1) {

- generated_iseq[pos + 1 + j] =

- lobj->position - (pos + len);

- * [obj, label, ...]

- VALUE lits = operands[j];

- VALUE map = rb_hash_new();

- RHASH_TBL(map)->type = &cdhash_type;

- for (i=0; i < RARRAY_LEN(lits); i+=2) {

- VALUE obj = rb_ary_entry(lits, i);

- VALUE lv = rb_ary_entry(lits, i+1);

- lobj = (LABEL *)(lv & ~1);

- rb_compile_error(RSTRING_PTR(iseq->filename), iobj->line_no,

- if (!st_lookup(rb_hash_tbl(map), obj, 0)) {

- rb_hash_aset(map, obj, INT2FIX(lobj->position - (pos+len)));

- rb_compile_warning(RSTRING_PTR(iseq->filename), iobj->line_no,

- "duplicated when clause is ignored");

- generated_iseq[pos + 1 + j] = map;

- iseq_add_mark_object(iseq, map);

- case TS_NUM: /* ulong */

- generated_iseq[pos + 1 + j] = FIX2INT(operands[j]);

- case TS_ISEQ: /* iseq */

- VALUE v = operands[j];

- rb_iseq_t *block = 0;

- GetISeqPtr(v, block);

- generated_iseq[pos + 1 + j] = (VALUE)block;

- case TS_VALUE: /* VALUE */

- VALUE v = operands[j];

- generated_iseq[pos + 1 + j] = v;

- /* to mark ruby object */

- iseq_add_mark_object(iseq, v);

- case TS_IC: /* inline cache */

- int ic_index = FIX2INT(operands[j]);

- IC ic = &iseq->ic_entries[ic_index];

- if (UNLIKELY(ic_index >= iseq->ic_size)) {

- rb_bug("iseq_set_sequence: ic_index overflow: index: %d, size: %d",

- ic_index, iseq->ic_size);

- generated_iseq[pos + 1 + j] = (VALUE)ic;

- case TS_ID: /* ID */

- generated_iseq[pos + 1 + j] = SYM2ID(operands[j]);

- struct rb_global_entry *entry =

- (struct rb_global_entry *)(operands[j] & (~1));

- generated_iseq[pos + 1 + j] = (VALUE)entry;

- rb_compile_error(RSTRING_PTR(iseq->filename), iobj->line_no,

- "unknown operand type: %c", type);

- xfree(generated_iseq);

- xfree(insn_info_table);

- insn_info_table[k].line_no = iobj->line_no;

- insn_info_table[k].position = pos;

- insn_info_table[k].sp = sp;

- case ISEQ_ELEMENT_LABEL:

- lobj = (LABEL *)list;

- if (lobj->sp == -1) {

- case ISEQ_ELEMENT_ADJUST:

- ADJUST *adjust = (ADJUST *)list;

- if (adjust->label) {

- sp = adjust->label->sp;

- if (adjust->line_no != -1) {

- if (orig_sp - sp > 0) {

- insn_info_table[k].line_no = adjust->line_no;

- insn_info_table[k].position = pos;

- insn_info_table[k].sp = sp;

- generated_iseq[pos++] = BIN(adjuststack);

- generated_iseq[pos++] = orig_sp - sp;

- else if (orig_sp - sp == 0) {

- /* jump to next insn */

- insn_info_table[k].line_no = adjust->line_no;

- insn_info_table[k].position = pos;

- insn_info_table[k].sp = sp;

- generated_iseq[pos++] = BIN(jump);

- generated_iseq[pos++] = 0;

- rb_bug("iseq_set_sequence: adjust bug");

- list = list->next;

- /* this check need dead code elimination */

- rb_bug("SP is not 0 on %s (%d)\n", RSTRING_PTR(iseq->name), sp);

- iseq->iseq = (void *)generated_iseq;

- iseq->iseq_size = pos;

- iseq->insn_info_table = insn_info_table;

- iseq->insn_info_size = k;

- iseq->stack_max = stack_max;

- return COMPILE_OK;

-label_get_position(LABEL *lobj)

- return lobj->position;

-label_get_sp(LABEL *lobj)

-iseq_set_exception_table(rb_iseq_t *iseq)

- VALUE *tptr, *ptr;

- struct iseq_catch_table_entry *entry;

- tlen = (int)RARRAY_LEN(iseq->compile_data->catch_table_ary);

- tptr = RARRAY_PTR(iseq->compile_data->catch_table_ary);

- iseq->catch_table = tlen ? ALLOC_N(struct iseq_catch_table_entry, tlen) : 0;

- iseq->catch_table_size = tlen;

- for (i = 0; i < tlen; i++) {

- ptr = RARRAY_PTR(tptr[i]);

- entry = &iseq->catch_table[i];

- entry->type = ptr[0] & 0xffff;

- entry->start = label_get_position((LABEL *)(ptr[1] & ~1));

- entry->end = label_get_position((LABEL *)(ptr[2] & ~1));

- entry->iseq = ptr[3];

- /* register iseq as mark object */

- if (entry->iseq != 0) {

- iseq_add_mark_object(iseq, entry->iseq);

- LABEL *lobj = (LABEL *)(ptr[4] & ~1);

- entry->cont = label_get_position(lobj);

- entry->sp = label_get_sp(lobj);

- /* TODO: Dirty Hack! Fix me */

- if (entry->type == CATCH_TYPE_RESCUE ||

- entry->type == CATCH_TYPE_BREAK ||

- entry->type == CATCH_TYPE_NEXT) {

- iseq->compile_data->catch_table_ary = 0; /* free */

- return COMPILE_OK;

- * set optional argument table

- * def foo(a, b=expr1, c=expr2)

-iseq_set_optargs_table(rb_iseq_t *iseq)

- if (iseq->arg_opts != 0) {

- for (i = 0; i < iseq->arg_opts; i++) {

- iseq->arg_opt_table[i] =

- label_get_position((LABEL *)iseq->arg_opt_table[i]);

- return COMPILE_OK;

-static LINK_ELEMENT *

-get_destination_insn(INSN *iobj)

- LABEL *lobj = (LABEL *)OPERAND_AT(iobj, 0);

- LINK_ELEMENT *list;

- list = lobj->link.next;

- if (list->type == ISEQ_ELEMENT_INSN || list->type == ISEQ_ELEMENT_ADJUST) {

- list = list->next;

-static LINK_ELEMENT *

-get_next_insn(INSN *iobj)

- LINK_ELEMENT *list = iobj->link.next;

- if (list->type == ISEQ_ELEMENT_INSN || list->type == ISEQ_ELEMENT_ADJUST) {

- list = list->next;

-static LINK_ELEMENT *

-get_prev_insn(INSN *iobj)

- LINK_ELEMENT *list = iobj->link.prev;

- if (list->type == ISEQ_ELEMENT_INSN || list->type == ISEQ_ELEMENT_ADJUST) {

- list = list->prev;

-iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list, const int do_tailcallopt)

- INSN *iobj = (INSN *)list;

- if (iobj->insn_id == BIN(jump)) {

- INSN *niobj, *diobj, *piobj;

- * useless jump elimination:

- * => in this case, first jump instruction should jump to

- diobj = (INSN *)get_destination_insn(iobj);

- niobj = (INSN *)get_next_insn(iobj);

- if (diobj == niobj) {

- REMOVE_ELEM(&iobj->link);

- else if (iobj != diobj && diobj->insn_id == BIN(jump)) {

- if (OPERAND_AT(iobj, 0) != OPERAND_AT(diobj, 0)) {

- OPERAND_AT(iobj, 0) = OPERAND_AT(diobj, 0);

- else if (diobj->insn_id == BIN(leave)) {

- INSN *eiobj = new_insn_core(iseq, iobj->line_no, BIN(leave),

- diobj->operand_size, diobj->operands);

- INSN *popiobj = new_insn_core(iseq, iobj->line_no,

- REPLACE_ELEM((LINK_ELEMENT *)iobj, (LINK_ELEMENT *)eiobj);

- INSERT_ELEM_NEXT((LINK_ELEMENT *)eiobj, (LINK_ELEMENT *)popiobj);

- * useless jump elimination (if/unless destination):

- else if ((piobj = (INSN *)get_prev_insn(iobj)) != 0 &&

- (piobj->insn_id == BIN(branchif) ||

- piobj->insn_id == BIN(branchunless))) {

- if (niobj == (INSN *)get_destination_insn(piobj)) {

- piobj->insn_id = (piobj->insn_id == BIN(branchif))

- ? BIN(branchunless) : BIN(branchif);

- OPERAND_AT(piobj, 0) = OPERAND_AT(iobj, 0);

- REMOVE_ELEM(&iobj->link);

- if (iobj->insn_id == BIN(branchif) ||

- iobj->insn_id == BIN(branchunless)) {

- INSN *nobj = (INSN *)get_destination_insn(iobj);

- if (nobj->insn_id == BIN(jump)) {

- OPERAND_AT(iobj, 0) = OPERAND_AT(nobj, 0);

- if (do_tailcallopt && iobj->insn_id == BIN(leave)) {

- * send ..., ... | VM_CALL_TAILCALL_BIT, ...

- * leave # unreachable

- INSN *piobj = (INSN *)get_prev_insn((INSN *)list);

- if (piobj->insn_id == BIN(send) &&

- piobj->operands[2] == 0 /* block */

- piobj->operands[3] = FIXNUM_OR(piobj->operands[3], VM_CALL_TAILCALL_BIT);

- return COMPILE_OK;

-insn_set_specialized_instruction(rb_iseq_t *iseq, INSN *iobj, int insn_id)

- int i, old_opsize = iobj->operand_size;

- iobj->insn_id = insn_id;

- iobj->operand_size = insn_len(insn_id) - 1;

- /* printf("iobj->operand_size: %d\n", iobj->operand_size); */

- if (iobj->operand_size > old_opsize) {

- iobj->operands = (VALUE *)compile_data_alloc(iseq, iobj->operand_size);

- for (i=0; i<iobj->operand_size; i++) {

- iobj->operands[i] = INT2FIX(iseq->ic_size++);

- return COMPILE_OK;

-iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)

- if (iobj->insn_id == BIN(send)) {

- ID mid = SYM2ID(OPERAND_AT(iobj, 0));

- int argc = FIX2INT(OPERAND_AT(iobj, 1));

- VALUE block = OPERAND_AT(iobj, 2);

- VALUE flag = OPERAND_AT(iobj, 3);

- /* TODO: should be more sophisticated search */

- if (block == 0 && flag == INT2FIX(0)) {

- if (mid == idLength) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_length));

- else if (mid == idSize) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_size));

- else if (mid == idSucc) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_succ));

- else if (mid == idNot) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_not));

- else if (argc == 1) {

- else if (mid == idPLUS) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_plus));

- else if (mid == idMINUS) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_minus));

- else if (mid == idMULT) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_mult));

- else if (mid == idDIV) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_div));

- else if (mid == idMOD) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_mod));

- else if (mid == idEq) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_eq));

- else if (mid == idNeq) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_neq));

- else if (mid == idLT) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_lt));

- else if (mid == idLE) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_le));

- else if (mid == idGT) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_gt));

- else if (mid == idGE) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_ge));

- else if (mid == idLTLT) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_ltlt));

- else if (mid == idAREF) {

- insn_set_specialized_instruction(iseq, iobj, BIN(opt_aref));

- return COMPILE_OK;

-iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor)

- LINK_ELEMENT *list;

- const int do_peepholeopt = iseq->compile_data->option->peephole_optimization;

- const int do_tailcallopt = iseq->compile_data->option->tailcall_optimization;

- const int do_si = iseq->compile_data->option->specialized_instruction;

- const int do_ou = iseq->compile_data->option->operands_unification;

- list = FIRST_ELEMENT(anchor);

- if (list->type == ISEQ_ELEMENT_INSN) {

- if (do_peepholeopt) {

- iseq_peephole_optimize(iseq, list, do_tailcallopt);

- iseq_specialized_instruction(iseq, (INSN *)list);

- insn_operands_unification((INSN *)list);

- list = list->next;

- return COMPILE_OK;

-#if OPT_INSTRUCTIONS_UNIFICATION

-new_unified_insn(rb_iseq_t *iseq,

- int insn_id, int size, LINK_ELEMENT *seq_list)

- LINK_ELEMENT *list = seq_list;

- VALUE *operands = 0, *ptr = 0;

- for (i = 0; i < size; i++) {

- iobj = (INSN *)list;

- argc += iobj->operand_size;

- list = list->next;

- (VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * argc);

- /* copy operands */

- for (i = 0; i < size; i++) {

- iobj = (INSN *)list;

- MEMCPY(ptr, iobj->operands, VALUE, iobj->operand_size);

- ptr += iobj->operand_size;

- list = list->next;

- return new_insn_core(iseq, iobj->line_no, insn_id, argc, operands);

- * This scheme can get more performance if do this optimize with

- * label address resolving.

- * It's future work (if compile time was bottle neck).

-iseq_insns_unification(rb_iseq_t *iseq, LINK_ANCHOR *anchor)

-#if OPT_INSTRUCTIONS_UNIFICATION

- LINK_ELEMENT *list;

- INSN *iobj, *niobj;

- list = FIRST_ELEMENT(anchor);

- if (list->type == ISEQ_ELEMENT_INSN) {

- iobj = (INSN *)list;

- id = iobj->insn_id;

- if (unified_insns_data[id] != 0) {

- const int *const *entry = unified_insns_data[id];

- for (j = 1; j < (intptr_t)entry[0]; j++) {

- const int *unified = entry[j];

- LINK_ELEMENT *li = list->next;

- for (k = 2; k < unified[1]; k++) {

- if (li->type != ISEQ_ELEMENT_INSN ||

- ((INSN *)li)->insn_id != unified[k]) {

- new_unified_insn(iseq, unified[0], unified[1] - 1,

- /* insert to list */

- niobj->link.prev = (LINK_ELEMENT *)iobj->link.prev;

- niobj->link.next = li;

- li->prev = (LINK_ELEMENT *)niobj;

- list->prev->next = (LINK_ELEMENT *)niobj;

- list = (LINK_ELEMENT *)niobj;

- list = list->next;

- return COMPILE_OK;

-#if OPT_STACK_CACHING

-#define SC_INSN(insn, stat) sc_insn_info[(insn)][(stat)]

-#define SC_NEXT(insn) sc_insn_next[insn]

-#include "opt_sc.inc"

-insn_set_sc_state(rb_iseq_t *iseq, INSN *iobj, int state)

- insn_id = iobj->insn_id;

- iobj->insn_id = SC_INSN(insn_id, state);

- nstate = SC_NEXT(iobj->insn_id);

- if (insn_id == BIN(jump) ||

- insn_id == BIN(branchif) || insn_id == BIN(branchunless)) {

- LABEL *lobj = (LABEL *)OPERAND_AT(iobj, 0);

- if (lobj->sc_state != 0) {

- if (lobj->sc_state != nstate) {

- dump_disasm_list((LINK_ELEMENT *)iobj);

- dump_disasm_list((LINK_ELEMENT *)lobj);

- printf("\n-- %d, %d\n", lobj->sc_state, nstate);

- rb_compile_error(RSTRING_PTR(iseq->filename), iobj->line_no,

- "insn_set_sc_state error\n");

- lobj->sc_state = nstate;

- if (insn_id == BIN(jump)) {

- else if (insn_id == BIN(leave)) {

-label_set_sc_state(LABEL *lobj, int state)

- if (lobj->sc_state != 0) {

- if (lobj->sc_state != state) {

- state = lobj->sc_state;

- lobj->sc_state = state;

-iseq_set_sequence_stackcaching(rb_iseq_t *iseq, LINK_ANCHOR *anchor)

-#if OPT_STACK_CACHING

- LINK_ELEMENT *list;

- int state, insn_id;

- list = FIRST_ELEMENT(anchor);

- /* dump_disasm_list(list); */

- /* for each list element */

- switch (list->type) {

- case ISEQ_ELEMENT_INSN:

- INSN *iobj = (INSN *)list;

- insn_id = iobj->insn_id;

- /* dump_disasm_list(list); */

- switch (insn_id) {

- /* exception merge point */

- if (state != SCS_AX) {

- new_insn_body(iseq, 0, BIN(reput), 0);

- /* replace this insn */

- REPLACE_ELEM(list, (LINK_ELEMENT *)rpobj);

- list = (LINK_ELEMENT *)rpobj;

- if (state == SCS_AB || state == SCS_BA) {

- state = (state == SCS_AB ? SCS_BA : SCS_AB);

- REMOVE_ELEM(list);

- list = list->next;

- rb_compile_error(RSTRING_PTR(iseq->filename), iobj->line_no,

- /* remove useless pop */

- REMOVE_ELEM(list);

- list = list->next;

- } /* end of switch */

- state = insn_set_sc_state(iseq, iobj, state);

- case ISEQ_ELEMENT_LABEL:

- lobj = (LABEL *)list;

- state = label_set_sc_state(lobj, state);

- list = list->next;

- return COMPILE_OK;

-compile_dstr_fragments(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int *cntp)

- NODE *list = node->nd_next;

- VALUE lit = node->nd_lit;

- debugp_param("nd_lit", lit);

- if (!NIL_P(lit)) {

- ADD_INSN1(ret, nd_line(node), putobject, lit);

- COMPILE(ret, "each string", list->nd_head);

- list = list->nd_next;

- return COMPILE_OK;

-compile_dstr(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)

- compile_dstr_fragments(iseq, ret, node, &cnt);

- ADD_INSN1(ret, nd_line(node), concatstrings, INT2FIX(cnt));

- return COMPILE_OK;

-compile_dregx(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node)

- compile_dstr_fragments(iseq, ret, node, &cnt);

- ADD_INSN2(ret, nd_line(node), toregexp, INT2FIX(node->nd_cflag), INT2FIX(cnt));

- return COMPILE_OK;

-compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * cond,

- LABEL *then_label, LABEL *else_label)

- switch (nd_type(cond)) {

- LABEL *label = NEW_LABEL(nd_line(cond));

- compile_branch_condition(iseq, ret, cond->nd_1st, label,

- ADD_LABEL(ret, label);

- compile_branch_condition(iseq, ret, cond->nd_2nd, then_label,

- LABEL *label = NEW_LABEL(nd_line(cond));

- compile_branch_condition(iseq, ret, cond->nd_1st, then_label,

- ADD_LABEL(ret, label);

- compile_branch_condition(iseq, ret, cond->nd_2nd, then_label,

- case NODE_LIT: /* NODE_LIT is always not true */

- /* printf("useless condition eliminate (%s)\n", ruby_node_name(nd_type(cond))); */

- ADD_INSNL(ret, nd_line(cond), jump, then_label);

- /* printf("useless condition eliminate (%s)\n", ruby_node_name(nd_type(cond))); */

- ADD_INSNL(ret, nd_line(cond), jump, else_label);

- COMPILE(ret, "branch condition", cond);

- ADD_INSNL(ret, nd_line(cond), branchunless, else_label);

- ADD_INSNL(ret, nd_line(cond), jump, then_label);

- return COMPILE_OK;

-compile_array_(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE* node_root,

- VALUE opt_p, int poped)

- NODE *node = node_root;

- int len = (int)node->nd_alen, line = (int)nd_line(node), i=0;

- DECL_ANCHOR(anchor);

- INIT_ANCHOR(anchor);

- if (nd_type(node) != NODE_ZARRAY) {

- if (nd_type(node) != NODE_ARRAY) {

- rb_bug("compile_array: This node is not NODE_ARRAY, but %s",

- ruby_node_name(nd_type(node)));

- if (opt_p && nd_type(node->nd_head) != NODE_LIT) {

- COMPILE_(anchor, "array element", node->nd_head, poped);

- node = node->nd_next;

- rb_bug("node error: compile_array (%d: %d-%d)",

- (int)nd_line(node_root), len, i);

- if (opt_p == Qtrue) {

- VALUE ary = rb_ary_tmp_new(len);

- rb_ary_push(ary, node->nd_head->nd_lit);

- node = node->nd_next;

- iseq_add_mark_object_compile_time(iseq, ary);

- ADD_INSN1(ret, nd_line(node_root), duparray, ary);

- ADD_INSN1(anchor, line, newarray, INT2FIX(len));

- APPEND_LIST(ret, anchor);

-compile_array(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE* node_root, VALUE opt_p)

- return compile_array_(iseq, ret, node_root, opt_p, 0);

-case_when_optimizable_literal(NODE * node)

- switch (nd_type(node)) {

- VALUE v = node->nd_lit;

- if (SYMBOL_P(v) || rb_obj_is_kind_of(v, rb_cNumeric)) {

- return node->nd_lit;

-when_vals(rb_iseq_t *iseq, LINK_ANCHOR *cond_seq, NODE *vals, LABEL *l1, VALUE special_literals)

- val = vals->nd_head;

- if (special_literals &&

- (lit = case_when_optimizable_literal(val)) != Qfalse) {

- rb_ary_push(special_literals, lit);

- rb_ary_push(special_literals, (VALUE)(l1) | 1);

- special_literals = Qfalse;

- COMPILE(cond_seq, "when cond", val);

- ADD_INSN1(cond_seq, nd_line(val), topn, INT2FIX(1));

- ADD_SEND(cond_seq, nd_line(val), ID2SYM(idEqq), INT2FIX(1));

- ADD_INSNL(cond_seq, nd_line(val), branchif, l1);

- vals = vals->nd_next;

- return special_literals;

-compile_massign_lhs(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE *node)

- switch (nd_type(node)) {

- case NODE_ATTRASGN: {

- COMPILE_POPED(ret, "masgn lhs (NODE_ATTRASGN)", node);

- POP_ELEMENT(ret); /* pop pop insn */

- iobj = (INSN *)POP_ELEMENT(ret); /* pop send insn */

- dupidx = iobj->operands[1];

- dupidx = FIXNUM_INC(dupidx, 1);

- iobj->operands[1] = dupidx;

- ADD_INSN1(ret, nd_line(node), topn, dupidx);

- ADD_ELEM(ret, (LINK_ELEMENT *)iobj);

- ADD_INSN(ret, nd_line(node), pop); /* result */

- ADD_INSN(ret, nd_line(node), pop); /* rhs */

- case NODE_MASGN: {

- DECL_ANCHOR(anchor);

- INIT_ANCHOR(anchor);

- COMPILE_POPED(anchor, "nest masgn lhs", node);

- REMOVE_ELEM(FIRST_ELEMENT(anchor));

- ADD_SEQ(ret, anchor);

- DECL_ANCHOR(anchor);

- INIT_ANCHOR(anchor);

- COMPILE_POPED(anchor, "masgn lhs", node);

- REMOVE_ELEM(FIRST_ELEMENT(anchor));

- ADD_SEQ(ret, anchor);

- return COMPILE_OK;

-compile_massign_opt_lhs(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE *lhsn)

- compile_massign_opt_lhs(iseq, ret, lhsn->nd_next);

- compile_massign_lhs(iseq, ret, lhsn->nd_head);

-compile_massign_opt(rb_iseq_t *iseq, LINK_ANCHOR *ret,

- NODE *rhsn, NODE *orig_lhsn)

- const int memsize = numberof(mem);

- int llen = 0, rlen = 0;

- NODE *lhsn = orig_lhsn;

-#define MEMORY(v) { \

- if (memindex == memsize) return 0; \

- for (i=0; i<memindex; i++) { \

- if (mem[i] == (v)) return 0; \

- mem[memindex++] = (v); \

- if (rhsn == 0 || nd_type(rhsn) != NODE_ARRAY) {

- NODE *ln = lhsn->nd_head;

- switch (nd_type(ln)) {

- MEMORY(ln->nd_vid);

- case NODE_DASGN_CURR:

- MEMORY(ln->nd_vid);

- lhsn = lhsn->nd_next;

- if (llen <= rlen) {

- COMPILE_POPED(ret, "masgn val (popped)", rhsn->nd_head);

- COMPILE(ret, "masgn val", rhsn->nd_head);

- rhsn = rhsn->nd_next;

- if (llen > rlen) {

- for (i=0; i<llen-rlen; i++) {

- ADD_INSN(ret, nd_line(orig_lhsn), putnil);

- compile_massign_opt_lhs(iseq, ret, orig_lhsn);

-compile_massign(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE *node, int poped)

- NODE *rhsn = node->nd_value;

- NODE *splatn = node->nd_args;

- NODE *lhsn = node->nd_head;

- int lhs_splat = (splatn && (VALUE)splatn != (VALUE)-1) ? 1 : 0;

- if (!poped || splatn || !compile_massign_opt(iseq, ret, rhsn, lhsn)) {

- DECL_ANCHOR(lhsseq);

- INIT_ANCHOR(lhsseq);

- compile_massign_lhs(iseq, lhsseq, lhsn->nd_head);

- lhsn = lhsn->nd_next;

- COMPILE(ret, "normal masgn rhs", rhsn);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSN2(ret, nd_line(node), expandarray,

- INT2FIX(llen), INT2FIX(lhs_splat));

- ADD_SEQ(ret, lhsseq);

- if (nd_type(splatn) == NODE_POSTARG) {

- /*a, b, *r, p1, p2 */

- NODE *postn = splatn->nd_2nd;

- NODE *restn = splatn->nd_1st;

- int num = (int)postn->nd_alen;

- int flag = 0x02 | (((VALUE)restn == (VALUE)-1) ? 0x00 : 0x01);

- ADD_INSN2(ret, nd_line(splatn), expandarray,

- INT2FIX(num), INT2FIX(flag));

- if ((VALUE)restn != (VALUE)-1) {

- compile_massign_lhs(iseq, ret, restn);

- compile_massign_lhs(iseq, ret, postn->nd_head);

- postn = postn->nd_next;

- compile_massign_lhs(iseq, ret, splatn);

- return COMPILE_OK;

-compile_colon2(rb_iseq_t *iseq, NODE * node,

- LINK_ANCHOR *pref, LINK_ANCHOR *body)

- switch (nd_type(node)) {

- debugi("compile_colon2 - colon", node->nd_vid);

- ADD_INSN1(body, nd_line(node), getconstant, ID2SYM(node->nd_vid));

- debugi("compile_colon2 - colon3", node->nd_mid);

- ADD_INSN(body, nd_line(node), pop);

- ADD_INSN1(body, nd_line(node), putobject, rb_cObject);

- ADD_INSN1(body, nd_line(node), getconstant, ID2SYM(node->nd_mid));

- compile_colon2(iseq, node->nd_head, pref, body);

- debugi("compile_colon2 - colon2", node->nd_mid);

- ADD_INSN1(body, nd_line(node), getconstant, ID2SYM(node->nd_mid));

- COMPILE(pref, "const colon2 prefix", node);

- return COMPILE_OK;

-compile_cpath(LINK_ANCHOR *ret, rb_iseq_t *iseq, NODE *cpath)

- if (nd_type(cpath) == NODE_COLON3) {

- /* toplevel class ::Foo */

- ADD_INSN1(ret, nd_line(cpath), putobject, rb_cObject);

- else if (cpath->nd_head) {

- COMPILE(ret, "nd_else->nd_head", cpath->nd_head);

- /* class at cbase Foo */

- ADD_INSN1(ret, nd_line(cpath), putspecialobject,

- INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));

-defined_expr(rb_iseq_t *iseq, LINK_ANCHOR *ret,

- NODE *node, LABEL **lfinish, VALUE needstr)

- const char *estr = 0;

- enum node_type type;

- switch (type = nd_type(node)) {

- /* easy literals */

- NODE *vals = node;

- defined_expr(iseq, ret, vals->nd_head, lfinish, Qfalse);

- if (!lfinish[1]) {

- lfinish[1] = NEW_LABEL(nd_line(node));

- ADD_INSNL(ret, nd_line(node), branchunless, lfinish[1]);

- } while ((vals = vals->nd_next) != NULL);

- estr = "expression";

- estr = "local-variable";

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_IVAR),

- ID2SYM(node->nd_vid), needstr);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_GVAR),

- ID2SYM(node->nd_entry->id), needstr);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_CVAR),

- ID2SYM(node->nd_vid), needstr);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_CONST),

- ID2SYM(node->nd_vid), needstr);

- if (!lfinish[1]) {

- lfinish[1] = NEW_LABEL(nd_line(node));

- defined_expr(iseq, ret, node->nd_head, lfinish, Qfalse);

- ADD_INSNL(ret, nd_line(node), branchunless, lfinish[1]);

- if (rb_is_const_id(node->nd_mid)) {

- COMPILE(ret, "defined/colon2#nd_head", node->nd_head);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_CONST),

- ID2SYM(node->nd_mid), needstr);

- COMPILE(ret, "defined/colon2#nd_head", node->nd_head);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_METHOD),

- ID2SYM(node->nd_mid), needstr);

- ADD_INSN1(ret, nd_line(node), putobject, rb_cObject);

- ADD_INSN3(ret, nd_line(node), defined,

- INT2FIX(DEFINED_CONST), ID2SYM(node->nd_mid), needstr);

- /* method dispatch */

- case NODE_ATTRASGN:{

- case NODE_ATTRASGN:

- if (node->nd_recv == (NODE *)1) break;

- if (!lfinish[1]) {

- lfinish[1] = NEW_LABEL(nd_line(node));

- if (node->nd_args) {

- defined_expr(iseq, ret, node->nd_args, lfinish, Qfalse);

- ADD_INSNL(ret, nd_line(node), branchunless, lfinish[1]);

- LABEL *lstart = NEW_LABEL(nd_line(node));

- LABEL *lend = NEW_LABEL(nd_line(node));

- VALUE rescue = NEW_CHILD_ISEQVAL(NEW_NIL(),

- rb_str_concat(rb_str_new2

- ("defined guard in "),

- ISEQ_TYPE_DEFINED_GUARD, 0);

- defined_expr(iseq, ret, node->nd_recv, lfinish, Qfalse);

- ADD_INSNL(ret, nd_line(node), branchunless, lfinish[1]);

- ADD_LABEL(ret, lstart);

- COMPILE(ret, "defined/recv", node->nd_recv);

- ADD_LABEL(ret, lend);

- ADD_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_METHOD),

- ID2SYM(node->nd_mid), needstr);

- ADD_INSN(ret, nd_line(node), putself);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_FUNC),

- ID2SYM(node->nd_mid), needstr);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_YIELD), 0,

- case NODE_BACK_REF:

- case NODE_NTH_REF:

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_REF),

- INT2FIX((node->nd_nth << 1) | (type == NODE_BACK_REF)),

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN3(ret, nd_line(node), defined, INT2FIX(DEFINED_ZSUPER), 0,

- case NODE_OP_ASGN1:

- case NODE_OP_ASGN2:

- case NODE_OP_ASGN_OR:

- case NODE_OP_ASGN_AND:

- case NODE_DASGN_CURR:

- estr = "assignment";

- if (needstr != Qfalse) {

- VALUE str = rb_str_new2(estr);

- ADD_INSN1(ret, nd_line(node), putstring, str);

- iseq_add_mark_object_compile_time(iseq, str);

- ADD_INSN1(ret, nd_line(node), putobject, Qtrue);

-#define BUFSIZE 0x100

-make_name_for_block(rb_iseq_t *iseq)

- rb_iseq_t *ip = iseq;

- if (iseq->parent_iseq != 0) {

- while (ip->local_iseq != ip) {

- if (ip->type == ISEQ_TYPE_BLOCK) {

- ip = ip->parent_iseq;

- return rb_sprintf("block in %s", RSTRING_PTR(ip->name));

- return rb_sprintf("block (%d levels) in %s", level, RSTRING_PTR(ip->name));

-push_ensure_entry(rb_iseq_t *iseq,

- struct iseq_compile_data_ensure_node_stack *enl,

- struct ensure_range *er, NODE *node)

- enl->ensure_node = node;

- enl->prev = iseq->compile_data->ensure_node_stack; /* prev */

- iseq->compile_data->ensure_node_stack = enl;

-add_ensure_range(rb_iseq_t *iseq, struct ensure_range *erange,

- LABEL *lstart, LABEL *lend)

- struct ensure_range *ne =

- compile_data_alloc(iseq, sizeof(struct ensure_range));

- while (erange->next != 0) {

- erange = erange->next;

- ne->end = erange->end;

- erange->end = lstart;

- erange->next = ne;

-add_ensure_iseq(LINK_ANCHOR *ret, rb_iseq_t *iseq, int is_return)

- struct iseq_compile_data_ensure_node_stack *enlp =

- iseq->compile_data->ensure_node_stack;

- struct iseq_compile_data_ensure_node_stack *prev_enlp = enlp;

- DECL_ANCHOR(ensure);

- INIT_ANCHOR(ensure);

- if (enlp->erange != 0) {

- DECL_ANCHOR(ensure_part);

- LABEL *lstart = NEW_LABEL(0);

- LABEL *lend = NEW_LABEL(0);

- INIT_ANCHOR(ensure_part);

- add_ensure_range(iseq, enlp->erange, lstart, lend);

- iseq->compile_data->ensure_node_stack = enlp->prev;

- ADD_LABEL(ensure_part, lstart);

- COMPILE_POPED(ensure_part, "ensure part", enlp->ensure_node);

- ADD_LABEL(ensure_part, lend);

- ADD_SEQ(ensure, ensure_part);

- enlp = enlp->prev;

- iseq->compile_data->ensure_node_stack = prev_enlp;

- ADD_SEQ(ret, ensure);

-setup_args(rb_iseq_t *iseq, LINK_ANCHOR *args, NODE *argn, unsigned long *flag)

- VALUE argc = INT2FIX(0);

- DECL_ANCHOR(arg_block);

- DECL_ANCHOR(args_splat);

- INIT_ANCHOR(arg_block);

- INIT_ANCHOR(args_splat);

- if (argn && nd_type(argn) == NODE_BLOCK_PASS) {

- COMPILE(arg_block, "block", argn->nd_body);

- *flag |= VM_CALL_ARGS_BLOCKARG_BIT;

- argn = argn->nd_head;

- switch (nd_type(argn)) {

- case NODE_SPLAT: {

- COMPILE(args, "args (splat)", argn->nd_head);

- argc = INT2FIX(1);

- *flag |= VM_CALL_ARGS_SPLAT_BIT;

- case NODE_ARGSCAT:

- case NODE_ARGSPUSH: {

- int next_is_array = (nd_type(argn->nd_head) == NODE_ARRAY);

- COMPILE(tmp, "args (cat: splat)", argn->nd_body);

- if (next_is_array && nsplat == 0) {

- if (nd_type(argn) == NODE_ARGSCAT) {

- ADD_INSN1(tmp, nd_line(argn), splatarray, Qfalse);

- ADD_INSN1(tmp, nd_line(argn), newarray, INT2FIX(1));

- INSERT_LIST(args_splat, tmp);

- *flag |= VM_CALL_ARGS_SPLAT_BIT;

- if (next_is_array) {

- argc = INT2FIX(compile_array(iseq, args, argn->nd_head, Qfalse) + 1);

- POP_ELEMENT(args);

- argn = argn->nd_head;

- case NODE_ARRAY: {

- argc = INT2FIX(compile_array(iseq, args, argn, Qfalse));

- POP_ELEMENT(args);

- rb_bug("setup_arg: unknown node: %s\n", ruby_node_name(nd_type(argn)));

- for (i=1; i<nsplat; i++) {

- ADD_INSN(args_splat, nd_line(args), concatarray);

- if (!LIST_SIZE_ZERO(args_splat)) {

- ADD_SEQ(args, args_splat);

- if (*flag & VM_CALL_ARGS_BLOCKARG_BIT) {

- ADD_SEQ(args, arg_block);

- self: InstructionSequence

- node: Ruby compiled node

- poped: This node will be poped

-iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)

- enum node_type type;

- debugs("node: NODE_NIL(implicit)\n");

- ADD_INSN(ret, iseq->compile_data->last_line, putnil);

- return COMPILE_OK;

- iseq->compile_data->last_line = (int)nd_line(node);

- debug_node_start(node);

- type = nd_type(node);

- if (node->flags & NODE_FL_NEWLINE) {

- ADD_TRACE(ret, nd_line(node), RUBY_EVENT_LINE);

- while (node && nd_type(node) == NODE_BLOCK) {

- COMPILE_(ret, "BLOCK body", node->nd_head,

- (node->nd_next == 0 && poped == 0) ? 0 : 1);

- node = node->nd_next;

- COMPILE_(ret, "BLOCK next", node->nd_next, poped);

- DECL_ANCHOR(cond_seq);

- DECL_ANCHOR(then_seq);

- DECL_ANCHOR(else_seq);

- LABEL *then_label, *else_label, *end_label;

- INIT_ANCHOR(cond_seq);

- INIT_ANCHOR(then_seq);

- INIT_ANCHOR(else_seq);

- then_label = NEW_LABEL(nd_line(node));

- else_label = NEW_LABEL(nd_line(node));

- end_label = NEW_LABEL(nd_line(node));

- compile_branch_condition(iseq, cond_seq, node->nd_cond,

- then_label, else_label);

- COMPILE_(then_seq, "then", node->nd_body, poped);

- COMPILE_(else_seq, "else", node->nd_else, poped);

- ADD_SEQ(ret, cond_seq);

- ADD_LABEL(ret, then_label);

- ADD_SEQ(ret, then_seq);

- ADD_INSNL(ret, nd_line(node), jump, end_label);

- ADD_LABEL(ret, else_label);

- ADD_SEQ(ret, else_seq);

- ADD_LABEL(ret, end_label);

- NODE *tempnode = node;

- LABEL *endlabel, *elselabel;

- DECL_ANCHOR(head);

- DECL_ANCHOR(body_seq);

- DECL_ANCHOR(cond_seq);

- VALUE special_literals = rb_ary_tmp_new(1);

- INIT_ANCHOR(head);

- INIT_ANCHOR(body_seq);

- INIT_ANCHOR(cond_seq);

- if (node->nd_head == 0) {

- COMPILE_(ret, "when", node->nd_body, poped);

- COMPILE(head, "case base", node->nd_head);

- node = node->nd_body;

- type = nd_type(node);

- if (type != NODE_WHEN) {

- COMPILE_ERROR((ERROR_ARGS "NODE_CASE: unexpected node. must be NODE_WHEN, but %s", ruby_node_name(type)));

- endlabel = NEW_LABEL(nd_line(node));

- elselabel = NEW_LABEL(nd_line(node));

- ADD_SEQ(ret, head); /* case VAL */

- while (type == NODE_WHEN) {

- l1 = NEW_LABEL(nd_line(node));

- ADD_LABEL(body_seq, l1);

- ADD_INSN(body_seq, nd_line(node), pop);

- COMPILE_(body_seq, "when body", node->nd_body, poped);

- ADD_INSNL(body_seq, nd_line(node), jump, endlabel);

- vals = node->nd_head;

- switch (nd_type(vals)) {

- special_literals = when_vals(iseq, cond_seq, vals, l1, special_literals);

- case NODE_ARGSCAT:

- case NODE_ARGSPUSH:

- special_literals = 0;

- COMPILE(cond_seq, "when/cond splat", vals);

- ADD_INSN1(cond_seq, nd_line(vals), checkincludearray, Qtrue);

- ADD_INSNL(cond_seq, nd_line(vals), branchif, l1);

- rb_bug("NODE_CASE: unknown node (%s)",

- ruby_node_name(nd_type(vals)));

- rb_bug("NODE_CASE: must be NODE_ARRAY, but 0");

- node = node->nd_next;

- type = nd_type(node);

- ADD_LABEL(cond_seq, elselabel);

- ADD_INSN(cond_seq, nd_line(node), pop);

- COMPILE_(cond_seq, "else", node, poped);

- ADD_INSNL(cond_seq, nd_line(node), jump, endlabel);

- debugs("== else (implicit)\n");

- ADD_LABEL(cond_seq, elselabel);

- ADD_INSN(cond_seq, nd_line(tempnode), pop);

- ADD_INSN(cond_seq, nd_line(tempnode), putnil);

- ADD_INSNL(cond_seq, nd_line(tempnode), jump, endlabel);

- if (special_literals) {

- ADD_INSN(ret, nd_line(tempnode), dup);

- ADD_INSN2(ret, nd_line(tempnode), opt_case_dispatch,

- special_literals, elselabel);

- iseq_add_mark_object_compile_time(iseq, special_literals);

- ADD_SEQ(ret, cond_seq);

- ADD_SEQ(ret, body_seq);

- ADD_LABEL(ret, endlabel);

- NODE *orig_node = node;

- DECL_ANCHOR(body_seq);

- INIT_ANCHOR(body_seq);

- endlabel = NEW_LABEL(nd_line(node));

- while (node && nd_type(node) == NODE_WHEN) {

- LABEL *l1 = NEW_LABEL(nd_line(node));

- ADD_LABEL(body_seq, l1);

- COMPILE_(body_seq, "when", node->nd_body, poped);

- ADD_INSNL(body_seq, nd_line(node), jump, endlabel);

- vals = node->nd_head;

- rb_bug("NODE_WHEN: must be NODE_ARRAY, but 0");

- switch (nd_type(vals)) {

- val = vals->nd_head;

- COMPILE(ret, "when2", val);

- ADD_INSNL(ret, nd_line(val), branchif, l1);

- vals = vals->nd_next;

- case NODE_ARGSCAT:

- case NODE_ARGSPUSH:

- ADD_INSN(ret, nd_line(vals), putnil);

- COMPILE(ret, "when2/cond splat", vals);

- ADD_INSN1(ret, nd_line(vals), checkincludearray, Qfalse);

- ADD_INSN(ret, nd_line(vals), pop);

- ADD_INSNL(ret, nd_line(vals), branchif, l1);

- rb_bug("NODE_WHEN: unknown node (%s)",

- ruby_node_name(nd_type(vals)));

- node = node->nd_next;

- COMPILE_(ret, "else", node, poped);

- ADD_INSNL(ret, nd_line(orig_node), jump, endlabel);

- ADD_SEQ(ret, body_seq);

- ADD_LABEL(ret, endlabel);

- LABEL *prev_start_label = iseq->compile_data->start_label;

- LABEL *prev_end_label = iseq->compile_data->end_label;

- LABEL *prev_redo_label = iseq->compile_data->redo_label;

- int prev_loopval_popped = iseq->compile_data->loopval_popped;

- struct iseq_compile_data_ensure_node_stack enl;

- LABEL *next_label = iseq->compile_data->start_label = NEW_LABEL(nd_line(node)); /* next */

- LABEL *redo_label = iseq->compile_data->redo_label = NEW_LABEL(nd_line(node)); /* redo */

- LABEL *break_label = iseq->compile_data->end_label = NEW_LABEL(nd_line(node)); /* break */

- LABEL *end_label = NEW_LABEL(nd_line(node));

- LABEL *next_catch_label = NEW_LABEL(nd_line(node));

- LABEL *tmp_label = NULL;

- iseq->compile_data->loopval_popped = 0;

- push_ensure_entry(iseq, &enl, 0, 0);

- if (type == NODE_OPT_N || node->nd_state == 1) {

- ADD_INSNL(ret, nd_line(node), jump, next_label);

- tmp_label = NEW_LABEL(nd_line(node));

- ADD_INSNL(ret, nd_line(node), jump, tmp_label);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_LABEL(ret, next_catch_label);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSNL(ret, nd_line(node), jump, next_label);

- if (tmp_label) ADD_LABEL(ret, tmp_label);

- ADD_LABEL(ret, redo_label);

- COMPILE_POPED(ret, "while body", node->nd_body);

- ADD_LABEL(ret, next_label); /* next */

- if (type == NODE_WHILE) {

- compile_branch_condition(iseq, ret, node->nd_cond,

- redo_label, end_label);

- else if (type == NODE_UNTIL) {

- compile_branch_condition(iseq, ret, node->nd_cond,

- end_label, redo_label);

- ADD_CALL_RECEIVER(ret, nd_line(node));

- ADD_CALL(ret, nd_line(node), ID2SYM(idGets), INT2FIX(0));

- ADD_INSNL(ret, nd_line(node), branchif, redo_label);

- ADD_LABEL(ret, end_label);

- if (node->nd_state == Qundef) {

- /* ADD_INSN(ret, nd_line(node), putundef); */

- rb_bug("unsupported: putundef");

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_LABEL(ret, break_label); /* break */

- ADD_INSN(ret, nd_line(node), pop);

- ADD_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label,

- ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, 0,

- next_catch_label);

- ADD_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, 0,

- iseq->compile_data->redo_label);

- iseq->compile_data->start_label = prev_start_label;

- iseq->compile_data->end_label = prev_end_label;

- iseq->compile_data->redo_label = prev_redo_label;

- iseq->compile_data->loopval_popped = prev_loopval_popped;

- iseq->compile_data->ensure_node_stack = iseq->compile_data->ensure_node_stack->prev;

- VALUE prevblock = iseq->compile_data->current_block;

- LABEL *retry_label = NEW_LABEL(nd_line(node));

- LABEL *retry_end_l = NEW_LABEL(nd_line(node));

- ADD_LABEL(ret, retry_label);

- if (nd_type(node) == NODE_FOR) {

- COMPILE(ret, "iter caller (for)", node->nd_iter);

- iseq->compile_data->current_block =

- NEW_CHILD_ISEQVAL(node->nd_body, make_name_for_block(iseq),

- ISEQ_TYPE_BLOCK, nd_line(node));

- ADD_SEND_R(ret, nd_line(node), ID2SYM(idEach), INT2FIX(0),

- iseq->compile_data->current_block, INT2FIX(0));

- iseq->compile_data->current_block =

- NEW_CHILD_ISEQVAL(node->nd_body, make_name_for_block(iseq),

- ISEQ_TYPE_BLOCK, nd_line(node));

- COMPILE(ret, "iter caller", node->nd_iter);

- ADD_LABEL(ret, retry_end_l);

- ADD_INSN(ret, nd_line(node), pop);

- iseq->compile_data->current_block = prevblock;

- ADD_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, 0, retry_end_l);

- unsigned long level = 0;

- if (iseq->compile_data->redo_label != 0) {

- LABEL *splabel = NEW_LABEL(0);

- ADD_LABEL(ret, splabel);

- ADD_ADJUST(ret, nd_line(node), iseq->compile_data->redo_label);

- COMPILE_(ret, "break val (while/until)", node->nd_stts, iseq->compile_data->loopval_popped);

- add_ensure_iseq(ret, iseq, 0);

- ADD_INSNL(ret, nd_line(node), jump, iseq->compile_data->end_label);

- ADD_ADJUST_RESTORE(ret, splabel);

- ADD_INSN(ret, nd_line(node), putnil);

- else if (iseq->type == ISEQ_TYPE_BLOCK) {

- /* escape from block */

- COMPILE(ret, "break val (block)", node->nd_stts);

- ADD_INSN1(ret, nd_line(node), throw, INT2FIX(level | 0x02) /* TAG_BREAK */ );

- ADD_INSN(ret, nd_line(node), pop);

- else if (iseq->type == ISEQ_TYPE_EVAL) {

- COMPILE_ERROR((ERROR_ARGS "Can't escape from eval with break"));

- rb_iseq_t *ip = iseq->parent_iseq;

- if (!ip->compile_data) {

- if (ip->compile_data->redo_label != 0) {

- if (ip->compile_data->loopval_popped == 0) {

- goto break_by_insn;

- else if (ip->type == ISEQ_TYPE_BLOCK) {

- goto break_by_insn;

- else if (ip->type == ISEQ_TYPE_EVAL) {

- goto break_in_eval;

- ip = ip->parent_iseq;

- COMPILE_ERROR((ERROR_ARGS "Invalid break"));

- unsigned long level = 0;

- if (iseq->compile_data->redo_label != 0) {

- LABEL *splabel = NEW_LABEL(0);

- debugs("next in while loop\n");

- ADD_LABEL(ret, splabel);

- COMPILE(ret, "next val/valid syntax?", node->nd_stts);

- add_ensure_iseq(ret, iseq, 0);

- ADD_ADJUST(ret, nd_line(node), iseq->compile_data->redo_label);

- ADD_INSNL(ret, nd_line(node), jump, iseq->compile_data->start_label);

- ADD_ADJUST_RESTORE(ret, splabel);

- ADD_INSN(ret, nd_line(node), putnil);

- else if (iseq->compile_data->end_label) {

- LABEL *splabel = NEW_LABEL(0);

- debugs("next in block\n");

- ADD_LABEL(ret, splabel);

- ADD_ADJUST(ret, nd_line(node), iseq->compile_data->start_label);

- COMPILE(ret, "next val", node->nd_stts);

- add_ensure_iseq(ret, iseq, 0);

- ADD_INSNL(ret, nd_line(node), jump, iseq->compile_data->end_label);

- ADD_ADJUST_RESTORE(ret, splabel);

- ADD_INSN(ret, nd_line(node), putnil);

- else if (iseq->type == ISEQ_TYPE_EVAL) {

- COMPILE_ERROR((ERROR_ARGS "Can't escape from eval with next"));

- if (!ip->compile_data) {

- level = 0x8000 | 0x4000;

- if (ip->compile_data->redo_label != 0) {

- else if (ip->type == ISEQ_TYPE_BLOCK) {

- else if (ip->type == ISEQ_TYPE_EVAL) {

- goto next_in_eval;

- ip = ip->parent_iseq;

- COMPILE(ret, "next val", node->nd_stts);

- ADD_INSN1(ret, nd_line(node), throw, INT2FIX(level | 0x03) /* TAG_NEXT */ );

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE_ERROR((ERROR_ARGS "Invalid next"));

- if (iseq->compile_data->redo_label) {

- LABEL *splabel = NEW_LABEL(0);

- debugs("redo in while");

- ADD_LABEL(ret, splabel);

- ADD_ADJUST(ret, nd_line(node), iseq->compile_data->redo_label);

- add_ensure_iseq(ret, iseq, 0);

- ADD_INSNL(ret, nd_line(node), jump, iseq->compile_data->redo_label);

- ADD_ADJUST_RESTORE(ret, splabel);

- ADD_INSN(ret, nd_line(node), putnil);

- else if (iseq->type == ISEQ_TYPE_EVAL) {

- COMPILE_ERROR((ERROR_ARGS "Can't escape from eval with redo"));

- else if (iseq->compile_data->start_label) {

- LABEL *splabel = NEW_LABEL(0);

- debugs("redo in block");

- ADD_LABEL(ret, splabel);

- add_ensure_iseq(ret, iseq, 0);

- ADD_ADJUST(ret, nd_line(node), iseq->compile_data->start_label);

- ADD_INSNL(ret, nd_line(node), jump, iseq->compile_data->start_label);

- ADD_ADJUST_RESTORE(ret, splabel);

- ADD_INSN(ret, nd_line(node), putnil);

- unsigned long level;

- level = 0x8000 | 0x4000;

- if (!ip->compile_data) {

- if (ip->compile_data->redo_label != 0) {

- else if (ip->type == ISEQ_TYPE_BLOCK) {

- else if (ip->type == ISEQ_TYPE_EVAL) {

- goto redo_in_eval;

- ip = ip->parent_iseq;

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN1(ret, nd_line(node), throw, INT2FIX(level | 0x05) /* TAG_REDO */ );

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE_ERROR((ERROR_ARGS "Invalid redo"));

- if (iseq->type == ISEQ_TYPE_RESCUE) {

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN1(ret, nd_line(node), throw, INT2FIX(0x04) /* TAG_RETRY */ );

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE_ERROR((ERROR_ARGS "Invalid retry"));

- COMPILE_(ret, "NODE_BEGIN", node->nd_body, poped);

- case NODE_RESCUE:{

- LABEL *lstart = NEW_LABEL(nd_line(node));

- LABEL *lend = NEW_LABEL(nd_line(node));

- LABEL *lcont = NEW_LABEL(nd_line(node));

- VALUE rescue = NEW_CHILD_ISEQVAL(

- rb_str_concat(rb_str_new2("rescue in "), iseq->name),

- ISEQ_TYPE_RESCUE, nd_line(node));

- ADD_LABEL(ret, lstart);

- COMPILE(ret, "rescue head", node->nd_head);

- ADD_LABEL(ret, lend);

- if (node->nd_else) {

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "rescue else", node->nd_else);

- ADD_INSN(ret, nd_line(node), nop);

- ADD_LABEL(ret, lcont);

- ADD_INSN(ret, nd_line(node), pop);

- /* register catch entry */

- ADD_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lcont);

- ADD_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, 0, lstart);

- case NODE_RESBODY:{

- NODE *resq = node;

- LABEL *label_miss, *label_hit;

- label_miss = NEW_LABEL(nd_line(node));

- label_hit = NEW_LABEL(nd_line(node));

- narg = resq->nd_args;

- switch (nd_type(narg)) {

- COMPILE(ret, "rescue arg", narg->nd_head);

- ADD_INSN2(ret, nd_line(node), getdynamic, INT2FIX(2), INT2FIX(0));

- ADD_SEND(ret, nd_line(node), ID2SYM(idEqq), INT2FIX(1));

- ADD_INSNL(ret, nd_line(node), branchif, label_hit);

- narg = narg->nd_next;

- case NODE_ARGSCAT:

- case NODE_ARGSPUSH:

- ADD_INSN2(ret, nd_line(node), getdynamic, INT2FIX(2), INT2FIX(0));

- COMPILE(ret, "rescue/cond splat", narg);

- ADD_INSN1(ret, nd_line(node), checkincludearray, Qtrue);

- ADD_INSN(ret, nd_line(node), swap);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSNL(ret, nd_line(node), branchif, label_hit);

- rb_bug("NODE_RESBODY: unknown node (%s)",

- ruby_node_name(nd_type(narg)));

- ADD_INSN1(ret, nd_line(node), putobject,

- rb_eStandardError);

- ADD_INSN2(ret, nd_line(node), getdynamic, INT2FIX(2), INT2FIX(0));

- ADD_SEND(ret, nd_line(node), ID2SYM(idEqq), INT2FIX(1));

- ADD_INSNL(ret, nd_line(node), branchif, label_hit);

- ADD_INSNL(ret, nd_line(node), jump, label_miss);

- ADD_LABEL(ret, label_hit);

- COMPILE(ret, "resbody body", resq->nd_body);

- if (iseq->compile_data->option->tailcall_optimization) {

- ADD_INSN(ret, nd_line(node), nop);

- ADD_INSN(ret, nd_line(node), leave);

- ADD_LABEL(ret, label_miss);

- resq = resq->nd_head;

- case NODE_ENSURE:{

- DECL_ANCHOR(ensr);

- VALUE ensure = NEW_CHILD_ISEQVAL(node->nd_ensr,

- rb_str_concat(rb_str_new2

- ISEQ_TYPE_ENSURE, nd_line(node));

- LABEL *lstart = NEW_LABEL(nd_line(node));

- LABEL *lend = NEW_LABEL(nd_line(node));

- LABEL *lcont = NEW_LABEL(nd_line(node));

- struct ensure_range er;

- struct iseq_compile_data_ensure_node_stack enl;

- struct ensure_range *erange;

- INIT_ANCHOR(ensr);

- COMPILE_POPED(ensr, "ensure ensr", node->nd_ensr);

- er.begin = lstart;

- push_ensure_entry(iseq, &enl, &er, node->nd_ensr);

- ADD_LABEL(ret, lstart);

- COMPILE_(ret, "ensure head", node->nd_head, poped);

- ADD_LABEL(ret, lend);

- if (ensr->anchor.next == 0) {

- ADD_INSN(ret, nd_line(node), nop);

- ADD_SEQ(ret, ensr);

- ADD_LABEL(ret, lcont);

- erange = iseq->compile_data->ensure_node_stack->erange;

- ADD_CATCH_ENTRY(CATCH_TYPE_ENSURE, erange->begin, erange->end,

- erange = erange->next;

- iseq->compile_data->ensure_node_stack = enl.prev;

- LABEL *end_label = NEW_LABEL(nd_line(node));

- COMPILE(ret, "nd_1st", node->nd_1st);

- ADD_INSN(ret, nd_line(node), dup);

- if (type == NODE_AND) {

- ADD_INSNL(ret, nd_line(node), branchunless, end_label);

- ADD_INSNL(ret, nd_line(node), branchif, end_label);

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE_(ret, "nd_2nd", node->nd_2nd, poped);

- ADD_LABEL(ret, end_label);

- compile_massign(iseq, ret, node, poped);

- ID id = node->nd_vid;

- int idx = iseq->local_iseq->local_size - get_local_var_idx(iseq, id);

- debugs("lvar: %s idx: %d\n", rb_id2name(id), idx);

- COMPILE(ret, "rvalue", node->nd_value);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSN1(ret, nd_line(node), setlocal, INT2FIX(idx));

- case NODE_DASGN_CURR:{

- COMPILE(ret, "dvalue", node->nd_value);

- debugp_param("dassn id", rb_str_new2(rb_id2name(node->nd_vid) ? rb_id2name(node->nd_vid) : "*"));

- ADD_INSN(ret, nd_line(node), dup);

- idx = get_dyna_var_idx(iseq, node->nd_vid, &lv, &ls);

- rb_bug("NODE_DASGN(_CURR): unknown id (%s)", rb_id2name(node->nd_vid));

- ADD_INSN2(ret, nd_line(node), setdynamic,

- INT2FIX(ls - idx), INT2FIX(lv));

- COMPILE(ret, "lvalue", node->nd_value);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSN1(ret, nd_line(node), setglobal,

- (((long)node->nd_entry) | 1));

- case NODE_IASGN2:{

- COMPILE(ret, "lvalue", node->nd_value);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSN2(ret, nd_line(node), setinstancevariable,

- ID2SYM(node->nd_vid), INT2FIX(iseq->ic_size++));

- COMPILE(ret, "lvalue", node->nd_value);

- ADD_INSN(ret, nd_line(node), dup);

- if (node->nd_vid) {

- ADD_INSN1(ret, nd_line(node), putspecialobject,

- INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));

- ADD_INSN1(ret, nd_line(node), setconstant, ID2SYM(node->nd_vid));

- compile_cpath(ret, iseq, node->nd_else);

- ADD_INSN1(ret, nd_line(node), setconstant, ID2SYM(node->nd_else->nd_mid));

- case NODE_CVASGN:{

- COMPILE(ret, "cvasgn val", node->nd_value);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSN1(ret, nd_line(node), setclassvariable,

- ID2SYM(node->nd_vid));

- case NODE_OP_ASGN1: {

- DECL_ANCHOR(args);

- unsigned long flag = 0;

- ID id = node->nd_mid;

- * eval x # nil a x

- * dupn 2 # nil a x a x

- * send :[] # nil a x a[x]

- * eval y # nil a x a[x] y

- * send op # nil a x ret

- * setn 3 # ret a x ret

- * send []= # ret ?

- * nd_recv[nd_args->nd_body] (nd_mid)= nd_args->nd_head;

- * NODE_OP_ASGN nd_recv

- * nd_args->nd_head

- * nd_args->nd_body

- ADD_INSN(ret, nd_line(node), putnil);

- COMPILE(ret, "NODE_OP_ASGN1 recv", node->nd_recv);

- switch (nd_type(node->nd_args->nd_head)) {

- argc = INT2FIX(0);

- case NODE_BLOCK_PASS:

- INIT_ANCHOR(args);

- argc = setup_args(iseq, args, node->nd_args->nd_head, &flag);

- ADD_SEQ(ret, args);

- ADD_INSN1(ret, nd_line(node), dupn, FIXNUM_INC(argc, 1 + boff));

- ADD_SEND_R(ret, nd_line(node), ID2SYM(idAREF), argc, Qfalse, LONG2FIX(flag));

- if (id == 0 || id == 1) {

- LABEL *label = NEW_LABEL(nd_line(node));

- LABEL *lfin = NEW_LABEL(nd_line(node));

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSNL(ret, nd_line(node), branchif, label);

- ADD_INSNL(ret, nd_line(node), branchunless, label);

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "NODE_OP_ASGN1 args->body: ", node->nd_args->nd_body);

- ADD_INSN1(ret, nd_line(node), setn, FIXNUM_INC(argc, 2+boff));

- if (flag & VM_CALL_ARGS_SPLAT_BIT) {

- ADD_INSN1(ret, nd_line(node), newarray, INT2FIX(1));

- ADD_INSN1(ret, nd_line(node), dupn, INT2FIX(3));

- ADD_INSN(ret, nd_line(node), swap);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN(ret, nd_line(node), concatarray);

- ADD_INSN1(ret, nd_line(node), setn, INT2FIX(3));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_SEND_R(ret, nd_line(node), ID2SYM(idASET),

- argc, Qfalse, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), swap);

- ADD_SEND_R(ret, nd_line(node), ID2SYM(idASET),

- FIXNUM_INC(argc, 1), Qfalse, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSNL(ret, nd_line(node), jump, lfin);

- ADD_LABEL(ret, label);

- ADD_INSN1(ret, nd_line(node), setn, FIXNUM_INC(argc, 2+boff));

- ADD_INSN1(ret, nd_line(node), adjuststack, FIXNUM_INC(argc, 2+boff));

- ADD_LABEL(ret, lfin);

- COMPILE(ret, "NODE_OP_ASGN1 args->body: ", node->nd_args->nd_body);

- ADD_SEND(ret, nd_line(node), ID2SYM(id), INT2FIX(1));

- ADD_INSN1(ret, nd_line(node), setn, FIXNUM_INC(argc, 2+boff));

- if (flag & VM_CALL_ARGS_SPLAT_BIT) {

- ADD_INSN1(ret, nd_line(node), newarray, INT2FIX(1));

- ADD_INSN1(ret, nd_line(node), dupn, INT2FIX(3));

- ADD_INSN(ret, nd_line(node), swap);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN(ret, nd_line(node), concatarray);

- ADD_INSN1(ret, nd_line(node), setn, INT2FIX(3));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_SEND_R(ret, nd_line(node), ID2SYM(idASET),

- argc, Qfalse, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), swap);

- ADD_SEND_R(ret, nd_line(node), ID2SYM(idASET),

- FIXNUM_INC(argc, 1), Qfalse, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_OP_ASGN2:{

- ID atype = node->nd_next->nd_mid;

- LABEL *lfin = NEW_LABEL(nd_line(node));

- LABEL *lcfin = NEW_LABEL(nd_line(node));

- class C; attr_accessor :c; end

- COMPILE(ret, "NODE_OP_ASGN2#recv", node->nd_recv);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_SEND(ret, nd_line(node), ID2SYM(node->nd_next->nd_vid),

- if (atype == 0 || atype == 1) { /* 0: OR or 1: AND */

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSNL(ret, nd_line(node), branchif, lcfin);

- ADD_INSNL(ret, nd_line(node), branchunless, lcfin);

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "NODE_OP_ASGN2 val", node->nd_value);

- ADD_INSN(ret, nd_line(node), swap);

- ADD_INSN1(ret, nd_line(node), topn, INT2FIX(1));

- ADD_SEND(ret, nd_line(node), ID2SYM(node->nd_next->nd_aid),

- ADD_INSNL(ret, nd_line(node), jump, lfin);

- ADD_LABEL(ret, lcfin);

- ADD_INSN(ret, nd_line(node), swap);

- ADD_LABEL(ret, lfin);

- ADD_INSN(ret, nd_line(node), pop);

- /* we can apply more optimize */

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "NODE_OP_ASGN2 val", node->nd_value);

- ADD_SEND(ret, nd_line(node), ID2SYM(node->nd_next->nd_mid),

- ADD_INSN(ret, nd_line(node), swap);

- ADD_INSN1(ret, nd_line(node), topn, INT2FIX(1));

- ADD_SEND(ret, nd_line(node), ID2SYM(node->nd_next->nd_aid),

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_OP_ASGN_AND:

- case NODE_OP_ASGN_OR:{

- LABEL *lfin = NEW_LABEL(nd_line(node));

- if (nd_type(node) == NODE_OP_ASGN_OR) {

- LABEL *lfinish[2];

- lfinish[0] = lfin;

- defined_expr(iseq, ret, node->nd_head, lfinish, Qfalse);

- lassign = lfinish[1];

- lassign = NEW_LABEL(nd_line(node));

- ADD_INSNL(ret, nd_line(node), branchunless, lassign);

- lassign = NEW_LABEL(nd_line(node));

- COMPILE(ret, "NODE_OP_ASGN_AND/OR#nd_head", node->nd_head);

- ADD_INSN(ret, nd_line(node), dup);

- if (nd_type(node) == NODE_OP_ASGN_AND) {

- ADD_INSNL(ret, nd_line(node), branchunless, lfin);

- ADD_INSNL(ret, nd_line(node), branchif, lfin);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_LABEL(ret, lassign);

- COMPILE(ret, "NODE_OP_ASGN_AND/OR#nd_value", node->nd_value);

- ADD_LABEL(ret, lfin);

- /* we can apply more optimize */

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_VCALL:{ /* VCALL: variable or call */

- call: obj.method(...)

- DECL_ANCHOR(recv);

- DECL_ANCHOR(args);

- ID mid = node->nd_mid;

- unsigned long flag = 0;

- VALUE parent_block = iseq->compile_data->current_block;

- iseq->compile_data->current_block = Qfalse;

- INIT_ANCHOR(recv);

- INIT_ANCHOR(args);

- if (nd_type(node) == NODE_VCALL) {

- if (mid == idBitblt) {

- ADD_INSN(ret, nd_line(node), bitblt);

- else if (mid == idAnswer) {

- ADD_INSN(ret, nd_line(node), answer);

- CONST_ID(goto_id, "__goto__");

- CONST_ID(label_id, "__label__");

- if (nd_type(node) == NODE_FCALL &&

- (mid == goto_id || mid == label_id)) {

- if (nd_type(node->nd_args->nd_head) == NODE_LIT &&

- SYMBOL_P(node->nd_args->nd_head->nd_lit)) {

- label_sym = label = node->nd_args->nd_head->nd_lit;

- rb_hash_aref(iseq->compile_data,

- label_sym)) == Qnil) {

- rb_hash_aset(iseq->compile_data, label_sym,

- label = NEW_LABEL(nd_line(node)));

- rb_bug("invalid goto/label format");

- if (mid == goto_id) {

- ADD_INSNL(ret, nd_line(node), jump, label);

- ADD_LABEL(ret, label);

- if (type == NODE_CALL) {

- COMPILE(recv, "recv", node->nd_recv);

- else if (type == NODE_FCALL || type == NODE_VCALL) {

- ADD_CALL_RECEIVER(recv, nd_line(node));

- if (nd_type(node) != NODE_VCALL) {

- argc = setup_args(iseq, args, node->nd_args, &flag);

- argc = INT2FIX(0);

- ADD_SEQ(ret, recv);

- ADD_SEQ(ret, args);

- debugp_param("call args argc", argc);

- debugp_param("call method", ID2SYM(mid));

- switch (nd_type(node)) {

- flag |= VM_CALL_VCALL_BIT;

- /* VCALL is funcall, so fall through */

- flag |= VM_CALL_FCALL_BIT;

- ADD_SEND_R(ret, nd_line(node), ID2SYM(mid),

- argc, parent_block, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_ZSUPER:{

- DECL_ANCHOR(args);

- unsigned long flag = 0;

- VALUE parent_block = iseq->compile_data->current_block;

- INIT_ANCHOR(args);

- iseq->compile_data->current_block = Qfalse;

- if (nd_type(node) == NODE_SUPER) {

- argc = setup_args(iseq, args, node->nd_args, &flag);

- rb_iseq_t *liseq = iseq->local_iseq;

- argc = INT2FIX(liseq->argc);

- /* normal arguments */

- for (i = 0; i < liseq->argc; i++) {

- int idx = liseq->local_size - i;

- ADD_INSN1(args, nd_line(node), getlocal, INT2FIX(idx));

- if (!liseq->arg_simple) {

- if (liseq->arg_opts) {

- /* optional arguments */

- for (j = 0; j < liseq->arg_opts - 1; j++) {

- int idx = liseq->local_size - (i + j);

- ADD_INSN1(args, nd_line(node), getlocal, INT2FIX(idx));

- argc = INT2FIX(i);

- if (liseq->arg_rest != -1) {

- /* rest argument */

- int idx = liseq->local_size - liseq->arg_rest;

- ADD_INSN1(args, nd_line(node), getlocal, INT2FIX(idx));

- argc = INT2FIX(liseq->arg_rest + 1);

- flag |= VM_CALL_ARGS_SPLAT_BIT;

- if (liseq->arg_post_len) {

- /* post arguments */

- int post_len = liseq->arg_post_len;

- int post_start = liseq->arg_post_start;

- if (liseq->arg_rest != -1) {

- for (j=0; j<post_len; j++) {

- int idx = liseq->local_size - (post_start + j);

- ADD_INSN1(args, nd_line(node), getlocal, INT2FIX(idx));

- ADD_INSN1(args, nd_line(node), newarray, INT2FIX(j));

- ADD_INSN (args, nd_line(node), concatarray);

- /* argc is setteled at above */

- for (j=0; j<post_len; j++) {

- int idx = liseq->local_size - (post_start + j);

- ADD_INSN1(args, nd_line(node), getlocal, INT2FIX(idx));

- argc = INT2FIX(post_len + post_start);

- /* dummy receiver */

- ADD_INSN1(ret, nd_line(node), putobject,

- nd_type(node) == NODE_ZSUPER ? Qfalse : Qtrue);

- ADD_SEQ(ret, args);

- ADD_INSN3(ret, nd_line(node), invokesuper,

- argc, parent_block, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), pop);

- compile_array_(iseq, ret, node, Qtrue, poped);

- case NODE_ZARRAY:{

- ADD_INSN1(ret, nd_line(node), newarray, INT2FIX(0));

- case NODE_VALUES:{

- COMPILE(ret, "values item", n->nd_head);

- ADD_INSN1(ret, nd_line(node), newarray, INT2FIX(node->nd_alen));

- ADD_INSN(ret, nd_line(node), pop);

- DECL_ANCHOR(list);

- int type = node->nd_head ? nd_type(node->nd_head) : NODE_ZARRAY;

- INIT_ANCHOR(list);

- compile_array(iseq, list, node->nd_head, Qfalse);

- size = OPERAND_AT(POP_ELEMENT(list), 0);

- ADD_SEQ(ret, list);

- size = INT2FIX(0);

- rb_bug("can't make hash with this node: %s", ruby_node_name(type));

- ADD_INSN1(ret, nd_line(node), newhash, size);

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_RETURN:{

- rb_iseq_t *is = iseq;

- if (is->type == ISEQ_TYPE_TOP) {

- COMPILE_ERROR((ERROR_ARGS "Invalid return"));

- LABEL *splabel = 0;

- if (is->type == ISEQ_TYPE_METHOD) {

- splabel = NEW_LABEL(0);

- ADD_LABEL(ret, splabel);

- ADD_ADJUST(ret, nd_line(node), 0);

- COMPILE(ret, "return nd_stts (return val)", node->nd_stts);

- if (is->type == ISEQ_TYPE_METHOD) {

- add_ensure_iseq(ret, iseq, 1);

- ADD_TRACE(ret, nd_line(node), RUBY_EVENT_RETURN);

- ADD_INSN(ret, nd_line(node), leave);

- ADD_ADJUST_RESTORE(ret, splabel);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN1(ret, nd_line(node), throw, INT2FIX(0x01) /* TAG_RETURN */ );

- ADD_INSN(ret, nd_line(node), pop);

- DECL_ANCHOR(args);

- unsigned long flag = 0;

- INIT_ANCHOR(args);

- if (iseq->type == ISEQ_TYPE_TOP) {

- COMPILE_ERROR((ERROR_ARGS "Invalid yield"));

- if (node->nd_head) {

- argc = setup_args(iseq, args, node->nd_head, &flag);

- argc = INT2FIX(0);

- ADD_SEQ(ret, args);

- ADD_INSN2(ret, nd_line(node), invokeblock, argc, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), pop);

- ID id = node->nd_vid;

- int idx = iseq->local_iseq->local_size - get_local_var_idx(iseq, id);

- debugs("id: %s idx: %d\n", rb_id2name(id), idx);

- ADD_INSN1(ret, nd_line(node), getlocal, INT2FIX(idx));

- debugi("nd_vid", node->nd_vid);

- idx = get_dyna_var_idx(iseq, node->nd_vid, &lv, &ls);

- rb_bug("unknown dvar (%s)", rb_id2name(node->nd_vid));

- ADD_INSN2(ret, nd_line(node), getdynamic, INT2FIX(ls - idx), INT2FIX(lv));

- ADD_INSN1(ret, nd_line(node), getglobal,

- (((long)node->nd_entry) | 1));

- ADD_INSN(ret, nd_line(node), pop);

- debugi("nd_vid", node->nd_vid);

- ADD_INSN2(ret, nd_line(node), getinstancevariable,

- ID2SYM(node->nd_vid), INT2FIX(iseq->ic_size++));

- debugi("nd_vid", node->nd_vid);

- if (iseq->compile_data->option->inline_const_cache) {

- LABEL *lend = NEW_LABEL(nd_line(node));

- int ic_index = iseq->ic_size++;

- ADD_INSN2(ret, nd_line(node), getinlinecache, lend, INT2FIX(ic_index));

- ADD_INSN1(ret, nd_line(node), getconstant, ID2SYM(node->nd_vid));

- ADD_INSN1(ret, nd_line(node), setinlinecache, INT2FIX(ic_index));

- ADD_LABEL(ret, lend);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN1(ret, nd_line(node), getconstant, ID2SYM(node->nd_vid));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), getclassvariable,

- ID2SYM(node->nd_vid));

- case NODE_NTH_REF:{

- ADD_INSN2(ret, nd_line(node), getspecial, INT2FIX(1) /* '~' */,

- INT2FIX(node->nd_nth << 1));

- case NODE_BACK_REF:{

- ADD_INSN2(ret, nd_line(node), getspecial, INT2FIX(1) /* '~' */,

- INT2FIX(0x01 | (node->nd_nth << 1)));

- case NODE_MATCH3:{

- DECL_ANCHOR(recv);

- INIT_ANCHOR(recv);

- switch(nd_type(node)) {

- ADD_INSN1(recv, nd_line(node), putobject, node->nd_lit);

- ADD_INSN2(val, nd_line(node), getspecial, INT2FIX(0),

- COMPILE(recv, "receiver", node->nd_recv);

- COMPILE(val, "value", node->nd_value);

- COMPILE(recv, "receiver", node->nd_value);

- COMPILE(val, "value", node->nd_recv);

- if (iseq->compile_data->option->specialized_instruction) {

- /* TODO: detect by node */

- if (recv->last == recv->anchor.next &&

- INSN_OF(recv->last) == BIN(putobject) &&

- nd_type(node) == NODE_MATCH2) {

- ADD_SEQ(ret, val);

- ADD_INSN1(ret, nd_line(node), opt_regexpmatch1,

- OPERAND_AT(recv->last, 0));

- ADD_SEQ(ret, recv);

- ADD_SEQ(ret, val);

- ADD_INSN(ret, nd_line(node), opt_regexpmatch2);

- ADD_SEQ(ret, recv);

- ADD_SEQ(ret, val);

- ADD_SEND(ret, nd_line(node), ID2SYM(idEqTilde), INT2FIX(1));

- ADD_INSN(ret, nd_line(node), pop);

- debugp_param("lit", node->nd_lit);

- ADD_INSN1(ret, nd_line(node), putobject, node->nd_lit);

- debugp_param("nd_lit", node->nd_lit);

- OBJ_FREEZE(node->nd_lit);

- ADD_INSN1(ret, nd_line(node), putstring, node->nd_lit);

- compile_dstr(iseq, ret, node);

- ADD_INSN(ret, nd_line(node), pop);

- OBJ_FREEZE(node->nd_lit);

- ADD_CALL_RECEIVER(ret, nd_line(node));

- ADD_INSN1(ret, nd_line(node), putobject, node->nd_lit);

- ADD_CALL(ret, nd_line(node), ID2SYM(idBackquote), INT2FIX(1));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_CALL_RECEIVER(ret, nd_line(node));

- compile_dstr(iseq, ret, node);

- ADD_CALL(ret, nd_line(node), ID2SYM(idBackquote), INT2FIX(1));

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "nd_body", node->nd_body);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN(ret, nd_line(node), tostring);

- compile_dregx(iseq, ret, node);

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_DREGX_ONCE:{

- LABEL *lend = NEW_LABEL(nd_line(node));

- int ic_index = iseq->ic_size++;

- ADD_INSN2(ret, nd_line(node), onceinlinecache, lend, INT2FIX(ic_index));

- ADD_INSN(ret, nd_line(node), pop);

- compile_dregx(iseq, ret, node);

- ADD_INSN1(ret, nd_line(node), setinlinecache, INT2FIX(ic_index));

- ADD_LABEL(ret, lend);

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_ARGSCAT:{

- COMPILE(ret, "argscat head", node->nd_head);

- ADD_INSN1(ret, nd_line(node), splatarray, Qfalse);

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "argscat body", node->nd_body);

- ADD_INSN1(ret, nd_line(node), splatarray, Qfalse);

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE(ret, "argscat head", node->nd_head);

- COMPILE(ret, "argscat body", node->nd_body);

- ADD_INSN(ret, nd_line(node), concatarray);

- case NODE_ARGSPUSH:{

- COMPILE(ret, "arsgpush head", node->nd_head);

- ADD_INSN1(ret, nd_line(node), splatarray, Qfalse);

- ADD_INSN(ret, nd_line(node), pop);

- COMPILE_(ret, "argspush body", node->nd_body, poped);

- COMPILE(ret, "arsgpush head", node->nd_head);

- COMPILE_(ret, "argspush body", node->nd_body, poped);

- ADD_INSN1(ret, nd_line(node), newarray, INT2FIX(1));

- ADD_INSN(ret, nd_line(node), concatarray);

- COMPILE(ret, "splat", node->nd_head);

- ADD_INSN1(ret, nd_line(node), splatarray, Qfalse);

- ADD_INSN(ret, nd_line(node), pop);

- VALUE iseqval = NEW_ISEQVAL(node->nd_defn,

- rb_str_dup(rb_id2str(node->nd_mid)),

- ISEQ_TYPE_METHOD, nd_line(node));

- debugp_param("defn/iseq", iseqval);

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));

- ADD_INSN1(ret, nd_line(node), putobject, ID2SYM(node->nd_mid));

- ADD_INSN1(ret, nd_line(node), putiseq, iseqval);

- ADD_SEND (ret, nd_line(node), ID2SYM(id_core_define_method), INT2FIX(3));

- ADD_INSN(ret, nd_line(node), pop);

- debugp_param("defn", iseqval);

- VALUE iseqval = NEW_ISEQVAL(node->nd_defn,

- rb_str_dup(rb_id2str(node->nd_mid)),

- ISEQ_TYPE_METHOD, nd_line(node));

- debugp_param("defs/iseq", iseqval);

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));

- COMPILE(ret, "defs: recv", node->nd_recv);

- ADD_INSN1(ret, nd_line(node), putobject, ID2SYM(node->nd_mid));

- ADD_INSN1(ret, nd_line(node), putiseq, iseqval);

- ADD_SEND (ret, nd_line(node), ID2SYM(id_core_define_singleton_method), INT2FIX(3));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));

- COMPILE(ret, "alias arg1", node->u1.node);

- COMPILE(ret, "alias arg2", node->u2.node);

- ADD_SEND(ret, nd_line(node), ID2SYM(id_core_set_method_alias), INT2FIX(3));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_VALIAS:{

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));

- ADD_INSN1(ret, nd_line(node), putobject, ID2SYM(node->u1.id));

- ADD_INSN1(ret, nd_line(node), putobject, ID2SYM(node->u2.id));

- ADD_SEND(ret, nd_line(node), ID2SYM(id_core_set_variable_alias), INT2FIX(2));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE));

- COMPILE(ret, "undef arg", node->u2.node);

- ADD_SEND(ret, nd_line(node), ID2SYM(id_core_undef_method), INT2FIX(2));

- ADD_INSN(ret, nd_line(node), pop);

- NEW_CHILD_ISEQVAL(

- rb_sprintf("<class:%s>", rb_id2name(node->nd_cpath->nd_mid)),

- ISEQ_TYPE_CLASS, nd_line(node));

- compile_cpath(ret, iseq, node->nd_cpath);

- COMPILE(ret, "super", node->nd_super);

- ADD_INSN3(ret, nd_line(node), defineclass,

- ID2SYM(node->nd_cpath->nd_mid), iseqval, INT2FIX(0));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_MODULE:{

- VALUE iseqval = NEW_CHILD_ISEQVAL(

- rb_sprintf("<module:%s>", rb_id2name(node->nd_cpath->nd_mid)),

- ISEQ_TYPE_CLASS, nd_line(node));

- compile_cpath(ret, iseq, node->nd_cpath);

- ADD_INSN (ret, nd_line(node), putnil); /* dummy */

- ADD_INSN3(ret, nd_line(node), defineclass,

- ID2SYM(node->nd_cpath->nd_mid), iseqval, INT2FIX(2));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_SCLASS:{

- ID singletonclass;

- NEW_ISEQVAL(node->nd_body, rb_str_new2("singletonclass"),

- ISEQ_TYPE_CLASS, nd_line(node));

- COMPILE(ret, "sclass#recv", node->nd_recv);

- ADD_INSN (ret, nd_line(node), putnil);

- CONST_ID(singletonclass, "singletonclass");

- ADD_INSN3(ret, nd_line(node), defineclass,

- ID2SYM(singletonclass), iseqval, INT2FIX(1));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_COLON2:{

- if (rb_is_const_id(node->nd_mid)) {

- LABEL *lend = NEW_LABEL(nd_line(node));

- int ic_index = iseq->ic_size++;

- DECL_ANCHOR(pref);

- DECL_ANCHOR(body);

- INIT_ANCHOR(pref);

- INIT_ANCHOR(body);

- compile_colon2(iseq, node, pref, body);

- if (LIST_SIZE_ZERO(pref)) {

- if (iseq->compile_data->option->inline_const_cache) {

- ADD_INSN2(ret, nd_line(node), getinlinecache, lend, INT2FIX(ic_index));

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_SEQ(ret, body);

- if (iseq->compile_data->option->inline_const_cache) {

- ADD_INSN1(ret, nd_line(node), setinlinecache, INT2FIX(ic_index));

- ADD_LABEL(ret, lend);

- ADD_SEQ(ret, pref);

- ADD_SEQ(ret, body);

- /* function call */

- ADD_CALL_RECEIVER(ret, nd_line(node));

- COMPILE(ret, "colon2#nd_head", node->nd_head);

- ADD_CALL(ret, nd_line(node), ID2SYM(node->nd_mid),

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_COLON3:{

- LABEL *lend = NEW_LABEL(nd_line(node));

- int ic_index = iseq->ic_size++;

- debugi("colon3#nd_mid", node->nd_mid);

- /* add cache insn */

- if (iseq->compile_data->option->inline_const_cache) {

- ADD_INSN2(ret, nd_line(node), getinlinecache, lend, INT2FIX(ic_index));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), putobject, rb_cObject);

- ADD_INSN1(ret, nd_line(node), getconstant, ID2SYM(node->nd_mid));

- if (iseq->compile_data->option->inline_const_cache) {

- ADD_INSN1(ret, nd_line(node), setinlinecache, INT2FIX(ic_index));

- ADD_LABEL(ret, lend);

- ADD_INSN(ret, nd_line(node), pop);

- VALUE flag = type == NODE_DOT2 ? INT2FIX(0) : INT2FIX(1);

- COMPILE(ret, "min", (NODE *) node->nd_beg);

- COMPILE(ret, "max", (NODE *) node->nd_end);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), newrange, flag);

- LABEL *lend = NEW_LABEL(nd_line(node));

- LABEL *lfin = NEW_LABEL(nd_line(node));

- LABEL *ltrue = NEW_LABEL(nd_line(node));

- VALUE key = rb_sprintf("flipflag/%s-%p-%d",

- RSTRING_PTR(iseq->name), (void *)iseq,

- iseq->compile_data->flip_cnt++);

- iseq_add_mark_object_compile_time(iseq, key);

- ADD_INSN2(ret, nd_line(node), getspecial, key, INT2FIX(0));

- ADD_INSNL(ret, nd_line(node), branchif, lend);

- COMPILE(ret, "flip2 beg", node->nd_beg);

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSNL(ret, nd_line(node), branchunless, lfin);

- if (nd_type(node) == NODE_FLIP3) {

- ADD_INSN(ret, nd_line(node), dup);

- ADD_INSN1(ret, nd_line(node), setspecial, key);

- ADD_INSNL(ret, nd_line(node), jump, lfin);

- ADD_INSN1(ret, nd_line(node), setspecial, key);

- ADD_LABEL(ret, lend);

- COMPILE(ret, "flip2 end", node->nd_end);

- ADD_INSNL(ret, nd_line(node), branchunless, ltrue);

- ADD_INSN1(ret, nd_line(node), putobject, Qfalse);

- ADD_INSN1(ret, nd_line(node), setspecial, key);

- ADD_LABEL(ret, ltrue);

- ADD_INSN1(ret, nd_line(node), putobject, Qtrue);

- ADD_LABEL(ret, lfin);

- ADD_INSN(ret, nd_line(node), putself);

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_INSN1(ret, nd_line(node), putobject, Qtrue);

- ADD_INSN1(ret, nd_line(node), putobject, Qfalse);

- case NODE_ERRINFO:{

- if (iseq->type == ISEQ_TYPE_RESCUE) {

- ADD_INSN2(ret, nd_line(node), getdynamic, INT2FIX(2), INT2FIX(0));

- rb_iseq_t *ip = iseq;

- if (ip->type == ISEQ_TYPE_RESCUE) {

- ip = ip->parent_iseq;

- ADD_INSN2(ret, nd_line(node), getdynamic, INT2FIX(2), INT2FIX(level));

- ADD_INSN(ret, nd_line(node), putnil);

- case NODE_DEFINED:{

- LABEL *lfinish[2];

- lfinish[0] = NEW_LABEL(nd_line(node));

- ADD_INSN(ret, nd_line(node), putnil);

- defined_expr(iseq, ret, node->nd_head, lfinish, Qtrue);

- ADD_INSN(ret, nd_line(node), swap);

- ADD_INSN(ret, nd_line(node), pop);

- ADD_LABEL(ret, lfinish[1]);

- ADD_LABEL(ret, lfinish[0]);

- case NODE_POSTEXE:{

- LABEL *lend = NEW_LABEL(nd_line(node));

- VALUE block = NEW_CHILD_ISEQVAL(node->nd_body, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, nd_line(node));

- int ic_index = iseq->ic_size++;

- ADD_INSN2(ret, nd_line(node), onceinlinecache, lend, INT2FIX(ic_index));

- ADD_INSN(ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));

- ADD_INSN1(ret, nd_line(node), putiseq, block);

- ADD_SEND (ret, nd_line(node), ID2SYM(id_core_set_postexe), INT2FIX(1));

- ADD_INSN1(ret, nd_line(node), setinlinecache, INT2FIX(ic_index));

- ADD_LABEL(ret, lend);

- ADD_INSN(ret, nd_line(node), pop);

- compile_dstr(iseq, ret, node);

- ADD_SEND(ret, nd_line(node), ID2SYM(idIntern), INT2FIX(0));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_ATTRASGN:{

- DECL_ANCHOR(recv);

- DECL_ANCHOR(args);

- unsigned long flag = 0;

- INIT_ANCHOR(recv);

- INIT_ANCHOR(args);

- argc = setup_args(iseq, args, node->nd_args, &flag);

- if (node->nd_recv == (NODE *) 1) {

- flag |= VM_CALL_FCALL_BIT;

- ADD_INSN(recv, nd_line(node), putself);

- COMPILE(recv, "recv", node->nd_recv);

- debugp_param("argc", argc);

- debugp_param("nd_mid", ID2SYM(node->nd_mid));

- ADD_INSN(ret, nd_line(node), putnil);

- ADD_SEQ(ret, recv);

- ADD_SEQ(ret, args);

- if (flag & VM_CALL_ARGS_BLOCKARG_BIT) {

- ADD_INSN1(ret, nd_line(node), topn, INT2FIX(1));

- ADD_INSN1(ret, nd_line(node), setn, FIXNUM_INC(argc, 3));

- ADD_INSN (ret, nd_line(node), pop);

- ADD_INSN1(ret, nd_line(node), setn, FIXNUM_INC(argc, 1));

- ADD_SEQ(ret, recv);

- ADD_SEQ(ret, args);

- ADD_SEND_R(ret, nd_line(node), ID2SYM(node->nd_mid), argc, 0, LONG2FIX(flag));

- ADD_INSN(ret, nd_line(node), pop);

- case NODE_OPTBLOCK:{

- /* for optimize */

- LABEL *redo_label = NEW_LABEL(0);

- LABEL *next_label = NEW_LABEL(0);

- iseq->compile_data->start_label = next_label;

- iseq->compile_data->redo_label = redo_label;

- ADD_LABEL(ret, redo_label);

- COMPILE_(ret, "optblock body", node->nd_head, 1 /* pop */ );

- ADD_LABEL(ret, next_label);

- ADD_INSN(ret, 0, opt_checkenv);

- case NODE_PRELUDE:{

- COMPILE_POPED(ret, "prelude", node->nd_head);

- COMPILE_(ret, "body", node->nd_body, poped);

- case NODE_LAMBDA:{

- /* compile same as lambda{...} */

- VALUE block = NEW_CHILD_ISEQVAL(node->nd_body, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, nd_line(node));

- VALUE argc = INT2FIX(0);

- ADD_CALL_RECEIVER(ret, nd_line(node));

- ADD_CALL_WITH_BLOCK(ret, nd_line(node), ID2SYM(idLambda), argc, block);

- ADD_INSN(ret, nd_line(node), pop);

- rb_bug("iseq_compile_each: unknown node: %s", ruby_node_name(type));

- return COMPILE_NG;

- return COMPILE_OK;

-/***************************/

-/* instruction information */

-/***************************/

-insn_data_length(INSN *iobj)

- return insn_len(iobj->insn_id);

-calc_sp_depth(int depth, INSN *insn)

- return insn_stack_increase(depth, insn->insn_id, insn->operands);

-insn_data_line_no(INSN *iobj)

- return insn_len(iobj->line_no);

-insn_data_to_s_detail(INSN *iobj)

- VALUE str = rb_sprintf("%-16s", insn_name(iobj->insn_id));

- if (iobj->operands) {

- const char *types = insn_op_types(iobj->insn_id);

- for (j = 0; types[j]; j++) {

- char type = types[j];

- printf("str: %"PRIxVALUE", type: %c\n", str, type);

- case TS_OFFSET: /* label(destination position) */

- LABEL *lobj = (LABEL *)OPERAND_AT(iobj, j);

- rb_str_catf(str, "<L%03d>", lobj->label_no);

- case TS_ISEQ: /* iseq */

- rb_iseq_t *iseq = (rb_iseq_t *)OPERAND_AT(iobj, j);

- rb_str_concat(str, rb_inspect(val));

- case TS_NUM: /* ulong */

- case TS_VALUE: /* VALUE */

- rb_str_concat(str, rb_inspect(OPERAND_AT(iobj, j)));

- case TS_ID: /* ID */

- rb_str_concat(str, rb_inspect(OPERAND_AT(iobj, j)));

- struct rb_global_entry *entry = (struct rb_global_entry *)

- (OPERAND_AT(iobj, j) & (~1));

- rb_str_cat2(str, rb_id2name(entry->id));

- case TS_IC: /* method cache */

- rb_str_catf(str, "<ic:%d>", FIX2INT(OPERAND_AT(iobj, j)));

- case TS_CDHASH: /* case/when condition cache */

- rb_str_cat2(str, "<ch>");

- rb_raise(rb_eSyntaxError, "unknown operand type: %c", type);

- if (types[j + 1]) {

- rb_str_cat2(str, ", ");

-dump_disasm_list(struct iseq_link_element *link)

- printf("-- raw disasm--------\n");

- switch (link->type) {

- case ISEQ_ELEMENT_INSN:

- iobj = (INSN *)link;

- str = insn_data_to_s_detail(iobj);

- printf("%04d %-65s(%4d)\n", pos, StringValueCStr(str),

- insn_data_line_no(iobj));

- pos += insn_data_length(iobj);

- case ISEQ_ELEMENT_LABEL:

- lobj = (LABEL *)link;

- printf("<L%03d>\n", lobj->label_no);

- case ISEQ_ELEMENT_NONE:

- printf("[none]\n");

- case ISEQ_ELEMENT_ADJUST:

- ADJUST *adjust = (ADJUST *)link;

- printf("adjust: [label: %d]\n", adjust->label->label_no);

- rb_raise(rb_eSyntaxError, "dump_disasm_list error: %ld\n", FIX2LONG(link->type));

- link = link->next;

- printf("---------------------\n");

-rb_insns_name_array(void)

- VALUE ary = rb_ary_new();

- for (i = 0; i < numberof(insn_name_info); i++) {

- rb_ary_push(ary, rb_obj_freeze(rb_str_new2(insn_name_info[i])));

- return rb_obj_freeze(ary);

-register_label(rb_iseq_t *iseq, struct st_table *labels_table, VALUE obj)

- obj = rb_convert_type(obj, T_SYMBOL, "Symbol", "to_sym");

- if (st_lookup(labels_table, obj, &tmp) == 0) {

- label = NEW_LABEL(0);

- st_insert(labels_table, obj, (st_data_t)label);

- label = (LABEL *)tmp;

-get_exception_sym2type(VALUE sym)

-#define rb_intern(str) rb_intern_const(str)

- static VALUE symRescue, symEnsure, symRetry;

- static VALUE symBreak, symRedo, symNext;

- if (symRescue == 0) {

- symRescue = ID2SYM(rb_intern("rescue"));

- symEnsure = ID2SYM(rb_intern("ensure"));

- symRetry = ID2SYM(rb_intern("retry"));

- symBreak = ID2SYM(rb_intern("break"));

- symRedo = ID2SYM(rb_intern("redo"));

- symNext = ID2SYM(rb_intern("next"));

- if (sym == symRescue) return CATCH_TYPE_RESCUE;

- if (sym == symEnsure) return CATCH_TYPE_ENSURE;

- if (sym == symRetry) return CATCH_TYPE_RETRY;

- if (sym == symBreak) return CATCH_TYPE_BREAK;

- if (sym == symRedo) return CATCH_TYPE_REDO;

- if (sym == symNext) return CATCH_TYPE_NEXT;

- rb_raise(rb_eSyntaxError, "invalid exception symbol: %s",

- RSTRING_PTR(rb_inspect(sym)));

-iseq_build_exception(rb_iseq_t *iseq, struct st_table *labels_table,

- for (i=0; i<RARRAY_LEN(exception); i++) {

- VALUE v, type, *ptr, eiseqval;

- LABEL *lstart, *lend, *lcont;

- RB_GC_GUARD(v) = rb_convert_type(RARRAY_PTR(exception)[i], T_ARRAY,

- "Array", "to_ary");

- if (RARRAY_LEN(v) != 6) {

- rb_raise(rb_eSyntaxError, "wrong exception entry");

- ptr = RARRAY_PTR(v);

- type = get_exception_sym2type(ptr[0]);

- if (ptr[1] == Qnil) {

- eiseqval = rb_iseq_load(ptr[1], iseq->self, Qnil);

- lstart = register_label(iseq, labels_table, ptr[2]);

- lend = register_label(iseq, labels_table, ptr[3]);

- lcont = register_label(iseq, labels_table, ptr[4]);

- sp = NUM2INT(ptr[5]);

- ADD_CATCH_ENTRY(type, lstart, lend, eiseqval, lcont);

- return COMPILE_OK;

-static struct st_table *

-insn_make_insn_table(void)

- struct st_table *table;

- table = st_init_numtable();

- for (i=0; i<VM_INSTRUCTION_SIZE; i++) {

- st_insert(table, ID2SYM(rb_intern(insn_name(i))), i);

-iseq_build_body(rb_iseq_t *iseq, LINK_ANCHOR *anchor,

- VALUE body, struct st_table *labels_table)

- /* TODO: body should be frozen */

- VALUE *ptr = RARRAY_PTR(body);

- long i, len = RARRAY_LEN(body);

- * index -> LABEL *label

- static struct st_table *insn_table;

- if (insn_table == 0) {

- insn_table = insn_make_insn_table();

- for (i=0; i<len; i++) {

- VALUE obj = ptr[i];

- if (SYMBOL_P(obj)) {

- LABEL *label = register_label(iseq, labels_table, obj);

- ADD_LABEL(anchor, label);

- else if (FIXNUM_P(obj)) {

- line_no = NUM2INT(obj);

- else if (TYPE(obj) == T_ARRAY) {

- int argc = RARRAY_LENINT(obj) - 1;

- insn = (argc < 0) ? Qnil : RARRAY_PTR(obj)[0];

- if (st_lookup(insn_table, insn, &insn_id) == 0) {

- /* TODO: exception */

- RB_GC_GUARD(insn) = rb_inspect(insn);

- rb_compile_error(RSTRING_PTR(iseq->filename), line_no,

- "unknown instruction: %s", RSTRING_PTR(insn));

- if (argc != insn_len(insn_id)-1) {

- rb_compile_error(RSTRING_PTR(iseq->filename), line_no,

- "operand size mismatch");

- argv = compile_data_alloc(iseq, sizeof(VALUE) * argc);

- for (j=0; j<argc; j++) {

- VALUE op = rb_ary_entry(obj, j+1);

- switch (insn_op_type(insn_id, j)) {

- LABEL *label = register_label(iseq, labels_table, op);

- argv[j] = (VALUE)label;

- (void)NUM2INT(op);

- iseq_add_mark_object(iseq, op);

- if (TYPE(op) == T_ARRAY) {

- argv[j] = rb_iseq_load(op, iseq->self, Qnil);

- else if (CLASS_OF(op) == rb_cISeq) {

- rb_raise(rb_eSyntaxError, "ISEQ is required");

- iseq_add_mark_object(iseq, argv[j]);

- op = rb_convert_type(op, T_SYMBOL, "Symbol", "to_sym");

- argv[j] = (VALUE)rb_global_entry(SYM2ID(op));

- if (NUM2INT(op) >= iseq->ic_size)

- iseq->ic_size = NUM2INT(op) + 1;

- argv[j] = rb_convert_type(op, T_SYMBOL,

- "Symbol", "to_sym");

- op = rb_convert_type(op, T_ARRAY, "Array", "to_ary");

- op = rb_ary_dup(op);

- for (i=0; i<RARRAY_LEN(op); i+=2) {

- VALUE sym = rb_ary_entry(op, i+1);

- register_label(iseq, labels_table, sym);

- rb_ary_store(op, i+1, (VALUE)label | 1);

- iseq_add_mark_object_compile_time(iseq, op);

- rb_raise(rb_eSyntaxError, "unknown operand: %c", insn_op_type(insn_id, j));

- (LINK_ELEMENT*)new_insn_core(iseq, line_no,

- (enum ruby_vminsn_type)insn_id, argc, argv));

- rb_raise(rb_eTypeError, "unexpected object for instruction");

- st_free_table(labels_table);

- iseq_setup(iseq, anchor);

- return COMPILE_OK;

-#define CHECK_ARRAY(v) rb_convert_type(v, T_ARRAY, "Array", "to_ary")

-#define CHECK_STRING(v) rb_convert_type(v, T_STRING, "String", "to_str")

-#define CHECK_SYMBOL(v) rb_convert_type(v, T_SYMBOL, "Symbol", "to_sym")

-static inline VALUE CHECK_INTEGER(VALUE v) {NUM2LONG(v); return v;}

-rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE locals, VALUE args,

- VALUE exception, VALUE body)

- struct st_table *labels_table = st_init_numtable();

- DECL_ANCHOR(anchor);

- INIT_ANCHOR(anchor);

- iseq->local_table_size = RARRAY_LENINT(locals);

- iseq->local_table = tbl = (ID *)ALLOC_N(ID *, iseq->local_table_size);

- iseq->local_size = iseq->local_table_size + 1;

- for (i=0; i<RARRAY_LEN(locals); i++) {

- VALUE lv = RARRAY_PTR(locals)[i];

- tbl[i] = FIXNUM_P(lv) ? (ID)FIX2LONG(lv) : SYM2ID(CHECK_SYMBOL(lv));

- if (FIXNUM_P(args)) {

- iseq->arg_size = iseq->argc = FIX2INT(args);

- iseq->arg_simple = 1;

- VALUE argc = CHECK_INTEGER(rb_ary_entry(args, i++));

- VALUE arg_opt_labels = CHECK_ARRAY(rb_ary_entry(args, i++));

- VALUE arg_post_len = CHECK_INTEGER(rb_ary_entry(args, i++));

- VALUE arg_post_start = CHECK_INTEGER(rb_ary_entry(args, i++));

- VALUE arg_rest = CHECK_INTEGER(rb_ary_entry(args, i++));

- VALUE arg_block = CHECK_INTEGER(rb_ary_entry(args, i++));

- VALUE arg_simple = CHECK_INTEGER(rb_ary_entry(args, i++));

- iseq->argc = FIX2INT(argc);

- iseq->arg_rest = FIX2INT(arg_rest);

- iseq->arg_post_len = FIX2INT(arg_post_len);

- iseq->arg_post_start = FIX2INT(arg_post_start);

- iseq->arg_block = FIX2INT(arg_block);

- iseq->arg_opts = RARRAY_LENINT(arg_opt_labels);

- iseq->arg_opt_table = (VALUE *)ALLOC_N(VALUE, iseq->arg_opts);

- if (iseq->arg_block != -1) {

- iseq->arg_size = iseq->arg_block + 1;

- else if (iseq->arg_post_len) {

- iseq->arg_size = iseq->arg_post_start + iseq->arg_post_len;

- else if (iseq->arg_rest != -1) {

- iseq->arg_size = iseq->arg_rest + 1;

- iseq->arg_size = iseq->argc + (iseq->arg_opts ? iseq->arg_opts - 1 : 0);

- for (i=0; i<RARRAY_LEN(arg_opt_labels); i++) {

- iseq->arg_opt_table[i] =

- (VALUE)register_label(iseq, labels_table,

- rb_ary_entry(arg_opt_labels, i));

- iseq->arg_simple = NUM2INT(arg_simple);

- iseq_build_exception(iseq, labels_table, exception);

- iseq_build_body(iseq, anchor, body, labels_table);

- return iseq->self;

-rb_dvar_defined(ID id)

- rb_thread_t *th = GET_THREAD();

- if (th->base_block && (iseq = th->base_block->iseq)) {

- while (iseq->type == ISEQ_TYPE_BLOCK ||

- iseq->type == ISEQ_TYPE_RESCUE ||

- iseq->type == ISEQ_TYPE_ENSURE ||

- iseq->type == ISEQ_TYPE_EVAL ||

- iseq->type == ISEQ_TYPE_MAIN

- for (i = 0; i < iseq->local_table_size; i++) {

- if (iseq->local_table[i] == id) {

- iseq = iseq->parent_iseq;

-rb_local_defined(ID id)

- rb_thread_t *th = GET_THREAD();

- if (th->base_block && th->base_block->iseq) {

- iseq = th->base_block->iseq->local_iseq;

- for (i=0; i<iseq->local_table_size; i++) {

- if (iseq->local_table[i] == id) {

-rb_parse_in_eval(void)

- return GET_THREAD()->parse_in_eval > 0;

-rb_parse_in_main(void)

- return GET_THREAD()->parse_in_eval < 0;

- complex.c: Coded by Tadayoshi Funaba 2008,2009

- This implementation is based on Keiju Ishitsuka's Complex library

- which is written in ruby.

-#include <assert.h>

-#define ZERO INT2FIX(0)

-#define ONE INT2FIX(1)

-#define TWO INT2FIX(2)

-static ID id_abs, id_abs2, id_arg, id_cmp, id_conj, id_convert,

- id_denominator, id_divmod, id_eqeq_p, id_expt, id_fdiv, id_floor,

- id_idiv, id_imag, id_inspect, id_negate, id_numerator, id_quo,

- id_real, id_real_p, id_to_f, id_to_i, id_to_r, id_to_s;

-#define f_boolcast(x) ((x) ? Qtrue : Qfalse)

-#define binop(n,op) \

-inline static VALUE \

-f_##n(VALUE x, VALUE y)\

- return rb_funcall(x, op, 1, y);\

-inline static VALUE \

- return rb_funcall(x, id_##n, 0);\

-inline static VALUE \

-f_##n(VALUE x, VALUE y)\

- return rb_funcall(x, id_##n, 1, y);\

-inline static VALUE \

- return rb_funcall(rb_mMath, id_##n, 1, x);\

-inline static VALUE \

-m_##n(VALUE x, VALUE y)\

- return rb_funcall(rb_mMath, id_##n, 2, x, y);\

-#define PRESERVE_SIGNEDZERO

-inline static VALUE

-f_add(VALUE x, VALUE y)

-#ifndef PRESERVE_SIGNEDZERO

- if (FIXNUM_P(y) && FIX2LONG(y) == 0)

- else if (FIXNUM_P(x) && FIX2LONG(x) == 0)

- return rb_funcall(x, '+', 1, y);

-inline static VALUE

-f_cmp(VALUE x, VALUE y)

- if (FIXNUM_P(x) && FIXNUM_P(y)) {

- long c = FIX2LONG(x) - FIX2LONG(y);

- return INT2FIX(c);

- return rb_funcall(x, id_cmp, 1, y);

-inline static VALUE

-f_div(VALUE x, VALUE y)

- if (FIXNUM_P(y) && FIX2LONG(y) == 1)

- return rb_funcall(x, '/', 1, y);

-inline static VALUE

-f_gt_p(VALUE x, VALUE y)

- if (FIXNUM_P(x) && FIXNUM_P(y))

- return f_boolcast(FIX2LONG(x) > FIX2LONG(y));

- return rb_funcall(x, '>', 1, y);

-inline static VALUE

-f_lt_p(VALUE x, VALUE y)

- if (FIXNUM_P(x) && FIXNUM_P(y))

- return f_boolcast(FIX2LONG(x) < FIX2LONG(y));

- return rb_funcall(x, '<', 1, y);

-inline static VALUE

-f_mul(VALUE x, VALUE y)

-#ifndef PRESERVE_SIGNEDZERO

- if (FIXNUM_P(y)) {

- long iy = FIX2LONG(y);

- if (FIXNUM_P(x) || TYPE(x) == T_BIGNUM)

- else if (FIXNUM_P(x)) {

- long ix = FIX2LONG(x);

- if (FIXNUM_P(y) || TYPE(y) == T_BIGNUM)

- return rb_funcall(x, '*', 1, y);

-inline static VALUE

-f_sub(VALUE x, VALUE y)

-#ifndef PRESERVE_SIGNEDZERO

- if (FIXNUM_P(y) && FIX2LONG(y) == 0)

- return rb_funcall(x, '-', 1, y);

-inline static VALUE

-f_eqeq_p(VALUE x, VALUE y)

- if (FIXNUM_P(x) && FIXNUM_P(y))

- return f_boolcast(FIX2LONG(x) == FIX2LONG(y));

- return rb_funcall(x, id_eqeq_p, 1, y);

-inline static VALUE

-f_negative_p(VALUE x)

- return f_boolcast(FIX2LONG(x) < 0);

- return rb_funcall(x, '<', 1, ZERO);

-#define f_positive_p(x) (!f_negative_p(x))

-inline static VALUE

- switch (TYPE(x)) {

- return f_boolcast(FIX2LONG(x) == 0);

- VALUE num = RRATIONAL(x)->num;

- return f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == 0);

- return rb_funcall(x, id_eqeq_p, 1, ZERO);

-#define f_nonzero_p(x) (!f_zero_p(x))

-inline static VALUE

- switch (TYPE(x)) {

- return f_boolcast(FIX2LONG(x) == 1);

- VALUE num = RRATIONAL(x)->num;

- VALUE den = RRATIONAL(x)->den;

- return f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == 1 &&

- FIXNUM_P(den) && FIX2LONG(den) == 1);

- return rb_funcall(x, id_eqeq_p, 1, ONE);

-inline static VALUE

-f_kind_of_p(VALUE x, VALUE c)

- return rb_obj_is_kind_of(x, c);

-inline static VALUE

-k_numeric_p(VALUE x)

- return f_kind_of_p(x, rb_cNumeric);

-inline static VALUE

-k_integer_p(VALUE x)

- return f_kind_of_p(x, rb_cInteger);

-inline static VALUE

-k_fixnum_p(VALUE x)

- return f_kind_of_p(x, rb_cFixnum);

-inline static VALUE

-k_bignum_p(VALUE x)

- return f_kind_of_p(x, rb_cBignum);

-inline static VALUE

- return f_kind_of_p(x, rb_cFloat);

-inline static VALUE

-k_rational_p(VALUE x)

- return f_kind_of_p(x, rb_cRational);

-inline static VALUE

-k_complex_p(VALUE x)

- return f_kind_of_p(x, rb_cComplex);

-#define k_exact_p(x) (!k_float_p(x))

-#define k_inexact_p(x) k_float_p(x)

-#define k_exact_zero_p(x) (k_exact_p(x) && f_zero_p(x))

-#define k_exact_one_p(x) (k_exact_p(x) && f_one_p(x))

-#define get_dat1(x) \

- struct RComplex *dat;\

- dat = ((struct RComplex *)(x))

-#define get_dat2(x,y) \

- struct RComplex *adat, *bdat;\

- adat = ((struct RComplex *)(x));\

- bdat = ((struct RComplex *)(y))

-inline static VALUE

-nucomp_s_new_internal(VALUE klass, VALUE real, VALUE imag)

- NEWOBJ(obj, struct RComplex);

- OBJSETUP(obj, klass, T_COMPLEX);

- return (VALUE)obj;

-nucomp_s_alloc(VALUE klass)

- return nucomp_s_new_internal(klass, ZERO, ZERO);

-nucomp_s_new_bang(int argc, VALUE *argv, VALUE klass)

- switch (rb_scan_args(argc, argv, "11", &real, &imag)) {

- if (!k_numeric_p(real))

- real = f_to_i(real);

- if (!k_numeric_p(real))

- real = f_to_i(real);

- if (!k_numeric_p(imag))

- imag = f_to_i(imag);

- return nucomp_s_new_internal(klass, real, imag);

-inline static VALUE

-f_complex_new_bang1(VALUE klass, VALUE x)

- assert(!k_complex_p(x));

- return nucomp_s_new_internal(klass, x, ZERO);

-inline static VALUE

-f_complex_new_bang2(VALUE klass, VALUE x, VALUE y)

- assert(!k_complex_p(x));

- assert(!k_complex_p(y));

- return nucomp_s_new_internal(klass, x, y);

-#ifdef CANONICALIZATION_FOR_MATHN

-static int canonicalization = 0;

-nucomp_canonicalization(int f)

- canonicalization = f;

-nucomp_real_check(VALUE num)

- switch (TYPE(num)) {

- if (!k_numeric_p(num) || !f_real_p(num))

- rb_raise(rb_eTypeError, "not a real");

-inline static VALUE

-nucomp_s_canonicalize_internal(VALUE klass, VALUE real, VALUE imag)

- if (k_exact_zero_p(imag) && canonicalization)

- if (f_zero_p(imag) && canonicalization)

- if (f_real_p(real) && f_real_p(imag))

- return nucomp_s_new_internal(klass, real, imag);

- else if (f_real_p(real)) {

- return nucomp_s_new_internal(klass,

- f_sub(real, dat->imag),

- f_add(ZERO, dat->real));

- else if (f_real_p(imag)) {

- return nucomp_s_new_internal(klass,

- f_add(dat->imag, imag));

- get_dat2(real, imag);

- return nucomp_s_new_internal(klass,

- f_sub(adat->real, bdat->imag),

- f_add(adat->imag, bdat->real));

- * Complex.rect(real[, imag]) -> complex

- * Complex.rectangular(real[, imag]) -> complex

- * Returns a complex object which denotes the given rectangular form.

-nucomp_s_new(int argc, VALUE *argv, VALUE klass)

- switch (rb_scan_args(argc, argv, "11", &real, &imag)) {

- nucomp_real_check(real);

- nucomp_real_check(imag);

- return nucomp_s_canonicalize_internal(klass, real, imag);

-inline static VALUE

-f_complex_new1(VALUE klass, VALUE x)

- assert(!k_complex_p(x));

- return nucomp_s_canonicalize_internal(klass, x, ZERO);

-inline static VALUE

-f_complex_new2(VALUE klass, VALUE x, VALUE y)

- assert(!k_complex_p(x));

- return nucomp_s_canonicalize_internal(klass, x, y);

- * Complex(x[, y]) -> numeric

-nucomp_f_complex(int argc, VALUE *argv, VALUE klass)

- return rb_funcall2(rb_cComplex, id_convert, argc, argv);

-extern VALUE rb_math_##n(VALUE x);\

-inline static VALUE \

-m_##n##_bang(VALUE x)\

- return rb_math_##n(x);\

-extern VALUE rb_math_##n(VALUE x, VALUE y);\

-inline static VALUE \

-m_##n##_bang(VALUE x, VALUE y)\

- return rb_math_##n(x, y);\

-#define m_hypot(x,y) m_hypot_bang(x,y)

-extern VALUE rb_math_log(int argc, VALUE *argv);

-m_log_bang(VALUE x)

- return rb_math_log(1, &x);

- return m_cos_bang(x);

- return f_complex_new2(rb_cComplex,

- f_mul(m_cos_bang(dat->real),

- m_cosh_bang(dat->imag)),

- f_mul(f_negate(m_sin_bang(dat->real)),

- m_sinh_bang(dat->imag)));

- return m_sin_bang(x);

- return f_complex_new2(rb_cComplex,

- f_mul(m_sin_bang(dat->real),

- m_cosh_bang(dat->imag)),

- f_mul(m_cos_bang(dat->real),

- m_sinh_bang(dat->imag)));

- if (f_real_p(x)) {

- if (f_positive_p(x))

- return m_sqrt_bang(x);

- return f_complex_new2(rb_cComplex, ZERO, m_sqrt_bang(f_negate(x)));

- if (f_negative_p(dat->imag))

- return f_conj(m_sqrt(f_conj(x)));

- VALUE a = f_abs(x);

- return f_complex_new2(rb_cComplex,

- m_sqrt_bang(f_div(f_add(a, dat->real), TWO)),

- m_sqrt_bang(f_div(f_sub(a, dat->real), TWO)));

-inline static VALUE

-f_complex_polar(VALUE klass, VALUE x, VALUE y)

- assert(!k_complex_p(x));

- assert(!k_complex_p(y));

- return nucomp_s_canonicalize_internal(klass,

- f_mul(x, m_cos(y)),

- f_mul(x, m_sin(y)));

- * Complex.polar(abs[, arg]) -> complex

- * Returns a complex object which denotes the given polar form.

-nucomp_s_polar(int argc, VALUE *argv, VALUE klass)

- switch (rb_scan_args(argc, argv, "11", &abs, &arg)) {

- nucomp_real_check(abs);

- nucomp_real_check(arg);

- return f_complex_polar(klass, abs, arg);

- * cmp.real -> real

- * Returns the real part.

-nucomp_real(VALUE self)

- * cmp.imag -> real

- * cmp.imaginary -> real

- * Returns the imaginary part.

-nucomp_imag(VALUE self)

- * Returns negation of the value.

-nucomp_negate(VALUE self)

- return f_complex_new2(CLASS_OF(self),

- f_negate(dat->real), f_negate(dat->imag));

-inline static VALUE

-f_addsub(VALUE self, VALUE other,

- VALUE (*func)(VALUE, VALUE), ID id)

- if (k_complex_p(other)) {

- get_dat2(self, other);

- real = (*func)(adat->real, bdat->real);

- imag = (*func)(adat->imag, bdat->imag);

- return f_complex_new2(CLASS_OF(self), real, imag);

- if (k_numeric_p(other) && f_real_p(other)) {

- return f_complex_new2(CLASS_OF(self),

- (*func)(dat->real, other), dat->imag);

- return rb_num_coerce_bin(self, other, id);

- * cmp + numeric -> complex

- * Performs addition.

-nucomp_add(VALUE self, VALUE other)

- return f_addsub(self, other, f_add, '+');

- * cmp - numeric -> complex

- * Performs subtraction.

-nucomp_sub(VALUE self, VALUE other)

- return f_addsub(self, other, f_sub, '-');

- * cmp * numeric -> complex

- * Performs multiplication.

-nucomp_mul(VALUE self, VALUE other)

- if (k_complex_p(other)) {

- get_dat2(self, other);

- real = f_sub(f_mul(adat->real, bdat->real),

- f_mul(adat->imag, bdat->imag));

- imag = f_add(f_mul(adat->real, bdat->imag),

- f_mul(adat->imag, bdat->real));

- return f_complex_new2(CLASS_OF(self), real, imag);

- if (k_numeric_p(other) && f_real_p(other)) {

- return f_complex_new2(CLASS_OF(self),

- f_mul(dat->real, other),

- f_mul(dat->imag, other));

- return rb_num_coerce_bin(self, other, '*');

-inline static VALUE

-f_divide(VALUE self, VALUE other,

- VALUE (*func)(VALUE, VALUE), ID id)

- if (k_complex_p(other)) {

- get_dat2(self, other);

- flo = (k_float_p(adat->real) || k_float_p(adat->imag) ||

- k_float_p(bdat->real) || k_float_p(bdat->imag));

- if (f_gt_p(f_abs(bdat->real), f_abs(bdat->imag))) {

- r = (*func)(bdat->imag, bdat->real);

- n = f_mul(bdat->real, f_add(ONE, f_mul(r, r)));

- return f_complex_new2(CLASS_OF(self),

- (*func)(f_negate(f_mul(self, r)), n));

- return f_complex_new2(CLASS_OF(self),

- (*func)(f_add(adat->real,

- f_mul(adat->imag, r)), n),

- (*func)(f_sub(adat->imag,

- f_mul(adat->real, r)), n));

- r = (*func)(bdat->real, bdat->imag);

- n = f_mul(bdat->imag, f_add(ONE, f_mul(r, r)));

- return f_complex_new2(CLASS_OF(self),

- (*func)(f_mul(self, r), n),

- (*func)(f_negate(self), n));

- return f_complex_new2(CLASS_OF(self),

- (*func)(f_add(f_mul(adat->real, r),

- (*func)(f_sub(f_mul(adat->imag, r),

- if (k_numeric_p(other) && f_real_p(other)) {

- return f_complex_new2(CLASS_OF(self),

- (*func)(dat->real, other),

- (*func)(dat->imag, other));

- return rb_num_coerce_bin(self, other, id);

-#define rb_raise_zerodiv() rb_raise(rb_eZeroDivError, "divided by 0")

- * cmp / numeric -> complex

- * cmp.quo(numeric) -> complex

- * Performs division.

- * Complex(10.0) / 3 #=> (3.3333333333333335+(0/1)*i)

- * Complex(10) / 3 #=> ((10/3)+(0/1)*i) # not (3+0i)

-nucomp_div(VALUE self, VALUE other)

- return f_divide(self, other, f_quo, id_quo);

-#define nucomp_quo nucomp_div

- * cmp.fdiv(numeric) -> complex

- * Performs division as each part is a float, never returns a float.

- * Complex(11,22).fdiv(3) #=> (3.6666666666666665+7.333333333333333i)

-nucomp_fdiv(VALUE self, VALUE other)

- return f_divide(self, other, f_fdiv, id_fdiv);

-inline static VALUE

-f_reciprocal(VALUE x)

- return f_quo(ONE, x);

- * cmp ** numeric -> complex

- * Performs exponentiation.

- * Complex('i') ** 2 #=> (-1+0i)

- * Complex(-8) ** Rational(1,3) #=> (1.0000000000000002+1.7320508075688772i)

-nucomp_expt(VALUE self, VALUE other)

- if (k_exact_zero_p(other))

- return f_complex_new_bang1(CLASS_OF(self), ONE);

- if (k_rational_p(other) && f_one_p(f_denominator(other)))

- other = f_numerator(other); /* c14n */

- if (k_complex_p(other)) {

- if (k_exact_zero_p(dat->imag))

- other = dat->real; /* c14n */

- if (k_complex_p(other)) {

- VALUE r, theta, nr, ntheta;

- theta = f_arg(self);

- nr = m_exp_bang(f_sub(f_mul(dat->real, m_log_bang(r)),

- f_mul(dat->imag, theta)));

- ntheta = f_add(f_mul(theta, dat->real),

- f_mul(dat->imag, m_log_bang(r)));

- return f_complex_polar(CLASS_OF(self), nr, ntheta);

- if (k_fixnum_p(other)) {

- if (f_gt_p(other, ZERO)) {

- n = FIX2LONG(other) - 1;

- x = f_complex_new2(CLASS_OF(self),

- f_sub(f_mul(dat->real, dat->real),

- f_mul(dat->imag, dat->imag)),

- f_mul(f_mul(TWO, dat->real), dat->imag));

- return f_expt(f_reciprocal(self), f_negate(other));

- if (k_numeric_p(other) && f_real_p(other)) {

- if (k_bignum_p(other))

- rb_warn("in a**b, b may be too big");

- theta = f_arg(self);

- return f_complex_polar(CLASS_OF(self), f_expt(r, other),

- f_mul(theta, other));

- return rb_num_coerce_bin(self, other, id_expt);

- * cmp == object -> true or false

- * Returns true if cmp equals object numerically.

-nucomp_eqeq_p(VALUE self, VALUE other)

- if (k_complex_p(other)) {

- get_dat2(self, other);

- return f_boolcast(f_eqeq_p(adat->real, bdat->real) &&

- f_eqeq_p(adat->imag, bdat->imag));

- if (k_numeric_p(other) && f_real_p(other)) {

- return f_boolcast(f_eqeq_p(dat->real, other) && f_zero_p(dat->imag));

- return f_eqeq_p(other, self);

-nucomp_coerce(VALUE self, VALUE other)

- if (k_numeric_p(other) && f_real_p(other))

- return rb_assoc_new(f_complex_new_bang1(CLASS_OF(self), other), self);

- if (TYPE(other) == T_COMPLEX)

- return rb_assoc_new(other, self);

- rb_raise(rb_eTypeError, "%s can't be coerced into %s",

- rb_obj_classname(other), rb_obj_classname(self));

- * cmp.magnitude -> real

- * Returns the absolute part of its polar form.

-nucomp_abs(VALUE self)

- if (f_zero_p(dat->real)) {

- VALUE a = f_abs(dat->imag);

- if (k_float_p(dat->real) && !k_float_p(dat->imag))

- if (f_zero_p(dat->imag)) {

- VALUE a = f_abs(dat->real);

- if (!k_float_p(dat->real) && k_float_p(dat->imag))

- return m_hypot(dat->real, dat->imag);

- * cmp.abs2 -> real

- * Returns square of the absolute value.

-nucomp_abs2(VALUE self)

- return f_add(f_mul(dat->real, dat->real),

- f_mul(dat->imag, dat->imag));

- * cmp.arg -> float

- * cmp.angle -> float

- * cmp.phase -> float

- * Returns the angle part of its polar form.

-nucomp_arg(VALUE self)

- return m_atan2_bang(dat->imag, dat->real);

- * cmp.rect -> array

- * cmp.rectangular -> array

- * Returns an array; [cmp.real, cmp.imag].

-nucomp_rect(VALUE self)

- return rb_assoc_new(dat->real, dat->imag);

- * cmp.polar -> array

- * Returns an array; [cmp.abs, cmp.arg].

-nucomp_polar(VALUE self)

- return rb_assoc_new(f_abs(self), f_arg(self));

- * cmp.conj -> complex

- * cmp.conjugate -> complex

- * Returns the complex conjugate.

-nucomp_conj(VALUE self)

- return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag));

-nucomp_true(VALUE self)

- * cmp.real? -> false

-nucomp_false(VALUE self)

-nucomp_exact_p(VALUE self)

- return f_boolcast(k_exact_p(dat->real) && k_exact_p(dat->imag));

-nucomp_inexact_p(VALUE self)

- return f_boolcast(!nucomp_exact_p(self));

-extern VALUE rb_lcm(VALUE x, VALUE y);

- * cmp.denominator -> integer

- * Returns the denominator (lcm of both denominator, real and imag).

-nucomp_denominator(VALUE self)

- return rb_lcm(f_denominator(dat->real), f_denominator(dat->imag));

- * cmp.numerator -> numeric

- * Returns the numerator.

- * 1 2 3+4i <- numerator

- * 2 3 6 <- denominator

- * c = Complex('1/2+2/3i') #=> ((1/2)+(2/3)*i)

- * n = c.numerator #=> (3+4i)

- * d = c.denominator #=> 6

- * n / d #=> ((1/2)+(2/3)*i)

- * Complex(Rational(n.real, d), Rational(n.imag, d))

- * #=> ((1/2)+(2/3)*i)

- * See denominator.

-nucomp_numerator(VALUE self)

- cd = f_denominator(self);

- return f_complex_new2(CLASS_OF(self),

- f_mul(f_numerator(dat->real),

- f_div(cd, f_denominator(dat->real))),

- f_mul(f_numerator(dat->imag),

- f_div(cd, f_denominator(dat->imag))));

-nucomp_hash(VALUE self)

- st_index_t v, h[2];

- n = rb_hash(dat->real);

- h[0] = NUM2LONG(n);

- n = rb_hash(dat->imag);

- h[1] = NUM2LONG(n);

- v = rb_memhash(h, sizeof(h));

- return LONG2FIX(v);

-nucomp_eql_p(VALUE self, VALUE other)

- if (k_complex_p(other)) {

- get_dat2(self, other);

- return f_boolcast((CLASS_OF(adat->real) == CLASS_OF(bdat->real)) &&

- (CLASS_OF(adat->imag) == CLASS_OF(bdat->imag)) &&

- f_eqeq_p(self, other));

-inline static VALUE

- switch (TYPE(x)) {

- double f = RFLOAT_VALUE(x);

- return f_boolcast(!isnan(f) && signbit(f));

- return f_negative_p(x);

-inline static VALUE

-f_tpositive_p(VALUE x)

- return f_boolcast(!f_signbit(x));

-f_format(VALUE self, VALUE (*func)(VALUE))

- impos = f_tpositive_p(dat->imag);

- s = (*func)(dat->real);

- rb_str_cat2(s, !impos ? "-" : "+");

- rb_str_concat(s, (*func)(f_abs(dat->imag)));

- if (!rb_isdigit(RSTRING_PTR(s)[RSTRING_LEN(s) - 1]))

- rb_str_cat2(s, "*");

- rb_str_cat2(s, "i");

- * cmp.to_s -> string

- * Returns the value as a string.

-nucomp_to_s(VALUE self)

- return f_format(self, f_to_s);

- * cmp.inspect -> string

- * Returns the value as a string for inspection.

-nucomp_inspect(VALUE self)

- s = rb_usascii_str_new2("(");

- rb_str_concat(s, f_format(self, f_inspect));

- rb_str_cat2(s, ")");

-nucomp_marshal_dump(VALUE self)

- a = rb_assoc_new(dat->real, dat->imag);

- rb_copy_generic_ivar(a, self);

-nucomp_marshal_load(VALUE self, VALUE a)

- Check_Type(a, T_ARRAY);

- dat->real = RARRAY_PTR(a)[0];

- dat->imag = RARRAY_PTR(a)[1];

- rb_copy_generic_ivar(self, a);

-rb_complex_raw(VALUE x, VALUE y)

- return nucomp_s_new_internal(rb_cComplex, x, y);

-rb_complex_new(VALUE x, VALUE y)

- return nucomp_s_canonicalize_internal(rb_cComplex, x, y);

-rb_complex_polar(VALUE x, VALUE y)

- return f_complex_polar(rb_cComplex, x, y);

-static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass);

-rb_Complex(VALUE x, VALUE y)

- return nucomp_s_convert(2, a, rb_cComplex);

- * cmp.to_i -> integer

- * Returns the value as an integer if possible.

-nucomp_to_i(VALUE self)

- if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {

- VALUE s = f_to_s(self);

- rb_raise(rb_eRangeError, "can't convert %s into Integer",

- StringValuePtr(s));

- return f_to_i(dat->real);

- * cmp.to_f -> float

- * Returns the value as a float if possible.

-nucomp_to_f(VALUE self)

- if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {

- VALUE s = f_to_s(self);

- rb_raise(rb_eRangeError, "can't convert %s into Float",

- StringValuePtr(s));

- return f_to_f(dat->real);

- * cmp.to_r -> rational

- * Returns the value as a rational if possible.

-nucomp_to_r(VALUE self)

- if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) {

- VALUE s = f_to_s(self);

- rb_raise(rb_eRangeError, "can't convert %s into Rational",

- StringValuePtr(s));

- return f_to_r(dat->real);

- * cmp.rationalize([eps]) -> rational

- * Returns the value as a rational if possible. An optional argument

- * eps is always ignored.

-nucomp_rationalize(int argc, VALUE *argv, VALUE self)

- rb_scan_args(argc, argv, "01", NULL);

- return nucomp_to_r(self);

- * nil.to_c -> (0+0i)

- * Returns zero as a complex.

-nilclass_to_c(VALUE self)

- return rb_complex_new1(INT2FIX(0));

- * num.to_c -> complex

- * Returns the value as a complex.

-numeric_to_c(VALUE self)

- return rb_complex_new1(self);

-static VALUE comp_pat0, comp_pat1, comp_pat2, a_slash, a_dot_and_an_e,

- null_string, underscores_pat, an_underscore;

-#define DIGITS "(?:[0-9](?:_[0-9]|[0-9])*)"

-#define NUMERATOR "(?:" DIGITS "?\\.)?" DIGITS "(?:[eE][-+]?" DIGITS ")?"

-#define DENOMINATOR DIGITS

-#define NUMBER "[-+]?" NUMERATOR "(?:\\/" DENOMINATOR ")?"

-#define NUMBERNOS NUMERATOR "(?:\\/" DENOMINATOR ")?"

-#define PATTERN0 "\\A" WS "(" NUMBER ")@(" NUMBER ")" WS

-#define PATTERN1 "\\A" WS "([-+])?(" NUMBER ")?[iIjJ]" WS

-#define PATTERN2 "\\A" WS "(" NUMBER ")(([-+])(" NUMBERNOS ")?[iIjJ])?" WS

-make_patterns(void)

- static const char comp_pat0_source[] = PATTERN0;

- static const char comp_pat1_source[] = PATTERN1;

- static const char comp_pat2_source[] = PATTERN2;

- static const char underscores_pat_source[] = "_+";

- if (comp_pat0) return;

- comp_pat0 = rb_reg_new(comp_pat0_source, sizeof comp_pat0_source - 1, 0);

- rb_gc_register_mark_object(comp_pat0);

- comp_pat1 = rb_reg_new(comp_pat1_source, sizeof comp_pat1_source - 1, 0);

- rb_gc_register_mark_object(comp_pat1);

- comp_pat2 = rb_reg_new(comp_pat2_source, sizeof comp_pat2_source - 1, 0);

- rb_gc_register_mark_object(comp_pat2);

- a_slash = rb_usascii_str_new2("/");

- rb_gc_register_mark_object(a_slash);

- a_dot_and_an_e = rb_usascii_str_new2(".eE");

- rb_gc_register_mark_object(a_dot_and_an_e);

- null_string = rb_usascii_str_new2("");

- rb_gc_register_mark_object(null_string);

- underscores_pat = rb_reg_new(underscores_pat_source,

- sizeof underscores_pat_source - 1, 0);

- rb_gc_register_mark_object(underscores_pat);

- an_underscore = rb_usascii_str_new2("_");

- rb_gc_register_mark_object(an_underscore);

-#define id_match rb_intern("match")

-#define f_match(x,y) rb_funcall(x, id_match, 1, y)

-#define id_aref rb_intern("[]")

-#define f_aref(x,y) rb_funcall(x, id_aref, 1, y)

-#define id_post_match rb_intern("post_match")

-#define f_post_match(x) rb_funcall(x, id_post_match, 0)

-#define id_split rb_intern("split")

-#define f_split(x,y) rb_funcall(x, id_split, 1, y)

-#define id_include_p rb_intern("include?")

-#define f_include_p(x,y) rb_funcall(x, id_include_p, 1, y)

-#define id_count rb_intern("count")

-#define f_count(x,y) rb_funcall(x, id_count, 1, y)

-#define id_gsub_bang rb_intern("gsub!")

-#define f_gsub_bang(x,y,z) rb_funcall(x, id_gsub_bang, 2, y, z)

-string_to_c_internal(VALUE self)

- if (RSTRING_LEN(s) == 0)

- return rb_assoc_new(Qnil, self);

- VALUE m, sr, si, re, r, i;

- m = f_match(comp_pat0, s);

- sr = f_aref(m, INT2FIX(1));

- si = f_aref(m, INT2FIX(2));

- re = f_post_match(m);

- m = f_match(comp_pat1, s);

- si = f_aref(m, INT2FIX(1));

- si = rb_usascii_str_new2("");

- t = f_aref(m, INT2FIX(2));

- t = rb_usascii_str_new2("1");

- rb_str_concat(si, t);

- re = f_post_match(m);

- m = f_match(comp_pat2, s);

- return rb_assoc_new(Qnil, self);

- sr = f_aref(m, INT2FIX(1));

- if (NIL_P(f_aref(m, INT2FIX(2))))

- si = f_aref(m, INT2FIX(3));

- t = f_aref(m, INT2FIX(4));

- t = rb_usascii_str_new2("1");

- rb_str_concat(si, t);

- re = f_post_match(m);

- if (f_include_p(sr, a_slash))

- else if (f_gt_p(f_count(sr, a_dot_and_an_e), INT2FIX(0)))

- if (f_include_p(si, a_slash))

- else if (f_gt_p(f_count(si, a_dot_and_an_e), INT2FIX(0)))

- return rb_assoc_new(rb_complex_polar(r, i), re);

- return rb_assoc_new(rb_complex_new2(r, i), re);

-string_to_c_strict(VALUE self)

- VALUE a = string_to_c_internal(self);

- if (NIL_P(RARRAY_PTR(a)[0]) || RSTRING_LEN(RARRAY_PTR(a)[1]) > 0) {

- VALUE s = f_inspect(self);

- rb_raise(rb_eArgError, "invalid value for convert(): %s",

- StringValuePtr(s));

- return RARRAY_PTR(a)[0];

-#define id_gsub rb_intern("gsub")

-#define f_gsub(x,y,z) rb_funcall(x, id_gsub, 2, y, z)

- * str.to_c -> complex

- * Returns a complex which denotes the string form. The parser

- * ignores leading whitespaces and trailing garbage. Any digit

- * sequences can be separated by an underscore. Returns zero for null

- * or garbage string.

- * '9'.to_c #=> (9+0i)

- * '2.5'.to_c #=> (2.5+0i)

- * '2.5/1'.to_c #=> ((5/2)+0i)

- * '-3/2'.to_c #=> ((-3/2)+0i)

- * '-i'.to_c #=> (0-1i)

- * '45i'.to_c #=> (0+45i)

- * '3-4i'.to_c #=> (3-4i)

- * '-4e2-4e-2i'.to_c #=> (-400.0-0.04i)

- * '-0.0-0.0i'.to_c #=> (-0.0-0.0i)

- * '1/2+3/4i'.to_c #=> ((1/2)+(3/4)*i)

- * 'ruby'.to_c #=> (0+0i)

-string_to_c(VALUE self)

- VALUE s, a, backref;

- backref = rb_backref_get();

- rb_match_busy(backref);

- s = f_gsub(self, underscores_pat, an_underscore);

- a = string_to_c_internal(s);

- rb_backref_set(backref);

- if (!NIL_P(RARRAY_PTR(a)[0]))

- return RARRAY_PTR(a)[0];

- return rb_complex_new1(INT2FIX(0));

-nucomp_s_convert(int argc, VALUE *argv, VALUE klass)

- VALUE a1, a2, backref;

- rb_scan_args(argc, argv, "11", &a1, &a2);

- if (NIL_P(a1) || (argc == 2 && NIL_P(a2)))

- rb_raise(rb_eTypeError, "can't convert nil into Complex");

- backref = rb_backref_get();

- rb_match_busy(backref);

- switch (TYPE(a1)) {

- a1 = string_to_c_strict(a1);

- switch (TYPE(a2)) {

- a2 = string_to_c_strict(a2);

- rb_backref_set(backref);

- switch (TYPE(a1)) {

- if (k_exact_zero_p(dat->imag))

- switch (TYPE(a2)) {

- if (k_exact_zero_p(dat->imag))

- switch (TYPE(a1)) {

- if (argc == 1 || (k_exact_zero_p(a2)))

- if (k_numeric_p(a1) && !f_real_p(a1))

- /* expect raise exception for consistency */

- if (!k_numeric_p(a1))

- return rb_convert_type(a1, T_COMPLEX, "Complex", "to_c");

- if ((k_numeric_p(a1) && k_numeric_p(a2)) &&

- (!f_real_p(a1) || !f_real_p(a2)))

- f_complex_new_bang2(rb_cComplex, ZERO, ONE)));

- return nucomp_s_new(argc, argv2, klass);

- * num.real -> self

-numeric_real(VALUE self)

- * num.imaginary -> 0

-numeric_imag(VALUE self)

- return INT2FIX(0);

- * num.abs2 -> real

- * Returns square of self.

-numeric_abs2(VALUE self)

- return f_mul(self, self);

-#define id_PI rb_intern("PI")

- * num.arg -> 0 or float

- * num.angle -> 0 or float

- * num.phase -> 0 or float

- * Returns 0 if the value is positive, pi otherwise.

-numeric_arg(VALUE self)

- if (f_positive_p(self))

- return INT2FIX(0);

- return rb_const_get(rb_mMath, id_PI);

- * num.rect -> array

- * Returns an array; [num, 0].

-numeric_rect(VALUE self)

- return rb_assoc_new(self, INT2FIX(0));

- * num.polar -> array

- * Returns an array; [num.abs, num.arg].

-numeric_polar(VALUE self)

- return rb_assoc_new(f_abs(self), f_arg(self));

- * num.conj -> self

- * num.conjugate -> self

-numeric_conj(VALUE self)

- * flo.arg -> 0 or float

- * flo.angle -> 0 or float

- * flo.phase -> 0 or float

- * Returns 0 if the value is positive, pi otherwise.

-float_arg(VALUE self)

- if (isnan(RFLOAT_VALUE(self)))

- if (f_tpositive_p(self))

- return INT2FIX(0);

- return rb_const_get(rb_mMath, id_PI);

- * A complex number can be represented as a paired real number with

- * imaginary unit; a+bi. Where a is real part, b is imaginary part

- * and i is imaginary unit. Real a equals complex a+0i

- * In ruby, you can create complex object with Complex, Complex::rect,

- * Complex::polar or to_c method.

- * Complex(1) #=> (1+0i)

- * Complex(2, 3) #=> (2+3i)

- * Complex.polar(2, 3) #=> (-1.9799849932008908+0.2822400161197344i)

- * 3.to_c #=> (3+0i)

- * You can also create complex object from floating-point numbers or

- * Complex(0.3) #=> (0.3+0i)

- * Complex('0.3-0.5i') #=> (0.3-0.5i)

- * Complex('2/3+3/4i') #=> ((2/3)+(3/4)*i)

- * Complex('1@2') #=> (-0.4161468365471424+0.9092974268256817i)

- * 0.3.to_c #=> (0.3+0i)

- * '0.3-0.5i'.to_c #=> (0.3-0.5i)

- * '2/3+3/4i'.to_c #=> ((2/3)+(3/4)*i)

- * '1@2'.to_c #=> (-0.4161468365471424+0.9092974268256817i)

- * A complex object is either an exact or an inexact number.

- * Complex(1, 1) / 2 #=> ((1/2)+(1/2)*i)

- * Complex(1, 1) / 2.0 #=> (0.5+0.5i)

-#define rb_intern(str) rb_intern_const(str)

- assert(fprintf(stderr, "assert() is now active\n"));

- id_abs = rb_intern("abs");

- id_abs2 = rb_intern("abs2");

- id_arg = rb_intern("arg");

- id_cmp = rb_intern("<=>");

- id_conj = rb_intern("conj");

- id_convert = rb_intern("convert");

- id_denominator = rb_intern("denominator");

- id_divmod = rb_intern("divmod");

- id_eqeq_p = rb_intern("==");

- id_expt = rb_intern("**");

- id_fdiv = rb_intern("fdiv");

- id_floor = rb_intern("floor");

- id_idiv = rb_intern("div");

- id_imag = rb_intern("imag");

- id_inspect = rb_intern("inspect");

- id_negate = rb_intern("-@");

- id_numerator = rb_intern("numerator");

- id_quo = rb_intern("quo");

- id_real = rb_intern("real");

- id_real_p = rb_intern("real?");

- id_to_f = rb_intern("to_f");

- id_to_i = rb_intern("to_i");

- id_to_r = rb_intern("to_r");

- id_to_s = rb_intern("to_s");

- rb_cComplex = rb_define_class("Complex", rb_cNumeric);

- rb_define_alloc_func(rb_cComplex, nucomp_s_alloc);

- rb_undef_method(CLASS_OF(rb_cComplex), "allocate");

- rb_define_private_method(CLASS_OF(rb_cComplex), "new!", nucomp_s_new_bang, -1);

- rb_define_private_method(CLASS_OF(rb_cComplex), "new", nucomp_s_new, -1);

- rb_undef_method(CLASS_OF(rb_cComplex), "new");

- rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1);

- rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1);

- rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, -1);

- rb_define_global_function("Complex", nucomp_f_complex, -1);

- rb_undef_method(rb_cComplex, "%");

- rb_undef_method(rb_cComplex, "<");

- rb_undef_method(rb_cComplex, "<=");

- rb_undef_method(rb_cComplex, "<=>");

- rb_undef_method(rb_cComplex, ">");

- rb_undef_method(rb_cComplex, ">=");

- rb_undef_method(rb_cComplex, "between?");

- rb_undef_method(rb_cComplex, "div");

- rb_undef_method(rb_cComplex, "divmod");

- rb_undef_method(rb_cComplex, "floor");

- rb_undef_method(rb_cComplex, "ceil");

- rb_undef_method(rb_cComplex, "modulo");

- rb_undef_method(rb_cComplex, "remainder");

- rb_undef_method(rb_cComplex, "round");

- rb_undef_method(rb_cComplex, "step");

- rb_undef_method(rb_cComplex, "truncate");

- rb_undef_method(rb_cComplex, "i");

- rb_undef_method(rb_cComplex, "//");

- rb_define_method(rb_cComplex, "real", nucomp_real, 0);

- rb_define_method(rb_cComplex, "imaginary", nucomp_imag, 0);

- rb_define_method(rb_cComplex, "imag", nucomp_imag, 0);

- rb_define_method(rb_cComplex, "-@", nucomp_negate, 0);

- rb_define_method(rb_cComplex, "+", nucomp_add, 1);

- rb_define_method(rb_cComplex, "-", nucomp_sub, 1);

- rb_define_method(rb_cComplex, "*", nucomp_mul, 1);

- rb_define_method(rb_cComplex, "/", nucomp_div, 1);

- rb_define_method(rb_cComplex, "quo", nucomp_quo, 1);

- rb_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 1);

- rb_define_method(rb_cComplex, "**", nucomp_expt, 1);

- rb_define_method(rb_cComplex, "==", nucomp_eqeq_p, 1);

- rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1);

- rb_define_method(rb_cComplex, "abs", nucomp_abs, 0);

- rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 0);

- rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0);

- rb_define_method(rb_cComplex, "arg", nucomp_arg, 0);

- rb_define_method(rb_cComplex, "angle", nucomp_arg, 0);

- rb_define_method(rb_cComplex, "phase", nucomp_arg, 0);

- rb_define_method(rb_cComplex, "rectangular", nucomp_rect, 0);

- rb_define_method(rb_cComplex, "rect", nucomp_rect, 0);

- rb_define_method(rb_cComplex, "polar", nucomp_polar, 0);

- rb_define_method(rb_cComplex, "conjugate", nucomp_conj, 0);

- rb_define_method(rb_cComplex, "conj", nucomp_conj, 0);

- rb_define_method(rb_cComplex, "~", nucomp_conj, 0); /* gcc */

- rb_define_method(rb_cComplex, "real?", nucomp_false, 0);

- rb_define_method(rb_cComplex, "complex?", nucomp_true, 0);

- rb_define_method(rb_cComplex, "exact?", nucomp_exact_p, 0);

- rb_define_method(rb_cComplex, "inexact?", nucomp_inexact_p, 0);

- rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0);

- rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0);

- rb_define_method(rb_cComplex, "hash", nucomp_hash, 0);

- rb_define_method(rb_cComplex, "eql?", nucomp_eql_p, 1);

- rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0);

- rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0);

- rb_define_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0);

- rb_define_method(rb_cComplex, "marshal_load", nucomp_marshal_load, 1);

- rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0);

- rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0);

- rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0);

- rb_define_method(rb_cComplex, "rationalize", nucomp_rationalize, -1);

- rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0);

- rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0);

- rb_define_method(rb_cString, "to_c", string_to_c, 0);

- rb_define_private_method(CLASS_OF(rb_cComplex), "convert", nucomp_s_convert, -1);

- rb_define_method(rb_cNumeric, "real", numeric_real, 0);

- rb_define_method(rb_cNumeric, "imaginary", numeric_imag, 0);

- rb_define_method(rb_cNumeric, "imag", numeric_imag, 0);

- rb_define_method(rb_cNumeric, "abs2", numeric_abs2, 0);

- rb_define_method(rb_cNumeric, "arg", numeric_arg, 0);

- rb_define_method(rb_cNumeric, "angle", numeric_arg, 0);

- rb_define_method(rb_cNumeric, "phase", numeric_arg, 0);

- rb_define_method(rb_cNumeric, "rectangular", numeric_rect, 0);

- rb_define_method(rb_cNumeric, "rect", numeric_rect, 0);

- rb_define_method(rb_cNumeric, "polar", numeric_polar, 0);

- rb_define_method(rb_cNumeric, "conjugate", numeric_conj, 0);

- rb_define_method(rb_cNumeric, "conj", numeric_conj, 0);

- rb_define_method(rb_cFloat, "arg", float_arg, 0);

- rb_define_method(rb_cFloat, "angle", float_arg, 0);

- rb_define_method(rb_cFloat, "phase", float_arg, 0);

- rb_define_const(rb_cComplex, "I",

- f_complex_new_bang2(rb_cComplex, ZERO, ONE));

-c-file-style: "ruby"

-AC_CONFIG_AUX_DIR(tool)

-AC_DEFUN([RUBY_PREREQ_AC],

- [m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [$1]), [-1],

- AC_MSG_ERROR([Autoconf version ]$1[ or higher is required]$2))])

-dnl environment section {

-AC_ARG_WITH(baseruby,

- AS_HELP_STRING([--with-baseruby=RUBY], [use RUBY as baseruby; RUBY is the pathname of ruby]),

- AS_CASE(["$withval"],[*ruby*],[BASERUBY=$withval],[AC_MSG_ERROR(need ruby)])

-test "`RUBYOPT=- $BASERUBY -e 'p 42' 2>/dev/null`" = 42 ||

- BASERUBY="echo executable host ruby is required. use --with-baseruby option.; false"

-AC_DEFUN([RUBY_MINGW32],

-[AS_CASE(["$host_os"],

-AS_CASE(["$target_os"], [mingw*msvc], [

-target_os="`echo ${target_os} | sed 's/msvc$//'`"

-AC_DEFUN([RUBY_CPPOUTFILE],

-AC_DEFUN([RUBY_PROG_GNU_LD],

-eval `sed -n 's/^#define RUBY_VERSION_$[A-Z][A-Z_0-9]*$ $[0-9][0-9]*$/\1=\2/p' $srcdir/version.h`

-for v in MAJOR MINOR TEENY; do

- if eval "test \"\$$v\" = ''"; then

- AC_MSG_ERROR(could not determine $v number from version.h)

-RUBY_PROGRAM_VERSION=`sed -n 's/^#define RUBY_VERSION "$.*$"/\1/p' $srcdir/version.h`

-AC_SUBST(RUBY_PROGRAM_VERSION)

-RUBY_RELEASE_DATE=`sed -n 's/^#define RUBY_RELEASE_DATE "$.*$"/\1/p' $srcdir/version.h`

-AC_SUBST(RUBY_RELEASE_DATE)

-if test "$MAJOR" = "1"; then

- AC_DEFINE(CANONICALIZATION_FOR_MATHN)

- AS_HELP_STRING([--without-gcc], [never use gcc]),

- AS_CASE([$withval],

- [no], [: ${CC=cc}],

- [yes], [: ${CC=gcc}],

-test -z "$CC" || ac_cv_prog_CC="$CC"

-RUBY_BASE_NAME=`echo ruby | sed "$program_transform_name"`

-RUBYW_BASE_NAME=`echo rubyw | sed "$program_transform_name"`

-AC_SUBST(RUBY_BASE_NAME)

-AC_SUBST(RUBYW_BASE_NAME)

-target_os=`echo $target_os | sed 's/linux-gnu$/linux/;s/linux-gnu/linux-/'`

-ac_install_sh='' # unusable for extension libraries.

-AC_DEFUN([RUBY_APPEND_OPTION],

- [# RUBY_APPEND_OPTION($1, $2)

- AS_CASE([" [$]{$1-} "],

- [*' $2 '*], [], [' '], [ $1="$2"], [ $1="[$]$1 $2"])])

-AC_DEFUN([RUBY_APPEND_OPTIONS],

- [{ for rb_opt in $2; do # RUBY_APPEND_OPTIONS($1, $2)

- AS_CASE([" [$]{$1-} "],

- [*" [$]{rb_opt} "*], [], [' '], [ $1="[$]{rb_opt}"], [ $1="[$]$1 [$]{rb_opt}"])

-AC_DEFUN([RUBY_PREPEND_OPTION],

- [# RUBY_PREPEND_OPTION($1, $2)

- AS_CASE([" [$]{$1-} "],

- [*' $2 '*], [], [' '], [ $1="$2"], [ $1="$2 [$]$1"])])

-AC_DEFUN([RUBY_PREPEND_OPTIONS],

- [{ unset rb_opts; for rb_opt in $2; do # RUBY_PREPEND_OPTIONS($1, $2)

- AS_CASE([" [$]{rb_opts} [$]{$1-} "],

- [*" [$]{rb_opt} "*], [], [' '], [ $1="[$]{rb_opt}"], [ rb_opts="[$]{rb_opts}[$]{rb_opt} "])

- $1="[$]{rb_opts}[$]$1"; }])

- AS_HELP_STRING([--with-arch=ARCHS],

- [build an Apple/NeXT Multi Architecture Binary (MAB);

- which to build; if this option is disabled or omitted

- entirely, then the package will be built only for the

- target platform]),

- [target_archs="$withval"], [unset target_archs])

-AC_DEFUN([RUBY_DEFAULT_ARCH], [

-AC_MSG_CHECKING([arch option])

- [*64], [ARCH_FLAG=-m64],

- [[i[3-6]86]], [ARCH_FLAG=-m32],

- [AC_MSG_ERROR(unknown target architecture: $target_archs)]

-AC_MSG_RESULT([$ARCH_FLAG])

-AC_DEFUN([RUBY_UNIVERSAL_ARCH], [

-# RUBY_UNIVERSAL_ARCH begin

-test ${CFLAGS+set} && CFLAGS=`echo "$CFLAGS" | sed -e 's/ *-arch *[^ ]*//g' -e 's/ *-m32//g' -e 's/ *-m64//g'`

-test ${LDFLAGS+set} && LDFLAGS=`echo "$LDFLAGS" | sed 's/ *-arch *[^ ]*//g' -e 's/ *-m32//g' -e 's/ *-m64//g'`

-unset ARCH_FLAG universal_binary universal_archnames

-if test ${target_archs+set}; then

- target_archs=`echo $target_archs | tr , ' '`

- for archs in $target_archs

- AS_CASE([",$universal_binary,"],[*",$archs,"*], [],[

- cpu=`$SHELL "$ac_aux_dir/config.sub" "${archs}-${target_os}" 2>&1` || {

- AC_MSG_RESULT([failed])

- AC_MSG_ERROR([$cpu])

- cpu=`echo $cpu | sed 's/-.*-.*//'`

- universal_binary="${universal_binary+$universal_binary,}$cpu"

- universal_archnames="${universal_archnames} ${archs}=${cpu}"

- ARCH_FLAG="${ARCH_FLAG+$ARCH_FLAG }-arch $archs"

- target_archs="$universal_binary"

- unset universal_binary

- AS_CASE(["$target_archs"],

- [*,*], [universal_binary=yes],

- [unset universal_archnames])

- AC_MSG_RESULT([$target_archs])

- target=`echo $target | sed "s/^$target_cpu-/-/"`

- target_alias=`echo $target_alias | sed "s/^$target_cpu-/-/"`

- if test "${universal_binary-no}" = yes; then

- RUBY_PREREQ_AC(2.63, [ to compile universal binary])

- AC_SUBST(try_header,try_compile)

- target_cpu=universal

- real_cross_compiling=$cross_compiling

- if test x"$target_cpu" != x"${target_archs}"; then

- echo 'int main(){return 0;}' > conftest.c

- if $CC $CFLAGS $ARCH_FLAG conftest.c > /dev/null 2>&1; then

- rm -f conftest.* a.out

- RUBY_DEFAULT_ARCH("$target_archs")

- target_cpu=${target_archs}

- AS_CASE(["$target"], [-*], [ target="$target_cpu${target}"])

- AS_CASE(["$target_alias"], [-*], [ target_alias="$target_cpu${target_alias}"])

- CFLAGS="$CFLAGS ${ARCH_FLAG}"

- LDFLAGS="${LDFLAGS+$LDFLAGS }${ARCH_FLAG}"

- if test x"$target_alias" = x; then

- AS_CASE(["$target_os"],

- AC_MSG_CHECKING([for real target cpu])

- target=`echo $target | sed "s/^$target_cpu-/-/"`

- target_cpu=`$CC -E - 2>/dev/null <<EOF |

-"processor-name=x86_64"

-"processor-name=i386"

-"processor-name=powerpc"

-"processor-name=powerpc64"

- sed -n 's/^"processor-name=$.*$"/\1/p'`

- target="$target_cpu${target}"

- AC_MSG_RESULT([$target_cpu])

- target_archs="$target_cpu"

-if test "${target_archs}" != "${rb_cv_target_archs-${target_archs}}"; then

- AC_MSG_ERROR([target arch(s) has changed from ${rb_cv_target_archs-nothing} to ${target_archs}])

- rb_cv_target_archs=${target_archs}

-# RUBY_UNIVERSAL_ARCH end

-AC_ARG_ENABLE(load-relative,

- AS_HELP_STRING([--enable-load-relative], [resolve load paths at run time]),

- [load_relative=$enableval])

-test -z "$optflags" ||

- cflagspat="$cflagspat;s|"`eval echo '"'"${optflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g'

-test -z "$debugflags" ||

- cflagspat="$cflagspat;s|"`eval echo '"'"${debugflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g'

-test -z "warnflags" ||

- cflagspat="$cflagspat;s|"`eval echo '"'"${warnflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g'

-if test -z "${CFLAGS+set}"; then

- cflags=`echo " $cflags " | sed "$cflagspat;s/^ *//;s/ *$//"`

- orig_cflags="$cflags"

- cflags="$cflags "'${optflags} ${debugflags} ${warnflags}'

-if test -z "${CXXFLAGS+set}"; then

- cxxflags=`echo " $cxxflags " | sed "$cflagspat;s/^ *//;s/ *$//"`

- orig_cxxflags="$cxxflags"

- cxxflags="$cxxflags "'${optflags} ${debugflags} ${warnflags}'

-if test "$GCC" = yes; then

- AS_CASE(["$target_os"], [linux*|darwin*], [: ${debugflags=-ggdb}])

-test $ac_cv_prog_cc_g = yes && : ${debugflags=-g}

-: ${COUTFLAG=${OUTFLAG}}

-RUBY_UNIVERSAL_ARCH

-if test "$target_cpu" != "$host_cpu" -a "$GCC" = yes -a "$cross_compiling" = no -a "$universal_binary" = no; then

- RUBY_DEFAULT_ARCH("$target_cpu")

-AC_CHECK_TOOL(AS, as)

-AS_CASE(["$target_os"],[cygwin*|mingw*|darwin*], [ac_cv_prog_ac_ct_OBJCOPY=":"])

-# BSD's ports and MacPorts prefix GNU binutils with 'g'

-AC_CHECK_TOOLS(OBJDUMP, [objdump gobjdump])

-AC_CHECK_TOOLS(OBJCOPY, [objcopy gobjcopy])

-AS_CASE(["$target_os"],

-[cygwin*|mingw*], [

- target=`echo $target | sed "s/^$target_cpu-/-/"`

- target_alias=`echo $target_alias | sed "s/^$target_cpu-/-/"`

- AS_CASE(["$target"], [-*], [ target="$target_cpu${target}"])

- AS_CASE(["$target_alias"], [-*], [ target_alias="$target_cpu${target_alias}"])

- AS_CASE(["$target_os"],

- test "$rb_cv_msvcrt" = "" && unset rb_cv_msvcrt

- AC_CACHE_CHECK(for mingw32 runtime DLL, rb_cv_msvcrt, [

- AC_TRY_LINK([@%:@include <stdio.h>],

- [FILE* volatile f = stdin; return 0;],

- [rb_cv_msvcrt=`$OBJDUMP -p conftest$ac_exeext |

- sed -n '/^[[ ]]*dll name: $msvc.*$\.dll$/{s//\1/p;q;}'`],

- [rb_cv_msvcrt=msvcrt])

- test "$rb_cv_msvcrt" = "" && rb_cv_msvcrt=msvcrt])

-[aix*], [AC_CHECK_TOOL(NM, nm, /usr/ccs/bin/nm, /usr/ccs/bin:$PATH)],

-[hiuxmpp*], [AC_DEFINE(__HIUX_MPP__)]) # by TOYODA Eizi <toyoda@npd.kishou.go.jp>

-if test "x$MKDIR_P" = "x -d"; then

- if test x"$as_mkdir_p" != xfalse; then

- MKDIR_P='mkdir -p'

- echo "use 'mkdir -p' as MKDIR_P"

- AC_MSG_ERROR([mkdir -p is required])

-MAKEDIRS="$MKDIR_P"

-AC_CHECK_TOOL(DOT, dot)

-AC_CHECK_TOOL(DOXYGEN, doxygen)

-if test x"$DOXYGEN" = x; then

-AC_SUBST(CAPITARGET)

-AC_USE_SYSTEM_EXTENSIONS

-AC_SUBST(RM, ['rm -f'])

-AC_SUBST(CP, ['cp'])

-AC_SUBST(RMDIRS, ['$(top_srcdir)/tool/rmdirs'])

-AC_SUBST(RMALL, ['rm -fr'])

-AC_MSG_CHECKING([for cd using phisical directory])

-mkdir conf$$.dir &&

-(cd conf$$.dir && mkdir src build && cd src &&

-$as_ln_s ../build . > /dev/null 2>&1 && cd build &&

-for chdir in 'cd -P' 'PWD= cd'; do

- /bin/sh -c "$chdir ../src && echo '$chdir' > cdcmd" 2> /dev/null && break

-if test -e conf$$.dir/src/cdcmd; then

- read CHDIR < conf$$.dir/src/cdcmd 2> /dev/null

-AC_MSG_RESULT([$CHDIR])

-dnl compiler section {

-AC_DEFUN(RUBY_TRY_CFLAGS, [

- save_CFLAGS="$CFLAGS"

- CFLAGS="[$]CFLAGS $1"

- AC_MSG_CHECKING([whether ]$1[ is accepted])

- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],

- AC_MSG_RESULT(yes)],

- AC_MSG_RESULT(no)])

- CFLAGS="$save_CFLAGS"

-if test "$GCC:${warnflags+set}:no" = yes::no; then

- for wflag in -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings \

- -Wno-missing-field-initializers -Wshorten-64-to-32 -Wno-long-long; do

- RUBY_TRY_CFLAGS($wflag, [warnflags="${warnflags+$warnflags }$wflag"])

- AS_CASE([" $warnflags "],[*" -Wno-missing-field-initializers "*], [wflag=-Wextra],

- RUBY_TRY_CFLAGS($wflag, [warnflags="$wflag${warnflags+ $warnflags}"])

-test -z "${ac_env_CFLAGS_set}" -a -n "${cflags+set}" && eval CFLAGS="\"$cflags $ARCH_FLAG\""

-test -z "${ac_env_CXXFLAGS_set}" -a -n "${cxxflags+set}" && eval CXXFLAGS="\"$cxxflags $ARCH_FLAG\""

-mv confdefs.h confdefs1.h

-mv confdefs.h largefile.h

-mv confdefs1.h confdefs.h

-cat largefile.h >> confdefs.h

-AS_CASE(["$target_os"],[mingw*], [ac_cv_type_off_t=yes;ac_cv_sizeof_off_t=8])

-AC_CACHE_CHECK([char bit], [rb_cv_char_bit],

- [test "$universal_binary" = yes && cross_compiling=yes

- AC_COMPUTE_INT([rb_cv_char_bit], [CHAR_BIT],

- [AC_INCLUDES_DEFAULT([@%:@include <limits.h>])], [rb_cv_char_bit=8])

- test "$universal_binary" = yes && cross_compiling=$real_cross_compiling])

-dnl RUBY_CHECK_SIZEOF [typename], [maybe same size types], [macros], [include]

-AC_DEFUN([RUBY_CHECK_SIZEOF],

-[m4_bmatch([$1], [\.], [], [if test "$universal_binary" = yes; then])

-AC_CACHE_CHECK([size of $1], [AS_TR_SH([ac_cv_sizeof_$1])], [

- unset AS_TR_SH(ac_cv_sizeof_$1)

-typedef m4_bpatsubst([$1], [\..*]) ac__type_sizeof_;

-static ac__type_sizeof_ *rbcv_ptr;

-@%:@define AS_TR_CPP(SIZEOF_$1) sizeof((*rbcv_ptr)[]m4_bmatch([$1], [\.], .m4_bpatsubst([$1], [^[^.]*\.])))

- m4_ifval([$2], [test -z "${AS_TR_SH(ac_cv_sizeof_$1)+set}" && {

- AC_COMPILE_IFELSE(

- [AC_LANG_BOOL_COMPILE_TRY(AC_INCLUDES_DEFAULT([$4]

- [AS_TR_CPP(SIZEOF_$1) == sizeof($t)])], [

- AS_TR_SH(ac_cv_sizeof_$1)=AS_TR_CPP([SIZEOF_]$t)

- m4_ifval([$3], [test -z "${AS_TR_SH(ac_cv_sizeof_$1)+set}" && {

- for s in 32 64 128; do

-@%:@${cond+el}if defined(__${t}${s}__) || defined(__${t}${s}) || defined(_${t}${s}) || defined(${t}${s})"

- hdr="AC_INCLUDES_DEFAULT([$4

-@%:@if defined(__${t}${s}__) || defined(__${t}${s}) || defined(_${t}${s}) || defined(${t}${s})

-@%:@ define AS_TR_CPP(HAVE_$1) 1

-@%:@ define AS_TR_CPP(HAVE_$1) 0

- AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$hdr], [!AS_TR_CPP(HAVE_$1)])], [continue])

- AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$hdr]

- [AS_TR_CPP(HAVE_$1) == (AS_TR_CPP(SIZEOF_$1) == ([$[s / rb_cv_char_bit]]))])],

- [AS_TR_SH(ac_cv_sizeof_$1)="${AS_TR_SH(ac_cv_sizeof_$1)+${AS_TR_SH(ac_cv_sizeof_$1)-} }${t}${s}"])

- m4_ifval([$2][$3], [case "${AS_TR_SH(ac_cv_sizeof_$1)}" in

- test "$universal_binary" = yes && cross_compiling=yes

- AC_COMPUTE_INT([t], AS_TR_CPP(SIZEOF_$1), [AC_INCLUDES_DEFAULT([$4])]

-@%:@ifndef AS_TR_CPP(SIZEOF_$1)

-@%:@define AS_TR_CPP(SIZEOF_$1) 0

- test "$universal_binary" = yes && cross_compiling=$real_cross_compiling

- if test ${t-0} != 0; then

- AS_TR_SH(ac_cv_sizeof_$1)="${AS_TR_SH(ac_cv_sizeof_$1)+${AS_TR_SH(ac_cv_sizeof_$1)-} }${t}"

- m4_ifval([$2][$3], [;; esac])

- : ${AS_TR_SH(ac_cv_sizeof_$1)=0}

- for t in ${AS_TR_SH(ac_cv_sizeof_$1)-}; do

- [[[0-9]*|SIZEOF_*]], [

- ${cond+echo "@%:@else"}

- echo "[@%:@define ]AS_TR_CPP(SIZEOF_$1) [$t]"

- s=`expr $t : ['.*[^0-9]$[0-9][0-9]*$$']`

- echo "@%:@${cond+el}if defined(__${t}__) || defined(__${t}) || defined(_${t}) || defined($t)"

- echo "@%:@define AS_TR_CPP(SIZEOF_$1) [$[s / rb_cv_char_bit]]"

- ${cond+echo "@%:@endif"}

-m4_bmatch([$1], [\.], [], [else

-AC_CHECK_SIZEOF([$1], 0, [$4])

-RUBY_CHECK_SIZEOF(int, [], [ILP])

-RUBY_CHECK_SIZEOF(short)

-RUBY_CHECK_SIZEOF(long, [int], [ILP LP])

-RUBY_CHECK_SIZEOF(long long)

-RUBY_CHECK_SIZEOF(__int64)

-RUBY_CHECK_SIZEOF(off_t)

-RUBY_CHECK_SIZEOF(void*, [int long "long long"], [ILP LP LLP])

-RUBY_CHECK_SIZEOF(float)

-RUBY_CHECK_SIZEOF(double)

-RUBY_CHECK_SIZEOF(time_t, [long "long long"], [], [@%:@include <time.h>])

-dnl RUBY_REPLACE_TYPE [typename] [default type] [macro type] [included]

-AC_DEFUN([RUBY_REPLACE_TYPE], [dnl

- AC_CHECK_TYPE([$1], [n=[$1]], [n=[$2]], [$4])

- AC_CACHE_CHECK([for convertible type of [$1]], rb_cv_[$1]_convertible, [

- [*" signed "*], [ ],

- [*" unsigned "*], [

- AC_COMPILE_IFELSE(

- [AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([$4])], [($n)-1 > 0])],

- if test x"$t" = x; then

- for t in "long long" long int short; do

- test -n "$u" && t="unsigned $t"

- AC_COMPILE_IFELSE(

- [AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([$4])]

- [typedef $n rbcv_conftest_target_type;

- typedef $t rbcv_conftest_replace_type;

- extern rbcv_conftest_target_type rbcv_conftest_var;

- extern rbcv_conftest_replace_type rbcv_conftest_var;

- extern rbcv_conftest_target_type rbcv_conftest_func(void);

- extern rbcv_conftest_replace_type rbcv_conftest_func(void);

- ], [sizeof(rbcv_conftest_target_type) == sizeof(rbcv_conftest_replace_type)])],

- [*" long long "*], [

- rb_cv_[$1]_convertible=${u}${t}])

- test "${AS_TR_SH(ac_cv_type_[$1])}" = "yes" && n="$1"

- AC_DEFINE_UNQUOTED(rb_[$1], $n)

- AC_DEFINE_UNQUOTED([$3]2NUM[(v)], [${rb_cv_[$1]_convertible}2NUM(v)])

- AC_DEFINE_UNQUOTED(NUM2[$3][(v)], [NUM2${rb_cv_[$1]_convertible}(v)])

- AC_DEFINE_UNQUOTED(PRI_[$3]_PREFIX,

- ["`echo ${rb_cv_[$1]_convertible} | sed ['s/^U//;s/[^L].*//;y/L/l/']`"])

-RUBY_REPLACE_TYPE(pid_t, int, PIDT)

-RUBY_REPLACE_TYPE(uid_t, int, UIDT)

-RUBY_REPLACE_TYPE(gid_t, int, GIDT)

-RUBY_REPLACE_TYPE(time_t, [], TIMET, [@%:@include <time.h>])

-AC_CACHE_CHECK(stringization, rb_cv_stringization, [

- rb_cv_stringization=no

- for string in "#expr" '"expr"'; do

- AC_COMPILE_IFELSE([

- AC_LANG_BOOL_COMPILE_TRY([

-#define STRINGIZE0(expr) $string

-#define STRINGIZE(expr) STRINGIZE0(expr)

-#undef real_test_for_stringization

-#define test_for_stringization -.real_test_for_stringization.-

-const char stringized[[]] = STRINGIZE(test_for_stringization);

-], [sizeof(stringized) == 32])],

- [rb_cv_stringization="$string"; break],

- [rb_cv_stringization=no])

-AC_DEFINE(STRINGIZE(expr),STRINGIZE0(expr))

-if test x"$rb_cv_stringization" != xno -a "$rb_cv_stringization" != "#expr"; then

- AC_DEFINE_UNQUOTED(STRINGIZE0(expr),$rb_cv_stringization)

- AC_DEFINE(OLD_FASHIONED_STRINGIZATION,1)

-AC_CACHE_CHECK([string literal concatenation],

- rb_cv_string_literal_concatenation, [

- AC_COMPILE_IFELSE([

- AC_LANG_BOOL_COMPILE_TRY([

-const char concatenated_literal[[]] = "literals" "to"

- "be" "concatenated.";

-], [sizeof(concatenated_literal) == 26])],

- [rb_cv_string_literal_concatenation=yes],

- [rb_cv_string_literal_concatenation=no])]

-if test "$rb_cv_string_literal_concatenation" = no; then

- AC_DEFINE(NO_STRING_LITERAL_CONCATENATION,1)

-AC_CACHE_CHECK(for variable length macro, rb_cv_va_args_macro,

- [AC_TRY_COMPILE([@%:@define FOO(a, ...) foo(a, @%:@@%:@__VA_ARGS__)],

- [FOO(1);FOO(1,2);FOO(1,2,3);],

- rb_cv_va_args_macro=yes,

- rb_cv_va_args_macro=no)])

-if test "$rb_cv_va_args_macro" = yes; then

- AC_DEFINE(HAVE_VA_ARGS_MACRO)

-AC_DEFUN([RUBY_DEFINE_IF], [dnl

- m4_ifval([$1],[test "$1" && cat <<EOH >> confdefs.h

-AC_DEFINE_UNQUOTED($2, $3)

- m4_ifval([$1],[test "$1" && cat <<EOH >> confdefs.h

-AC_DEFUN([RUBY_FUNC_ATTRIBUTE], [dnl

- [AS_VAR_PUSHDEF([attrib],[$2])], dnl

- [AS_VAR_PUSHDEF([attrib],[FUNC_]AS_TR_CPP($1))] dnl

- [AS_VAR_PUSHDEF([rbcv],[$3])], dnl

- [AS_VAR_PUSHDEF([rbcv],[rb_cv_func_][$1])]dnl

-m4_ifval([$4], [rbcv_cond=[$4]; test "$rbcv_cond" || unset rbcv_cond])

-AC_CACHE_CHECK(for [$1] function attribute, rbcv,

-if test "${ac_c_werror_flag+set}"; then

- rb_c_werror_flag="$ac_c_werror_flag"

- unset rb_c_werror_flag

-ac_c_werror_flag=yes

-for mac in "__attribute__ (($1)) x" "x __attribute__ (($1))" "__declspec($1) x" x; do

- m4_ifval([$4],mac="$mac"${rbcv_cond+" /* only if $rbcv_cond */"})

- m4_ifval([$4],${rbcv_cond+[@%:@if ]$rbcv_cond})

-[@%:@define ]attrib[(x) $mac]

-m4_ifval([$4],${rbcv_cond+[@%:@else]}

-${rbcv_cond+[@%:@define ]attrib[(x) x]}

-${rbcv_cond+[@%:@endif]})

- attrib[(void conftest_attribute_check(void));], [],

- [rbcv="$mac"; break])

-if test "${rb_c_werror_flag+set}"; then

- ac_c_werror_flag="$rb_c_werror_flag"

- unset ac_c_werror_flag

-if test "$rbcv" != x; then

- RUBY_DEFINE_IF([${rbcv_cond}], attrib[(x)], $rbcv)

-AS_VAR_POPDEF([attrib])

-AS_VAR_POPDEF([rbcv])

-RUBY_FUNC_ATTRIBUTE(noreturn, NORETURN)

-RUBY_FUNC_ATTRIBUTE(deprecated, DEPRECATED)

-RUBY_FUNC_ATTRIBUTE(noinline, NOINLINE)

-if_i386=${universal_binary+[defined __i386__]}

-RUBY_FUNC_ATTRIBUTE(stdcall, [], [], ${if_i386})

-RUBY_FUNC_ATTRIBUTE(cdecl, [], [], ${if_i386})

-RUBY_FUNC_ATTRIBUTE(fastcall, [], [], ${if_i386})

-if test "$GCC" = yes; then

- AC_CACHE_CHECK([for function alias], [rb_cv_gcc_function_alias],

- [rb_cv_gcc_function_alias=no

- for a in alias weak,alias; do

- AC_TRY_LINK([void foo(void) {}

- void bar(void) __attribute__(($a("foo")));], [bar()],

- [rb_cv_gcc_function_alias=$a; break])

- if test "$rb_cv_gcc_function_alias" != no; then

- AC_DEFINE_UNQUOTED([RUBY_ALIAS_FUNCTION_TYPE(type, prot, name, args)],

- [type prot __attribute__(($rb_cv_gcc_function_alias(@%:@name)));])

- AC_DEFINE_UNQUOTED([RUBY_ALIAS_FUNCTION_VOID(prot, name, args)],

- [RUBY_ALIAS_FUNCTION_TYPE(void, prot, name, args)])

-AC_CACHE_CHECK([for RUBY_EXTERN], rb_cv_ruby_extern,

-[rb_cv_ruby_extern=no

-for mac in "__attribute__((dllimport))" "__declspec(dllimport)"; do

- [extern $mac void conftest(void);],

- [rb_cv_ruby_extern="extern $mac"; break])

-test "x$rb_cv_ruby_extern" = xno || AC_DEFINE_UNQUOTED(RUBY_EXTERN, $rb_cv_ruby_extern)

-RUBY_APPEND_OPTION(XCFLAGS, -DRUBY_EXPORT)

-dnl header and library section {

-AC_ARG_ENABLE(win95,

- AS_HELP_STRING([--enable-win95], [enable Windows 95 series support]),

- [AS_CASE(["$enableval"],[yes|no],[enable_win95=$enableval],[unset enable_win95])])

-AS_CASE(["$target_os"],

- AC_CACHE_CHECK([whether pthread should be enabled by default],

- rb_cv_enable_pthread_default,

-#include <osreldate.h>

-#if __FreeBSD_version < 502102

-#error pthread should be disabled on this platform

- rb_cv_enable_pthread_default=yes,

- rb_cv_enable_pthread_default=no)])

- enable_pthread=$rb_cv_enable_pthread_default

- enable_pthread=yes

- AS_HELP_STRING([--enable-pthread], [obsolete, and ignored]))

-AS_CASE(["$target_os"],[*bsd*|dragonfly*],[],[ac_cv_func_daemon=no])

-AS_CASE(["$target_os"],

- AC_DEFINE(SIZEOF_STRUCT_DIRENT_TOO_SMALL, 1)

-[darwin*], [ RUBY_PREPEND_OPTION(LIBS, -lobjc)

- RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE)

- AC_MSG_CHECKING(whether Mac OS X 10.5 or later)

- AC_TRY_CPP([#include <AvailabilityMacros.h>

- #if MAC_OS_X_VERSION_MAX_ALLOWED <= 1040

- #error pre OS X 10.4

- [!<===== pre OS X 10.4 =====>]

- [macosx_10_5=yes], [macosx_10_5=no])

- AC_MSG_RESULT($macosx_10_5)

- if test $macosx_10_5 = yes; then

- ac_cv_header_ucontext_h=no

- AC_DEFINE(BROKEN_SETREUID, 1)

- AC_DEFINE(BROKEN_SETREGID, 1)

- ac_cv_type_getgroups=gid_t # getgroups() on Rosetta fills garbage

- ac_cv_lib_crypt_crypt=no

- AC_CACHE_CHECK(for broken crypt with 8bit chars, rb_cv_broken_crypt,

-#include <unistd.h>

-#include <string.h>

- for (i = 0; i < 128*128; i++) {

- char salt[2], buf[256], *s;

- salt[0] = 0x80 | (i & 0x7f);

- salt[1] = 0x80 | (i >> 7);

- strcpy(buf, crypt("", salt));

- if (strcmp(buf, s = crypt("", salt))) {

- printf("%.2x%.2x: %s -> %s\n", (unsigned char)salt[0], (unsigned char)salt[1],

- rb_cv_broken_crypt=no,

- rb_cv_broken_crypt=yes,

- rb_cv_broken_crypt=yes)])

- if test "$rb_cv_broken_crypt" = yes; then

- AC_DEFINE(BROKEN_CRYPT, 1)

-[hpux*], [ LIBS="-lm $LIBS"

- ac_cv_c_inline=no],

-[human*], [ ac_cv_func_getpgrp_void=yes

- AC_CHECK_LIB(signal, _harderr)

- AC_CHECK_LIB(hmem, hmemset)

- AC_CHECK_FUNCS(select)

- AC_CACHE_CHECK(whether PD libc _dtos18 fail to convert big number,

- rb_cv_missing__dtos18,

- sprintf(buf, "%g", 1e+300);

- return (strcmp (buf, "1e+300") ? 0 : 1);

- rb_cv_missing__dtos18=yes, rb_cv_missing__dtos18=no, rb_cv_missing__dtos18=no)])

- if test "$rb_cv_missing__dtos18" = yes; then

- AC_DEFINE(MISSING__DTOS18)

- AC_CACHE_CHECK(whether PD libc fconvert fail to round,

- rb_cv_missing_fconvert,

- sprintf(buf, "%f", log(exp(1.0)));

- return (strcmp (buf, "1.000000") ? 0 : 1);

- rb_cv_missing_fconvert=yes, rb_cv_missing_fconvert=no, rb_cv_missing_fconvert=no)])

- if test "$rb_cv_missing_fconvert" = yes; then

- AC_DEFINE(MISSING_FCONVERT)

- ac_cv_func_link=no

- ac_cv_func_sched_yield=no

- ac_cv_func_pthread_attr_setinheritsched=no

- AS_CASE(["$target_os"],

- [beos*], [ ac_cv_header_net_socket_h=yes],

- [haiku*], [ ac_cv_func_shutdown=no])

- LIBS="$LIBS" # m lib is include in root under BeOS/Haiku

-[cygwin*], [ ac_cv_header_langinfo_h=yes

- AC_LIBOBJ([langinfo])

-[mingw*], [ LIBS="-lshell32 -lws2_32 $LIBS"

- ac_cv_header_sys_time_h=no

- ac_cv_header_sys_socket_h=no

- ac_cv_func_link=yes

- ac_cv_func_truncate=yes

- ac_cv_func_fseeko=yes

- ac_cv_func_ftello=yes

- ac_cv_func_getpgrp_void=no

- ac_cv_func_setpgrp_void=yes

- ac_cv_func_memcmp_working=yes

- ac_cv_lib_dl_dlopen=no

- rb_cv_binary_elf=no

- rb_cv_negative_time_t=no

- ac_cv_func_fcntl=yes

- ac_cv_func_flock=yes

- rb_cv_large_fd_select=yes

- AC_LIBOBJ([langinfo])

- : ${enable_win95=maybe}

-[os2-emx*], [ LIBS="-lm $LIBS"

- ac_cv_lib_dir_opendir=no],

- ac_cv_sizeof_rlim_t=4

- ac_cv_func_fork=no

- ac_cv_func_setrlimit=no

- ac_cv_header_sys_socket_h=no

-[bsdi*], [ LIBS="-lm $LIBS"

- AC_DEFINE(BROKEN_SETREUID, 1)

- AC_DEFINE(BROKEN_SETREGID, 1)

- ac_cv_sizeof_rlim_t=8],

-[freebsd*], [ LIBS="-lm $LIBS"

- ac_cv_func_getpeername=no

- ac_cv_func_getsockname=no

- ac_cv_func_shutdown=no

- ac_cv_func_close=no

-[dragonfly*], [ LIBS="-lm $LIBS"

-[bow], [ ac_cv_func_setitimer=no

-[superux*], [ ac_cv_func_setitimer=no

-[ LIBS="-lm $LIBS"])

-AC_CHECK_LIB(socket, socketpair) # SunOS/Solaris

-AC_CHECK_LIB(rt, clock_gettime) # GNU/Linux

-if test "${enable_win95}" = maybe; then

- AC_HAVE_LIBRARY(unicows, [enable_win95=yes], [enable_win95=no])

-if test "${enable_win95}" = yes; then

- LIBS="-lunicows $LIBS"

-AS_CASE(["$target_cpu"],

-[alpha*], [AS_CASE(["$target_os"::"$GCC"],

- [CFLAGS="-mieee $CFLAGS"],

- [CFLAGS="-ieee $CFLAGS"],

-ac_cv_header_net_socket_h=${ac_cv_header_net_socket_h=no}

-if test "$ac_cv_header_net_socket_h" = yes; then

- ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=no}

- ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=yes}

-dnl AC_HEADER_STDC has been checked in AC_USE_SYSTEM_EXTENSIONS

-AC_CHECK_HEADERS(limits.h sys/file.h sys/ioctl.h sys/syscall.h\

- syscall.h pwd.h grp.h a.out.h utime.h direct.h sys/resource.h \

- sys/mkdev.h sys/utime.h xti.h netinet/in_systm.h float.h ieeefp.h \

- ucontext.h intrinsics.h langinfo.h locale.h sys/sendfile.h time.h \

- net/socket.h sys/socket.h)

-dnl Check additional types.

-RUBY_CHECK_SIZEOF(rlim_t, [int long "long long"], [], [

- #ifdef HAVE_SYS_TYPES_H

- # include <sys/types.h>

- #ifdef HAVE_SYS_TIME_H

- # include <sys/time.h>

- #ifdef HAVE_SYS_RESOURCE_H

- # include <sys/resource.h>

- #ifdef HAVE_UNISTD_H

- # include <unistd.h>

- #include <stdio.h>

-RUBY_CHECK_SIZEOF(size_t, [int long void*], [], [@%:@include <sys/types.h>])

-RUBY_CHECK_SIZEOF(ptrdiff_t, size_t, [], [@%:@include <stddef.h>])

-RUBY_CHECK_SIZEOF([struct stat.st_size], [int long "long long"])

-if test "$ac_cv_member_struct_stat_st_blocks" = yes; then

- RUBY_CHECK_SIZEOF([struct stat.st_blocks], [int long "long long"])

-AC_CHECK_MEMBERS([struct stat.st_atim])

-AC_CHECK_MEMBERS([struct stat.st_atimespec])

-AC_CHECK_MEMBERS([struct stat.st_atimensec])

-AC_CHECK_MEMBERS([struct stat.st_mtim])

-AC_CHECK_MEMBERS([struct stat.st_mtimespec])

-AC_CHECK_MEMBERS([struct stat.st_mtimensec])

-AC_CHECK_MEMBERS([struct stat.st_ctim])

-AC_CHECK_MEMBERS([struct stat.st_ctimespec])

-AC_CHECK_MEMBERS([struct stat.st_ctimensec])

-AC_CHECK_TYPES([struct timespec], [], [], [@%:@ifdef HAVE_TIME_H

-@%:@include <time.h>

-AC_CHECK_TYPES([struct timezone], [], [], [@%:@ifdef HAVE_TIME_H

-@%:@ include <time.h>

-@%:@ifdef HAVE_SYS_TIME_H

-@%:@ include <sys/time.h>

-AC_CACHE_VAL([rb_cv_large_fd_select],

- [AC_CHECK_TYPE(fd_mask, [rb_cv_large_fd_select=yes], [rb_cv_large_fd_select=no])])

-if test "$rb_cv_large_fd_select" = yes; then

- AC_DEFINE(HAVE_RB_FD_INIT, 1)

-dnl RUBY_DEFINT TYPENAME, SIZE, [SIGNED-OR-UNSIGNED], [INCLUDES = DEFAULT-INCLUDES]

-AC_DEFUN([RUBY_DEFINT], [dnl

-AC_CACHE_CHECK([for $1], [rb_cv_type_$1],

-[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT([$4])

-typedef $1 t; int s = sizeof(t) == 42;])],

- [rb_cv_type_$1=yes],

- [AS_CASE([m4_bmatch([$2], [^[1-9][0-9]*$], $2, [$ac_cv_sizeof_]AS_TR_SH($2))],

- ["1"], [ rb_cv_type_$1="m4_if([$3], [], [signed ], [$3 ])char"],

- ["$ac_cv_sizeof_short"], [ rb_cv_type_$1="m4_if([$3], [], [], [$3 ])short"],

- ["$ac_cv_sizeof_int"], [ rb_cv_type_$1="m4_if([$3], [], [], [$3 ])int"],

- ["$ac_cv_sizeof_long"], [ rb_cv_type_$1="m4_if([$3], [], [], [$3 ])long"],

- ["$ac_cv_sizeof_long_long"], [ rb_cv_type_$1="m4_if([$3], [], [], [$3 ])long long"],

- ["$ac_cv_sizeof___int64"], [ rb_cv_type_$1="m4_if([$3], [], [], [$3 ])__int64"],

- [ rb_cv_type_$1=no])])])

-if test "${rb_cv_type_$1}" != no; then

- AC_DEFINE([HAVE_]AS_TR_CPP($1), 1)

- if test "${rb_cv_type_$1}" = yes; then

- m4_bmatch([$2], [^[1-9][0-9]*$], [AC_CHECK_SIZEOF([$1], 0, [AC_INCLUDES_DEFAULT([$4])])],

- [RUBY_CHECK_SIZEOF([$1], [$2], [], [AC_INCLUDES_DEFAULT([$4])])])

- AC_DEFINE_UNQUOTED($1, [$rb_cv_type_$1])

- AC_DEFINE_UNQUOTED([SIZEOF_]AS_TR_CPP($1), [SIZEOF_]AS_TR_CPP([$rb_cv_type_$1]))

-RUBY_DEFINT(int8_t, 1)

-RUBY_DEFINT(uint8_t, 1, unsigned)

-RUBY_DEFINT(int16_t, 2)

-RUBY_DEFINT(uint16_t, 2, unsigned)

-RUBY_DEFINT(int32_t, 4)

-RUBY_DEFINT(uint32_t, 4, unsigned)

-RUBY_DEFINT(int64_t, 8)

-RUBY_DEFINT(uint64_t, 8, unsigned)

-RUBY_DEFINT(int128_t, 16)

-RUBY_DEFINT(uint128_t, 16, unsigned)

-RUBY_DEFINT(intptr_t, void*)

-RUBY_DEFINT(uintptr_t, void*, unsigned)

-RUBY_DEFINT(ssize_t, size_t, [], [@%:@include <sys/types.h>]) dnl may differ from int, so not use AC_TYPE_SSIZE_T.

-AC_CACHE_CHECK(for stack end address, rb_cv_stack_end_address,

-[rb_cv_stack_end_address=no

-for addr in __libc_stack_end _SEND; do

- [extern void *$addr;],

- [if (!$addr) return 1;],

- [rb_cv_stack_end_address="$addr"; break])

-if test $rb_cv_stack_end_address != no; then

- AC_DEFINE_UNQUOTED(STACK_END_ADDRESS, $rb_cv_stack_end_address)

-AS_CASE(["${target_cpu}-${target_os}:${target_archs}"],

-[powerpc-darwin*], [

- AC_LIBSOURCES(alloca.c)

- AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}])

- AC_DEFINE(C_ALLOCA)

- AC_DEFINE_UNQUOTED(alloca, alloca)

-[universal-darwin*:*ppc*], [

- AC_LIBSOURCES(alloca.c)

- AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}])

- RUBY_DEFINE_IF([defined __powerpc__], C_ALLOCA, 1)

- RUBY_DEFINE_IF([defined __powerpc__], alloca, alloca)

-# http://sources.redhat.com/ml/libc-hacker/2005-08/msg00008.html

-# Debian GNU/Linux Etch's libc6.1 2.3.6.ds1-13etch5 has this problem.

-# Debian GNU/Linux Lenny's libc6.1 2.7-10 has no problem.

-AC_CACHE_CHECK(for broken erfc of glibc-2.3.6 on IA64, rb_cv_broken_glibc_ia64_erfc,

- rb_cv_broken_glibc_ia64_erfc=no,

- rb_cv_broken_glibc_ia64_erfc=yes,

- rb_cv_broken_glibc_ia64_erfc=no)])

-AS_CASE([$rb_cv_broken_glibc_ia64_erfc],[yes],[ac_cv_func_erf=no])

-AS_CASE(["$target_os"],[freebsd*],[

- AC_DEFINE(BROKEN_CLOSE)

- AC_REPLACE_FUNCS(close)

-AC_REPLACE_FUNCS(dup2 memmove strerror\

- strchr strstr crypt flock\

- isnan finite isinf hypot acosh erf tgamma lgamma_r cbrt \

-AC_CACHE_CHECK(for signbit, rb_cv_have_signbit,

-], [int v = signbit(-0.0);],

- rb_cv_have_signbit=yes,

- rb_cv_have_signbit=no)])

-if test "$rb_cv_have_signbit" = yes; then

- AC_DEFINE(HAVE_SIGNBIT)

- AC_LIBOBJ([signbit])

-AC_CHECK_FUNCS(fmod killpg wait4 waitpid fork spawnv syscall chroot getcwd eaccess\

- truncate ftruncate chsize times utimes utimensat fcntl lockf lstat\

- link symlink readlink readdir_r fsync fdatasync fchown\

- setitimer setruid seteuid setreuid setresuid setproctitle socketpair\

- getpriority getrlimit setrlimit sysconf close\

- dlopen sigprocmask sigaction sigsetjmp _setjmp _longjmp\

- setsid telldir seekdir fchmod cosh sinh tanh log2 round\

- setuid setgid daemon select_large_fdset setenv unsetenv\

- mktime timegm gmtime_r clock_gettime gettimeofday\

- pread sendfile shutdown sigaltstack)

-AC_CACHE_CHECK(for unsetenv returns a value, rb_cv_unsetenv_return_value,

-#include <stdlib.h>

-], [int v = unsetenv("foo");],

- rb_cv_unsetenv_return_value=yes,

- rb_cv_unsetenv_return_value=no)])

-if test "$rb_cv_unsetenv_return_value" = no; then

- AC_DEFINE(VOID_UNSETENV)

-AC_CACHE_CHECK(for __builtin_setjmp, ac_cv_func___builtin_setjmp,

-[AC_TRY_LINK([@%:@include <setjmp.h>

- jmp_buf jb; void t(v) int v; {__builtin_longjmp(jb, v);}],

- [__builtin_setjmp(jb);],

- [ac_cv_func___builtin_setjmp=yes],

- [ac_cv_func___builtin_setjmp=no])

-test x$ac_cv_func__longjmp = xno && ac_cv_func__setjmp=no

-AC_MSG_CHECKING(for setjmp type)

-AC_ARG_WITH(setjmp-type,

- AS_HELP_STRING([--with-setjmp-type], [select setjmp type]),

- AS_CASE([$withval],

- [__builtin_setjmp], [ setjmp_prefix=__builtin_],

- [_setjmp], [ setjmp_prefix=_],

- [sigsetjmp], [ setjmp_prefix=sig],

- [setjmp], [ setjmp_prefix=],

- [''], [ unset setjmp_prefix],

- [ AC_MSG_ERROR(invalid setjmp type: $withval)])], [unset setjmp_prefix])

-if test ${setjmp_prefix+set}; then

- if test "${setjmp_prefix}" && eval test '$ac_cv_func_'${setjmp_prefix}setjmp = no; then

- AC_MSG_ERROR(${setjmp_prefix}setjmp is not available)

-elif test "$ac_cv_func___builtin_setjmp" = yes; then

- setjmp_prefix=__builtin_

-elif test "$ac_cv_func__setjmp" = yes; then

-elif test "$ac_cv_func_sigsetjmp" = yes; then

- AS_CASE([$target_os],[solaris*|cygwin*],[setjmp_prefix=],[setjmp_prefix=sig])

-if test x$setjmp_prefix = xsig; then

- setjmp_sigmask=yes

- unset setjmp_sigmask

-AC_MSG_RESULT(${setjmp_prefix}setjmp)

-AC_DEFINE_UNQUOTED([RUBY_SETJMP(env)], [${setjmp_prefix}setjmp(env${setjmp_sigmask+,0})])

-AC_DEFINE_UNQUOTED([RUBY_LONGJMP(env,val)], [${setjmp_prefix}longjmp(env,val)])

-AC_DEFINE_UNQUOTED(RUBY_JMP_BUF, ${setjmp_sigmask+${setjmp_prefix}}jmp_buf)

- AS_HELP_STRING([--enable-setreuid], [use setreuid()/setregid() according to need even if obsolete]),

-AC_DEFUN([RUBY_CHECK_VARTYPE], [dnl

-AC_CACHE_CHECK([for external $1], AS_TR_SH(rb_cv_var_$1),

- [AS_TR_SH(rb_cv_var_$1)=no

-#ifndef _XOPEN_SOURCE

-#define _XOPEN_SOURCE 1

-const volatile void *volatile t;],

-#ifndef _XOPEN_SOURCE

-#define _XOPEN_SOURCE 1

-const volatile void *volatile t;],

- [AS_TR_SH(rb_cv_var_$1)=$t; break])

-if test "${AS_TR_SH(rb_cv_var_$1)}" != no; then

- AC_DEFINE(AS_TR_CPP(HAVE_VAR_$1))

- AC_DEFINE_UNQUOTED(AS_TR_CPP(TYPEOF_VAR_$1), ${AS_TR_SH(rb_cv_var_$1)})

-RUBY_CHECK_VARTYPE(timezone, [@%:@include <time.h>], [long int])

-RUBY_CHECK_VARTYPE(altzone, [@%:@include <time.h>], [long int])

-AC_CHECK_FUNCS(timezone)

-if test "$ac_cv_func_timezone" = yes; then

- AC_CACHE_CHECK([whether timezone requires zero arguments], rb_cv_func_timezone_void,

- [AC_TRY_COMPILE([@%:@include <time.h>],

- [(void)timezone(0, 0);],

- [rb_cv_func_timezone_void=no],

- [rb_cv_func_timezone_void=yes])]

- if test $rb_cv_func_timezone_void = yes; then

- AC_DEFINE(TIMEZONE_VOID)

-# [ruby-dev:40910] overflow of time on FreeBSD

-# http://www.freebsd.org/cgi/query-pr.cgi?pr=145341

-AC_CACHE_CHECK(for localtime(3) overflow correctly, rb_cv_localtime_overflow,

- tm = localtime(&t1);

- return; /* overflow detected. ok. */

- return; /* round-trip. ok. */

- if (~(time_t)0 <= 0) {

- t = (((time_t)1) << (sizeof(time_t) * 8 - 2));

- rb_cv_localtime_overflow=yes,

- rb_cv_localtime_overflow=no,

- rb_cv_localtime_overflow=yes)])

-if test "$rb_cv_localtime_overflow" = no; then

- AC_DEFINE(LOCALTIME_OVERFLOW_PROBLEM)

- AC_CHECK_FUNCS(sigsetmask)

- rb_cv_bsd_signal=$ac_cv_func_sigsetmask)])

-if test x"$target_cpu" = xia64; then

- AC_CACHE_CHECK(for __libc_ia64_register_backing_store_base,

- rb_cv___libc_ia64_register_backing_store_base,

- [rb_cv___libc_ia64_register_backing_store_base=no

- [extern unsigned long __libc_ia64_register_backing_store_base;],

- [unsigned long p = __libc_ia64_register_backing_store_base;

- printf("%ld\n", p);],

- [rb_cv___libc_ia64_register_backing_store_base=yes])])

- if test $rb_cv___libc_ia64_register_backing_store_base = yes; then

- AC_DEFINE(HAVE___LIBC_IA64_REGISTER_BACKING_STORE_BASE)

- [AC_COMPILE_IFELSE(AC_LANG_BOOL_COMPILE_TRY([], [(-1==(-1>>1))]),

- rb_cv_rshift_sign=no)])

- AC_DEFINE(RSHIFT(x,y), ((x)>>(int)(y)))

- AC_DEFINE(RSHIFT(x,y), (((x)<0) ? ~((~(x))>>(int)(y)) : (x)>>(int)(y)))

-test "$rb_cv_fcnt" = "not found" && rb_cv_fcnt="not found (OK if using GNU libc)"

-AC_CACHE_CHECK([read count field in FILE structures], rb_cv_fcnt,

-[rb_cv_fcnt="not found (OK if using GNU libc)"

- [rb_cv_fcnt="$fcnt"; break])

-AS_CASE("$rb_cv_fcnt",

- ["not found"*], [rb_cv_fcnt="not found"],

- [AC_DEFINE_UNQUOTED(FILE_COUNT, $rb_cv_fcnt)])

-AC_CACHE_CHECK([read buffer ptr field in FILE structures], rb_cv_frptr,

-if test "$rb_cv_frptr" != "not found"; then

- AC_CACHE_CHECK([read buffer end field in FILE structures], rb_cv_frend,

- [FILE *f = stdin; char buf[256]; f->$frend = buf;],

- rb_cv_frend="$frend"; break,

- rb_cv_frend="not found")

- if test "$rb_cv_frend" != "not found"; then

-RUBY_CHECK_SIZEOF([struct stat.st_ino], [long "long long"], [], [@%:@include <sys/stat.h>])

-if test "$ac_cv_func_sysconf" = yes; then

- AC_DEFUN([RUBY_CHECK_SYSCONF], [dnl

- AC_CACHE_CHECK([whether _SC_$1 is supported], rb_cv_have_sc_[]m4_tolower($1),

- [AC_TRY_COMPILE([#include <unistd.h>

- rb_cv_have_sc_[]m4_tolower($1)=yes,

- rb_cv_have_sc_[]m4_tolower($1)=no)

- if test "$rb_cv_have_sc_[]m4_tolower($1)" = yes; then

- AC_DEFINE(HAVE__SC_$1)

- RUBY_CHECK_SYSCONF(CLK_TCK)

-AC_DEFUN(RUBY_STACK_GROW_DIRECTION, [

- AC_CACHE_CHECK(stack growing direction on $1, rb_cv_stack_grow_dir_$1, [

-[m68*|x86*|i?86|ia64|ppc*|sparc*|alpha*], [ $2=-1],

-], $2=-1, $2=+1, $2=0)

-eval rb_cv_stack_grow_dir_$1=\$$2])

-eval $2=\$rb_cv_stack_grow_dir_$1])

-if test "${universal_binary-no}" = yes ; then

- archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`

- save_CFLAGS="$CFLAGS" new_cflags=`echo "$CFLAGS" | sed "s|$archflagpat"'||'`

- save_LDFLAGS="$LDFLAGS" new_ldflags=`echo "$LDFLAGS" | sed "s|$archflagpat"'||'`

- for archs in ${universal_archnames}; do

- archs=`echo $archs | sed 's/=.*//'`

- CFLAGS="$new_cflags -arch $archs"

- LDFLAGS="$new_ldflags -arch $archs"

- RUBY_STACK_GROW_DIRECTION($archs, dir)

- if test x$stack_dir = x; then

- elif test x$stack_dir != x$dir; then

- CFLAGS="$save_CFLAGS" LDFLAGS="$save_LDFLAGS"

- if test x$stack_dir = xno; then

- for archs in ${universal_archnames}; do

- archs=`echo $archs | sed 's/=.*//'`

- eval dir=\$rb_cv_stack_grow_dir_$archs

- RUBY_DEFINE_IF([defined __${archs}__], STACK_GROW_DIRECTION, $dir)

- AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $stack_dir)

- RUBY_STACK_GROW_DIRECTION($target_cpu, dir)

- AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $dir)

-if test x"$enable_pthread" = xyes; then

- for pthread_lib in thr pthread pthreads c c_r root; do

- AC_CHECK_LIB($pthread_lib, pthread_kill,

- rb_with_pthread=yes, rb_with_pthread=no)

- if test "$rb_with_pthread" = "yes"; then break; fi

- if test x"$rb_with_pthread" = xyes; then

- AC_DEFINE(_REENTRANT)

- AC_DEFINE(_THREAD_SAFE)

- AC_DEFINE(HAVE_LIBPTHREAD)

- AC_CHECK_HEADERS(pthread_np.h)

- AS_CASE([$pthread_lib],

- [c_r], [MAINLIBS="-pthread $MAINLIBS"],

- [LIBS="-l$pthread_lib $LIBS"])

- AC_MSG_WARN("Don't know how to find pthread library on your system -- thread support disabled")

- AC_CHECK_FUNCS(nanosleep sched_yield pthread_attr_setinheritsched \

- pthread_getattr_np pthread_attr_get_np pthread_attr_getstack\

- pthread_get_stackaddr_np pthread_get_stacksize_np \

- thr_stksegment pthread_stackseg_np pthread_getthrds_np)

- if test x"$ac_cv_func_nanosleep" = xno; then

- AC_CHECK_LIB(rt, nanosleep)

- if test x"$ac_cv_lib_rt_nanosleep" = xyes; then

- AC_DEFINE(HAVE_NANOSLEEP)

-if test x"$ac_cv_header_ucontext_h" = xyes; then

- if test x"$rb_with_pthread" = xyes; then

- AC_CHECK_FUNCS(getcontext setcontext)

-if test "$ac_cv_func_fork" = "yes" -a "$rb_with_pthread" = "yes"; then

- AC_CACHE_CHECK([if fork works with pthread], rb_cv_fork_with_pthread,

-#include <stdlib.h>

-#include <unistd.h>

-#include <pthread.h>

-#include <sys/types.h>

-#include <sys/wait.h>

-#include <signal.h>

-#ifndef EXIT_SUCCESS

-#define EXIT_SUCCESS 0

-#ifndef EXIT_FAILURE

-#define EXIT_FAILURE 1

-thread_func(void *dmy)

- if (pthread_create(&tid, 0, thread_func, 0) != 0) {

- if (pthread_join(tid, 0) != 0) {

-main(int argc, char *argv[])

- if (use_threads()) return EXIT_FAILURE;

- if (waitpid(pid, &loc, WNOHANG) == 0) {

- kill(pid, SIGKILL);

- return EXIT_FAILURE;

- if (!WIFEXITED(loc) || WEXITSTATUS(loc) != EXIT_SUCCESS)

- return EXIT_FAILURE;

- if (use_threads()) return EXIT_FAILURE;

- return EXIT_SUCCESS;

- rb_cv_fork_with_pthread=yes,

- rb_cv_fork_with_pthread=no,

- rb_cv_fork_with_pthread=yes)])

- test x$rb_cv_fork_with_pthread = xyes || AC_DEFINE(CANNOT_FORK_WITH_PTHREAD)

-AC_CHECK_FUNCS(backtrace)

-AC_ARG_WITH(valgrind,

- AS_HELP_STRING([--with-valgrind],[enable valgrind memcheck support]),

- [AC_CHECK_HEADERS(valgrind/memcheck.h)])

-dnl runtime section {

-AC_ARG_WITH(dln-a-out,

- AS_HELP_STRING([--with-dln-a-out], [use dln_a_out if possible]),

- AS_CASE([$withval],

- if test "$enable_shared" = yes; then

- AC_MSG_ERROR(dln_a_out can not make shared library)

- with_dln_a_out=yes],

- with_dln_a_out=no])], [with_dln_a_out=no])

-[AC_TRY_LINK([],[], [

-AS_CASE(["`head -1 conftest$EXEEXT | cat -e`"],

-['^?ELF'*], [rb_cv_binary_elf=yes], [rb_cv_binary_elf=no])],

-rb_cv_binary_elf=no)])

- if test "$with_dln_a_out" = yes; then

- AC_MSG_ERROR(dln_a_out does not work with ELF)

-AS_CASE(["$target_os"],

-[linux* | gnu* | k*bsd*-gnu | bsdi* | kopensolaris*-gnu], [

-AC_SUBST(LDSHAREDXX)dnl

- AS_CASE(["$target_os"],

- [nextstep*|openstep*|rhapsody*|darwin*], [

- # The -fno-common is needed if we wish to embed the Ruby interpreter

- # into a plugin module of some project (as opposed to embedding it

- # within the project's application). The -I/usr/local/include is

- # needed because CPP as discovered by configure (cc -E -traditional)

- # fails to consult /usr/local/include by default. This causes

- # mkmf.rb's have_header() to fail if the desired resource happens to be

- # installed in the /usr/local tree.

- RUBY_APPEND_OPTION(CCDLFLAGS, -fno-common)],

- RUBY_APPEND_OPTION(CCDLFLAGS, -fPIC)])

- AS_CASE(["$target_os"],

- [hpux*], [CCDLFLAGS="$CCDLFLAGS +Z"],

- [solaris*|irix*], [CCDLFLAGS="$CCDLFLAGS -KPIC"],

- [sunos*], [CCDLFLAGS="$CCDLFLAGS -PIC"],

- [esix*|uxpds*], [CCDLFLAGS="$CCDLFLAGS -KPIC"],

- [: ${CCDLFLAGS=""}])

- AC_ARG_ENABLE(rpath,

- AS_HELP_STRING([--disable-rpath], [embed run path into extension libraries]),

- [enable_rpath=$enableval], [enable_rpath="$rb_cv_binary_elf"])

- if test "$enable_rpath" = yes; then

- RPATHFLAG=" ${linker_flag}-R%1\$-s"

- AS_CASE(["$target_os"],

- [hpux*], [ DLDFLAGS="$DLDFLAGS -E"

- : ${LIBPATHENV=SHLIB_PATH}

- if test "$rb_cv_prog_gnu_ld" = no; then

- RPATHFLAG=' +b %1$-s'

- rb_cv_dlopen=yes],

- [solaris*], [ if test "$GCC" = yes; then

- : ${LDSHARED='$(CC) -shared'}

- if test "$rb_cv_prog_gnu_ld" = yes; then

- LDFLAGS="$LDFLAGS -Wl,-E"

- : ${LDSHARED='ld -G'}

- rb_cv_dlopen=yes],

- [sunos*], [ : ${LDSHARED='ld -assert nodefinitions'}

- rb_cv_dlopen=yes],

- [irix*], [ : ${LDSHARED='ld -shared'}

- rb_cv_dlopen=yes],

- [sysv4*], [ : ${LDSHARED='ld -G'}

- rb_cv_dlopen=yes],

- [nto-qnx*], [ : ${LDSHARED='$(CC) -shared'}

- rb_cv_dlopen=yes],

- [esix*|uxpds*], [ : ${LDSHARED="ld -G"}

- rb_cv_dlopen=yes],

- [osf*], [ : ${LDSHARED="ld -shared -expect_unresolved \"*\""}

- rb_cv_dlopen=yes],

- [bsdi3*], [ AS_CASE(["$CC"],

- [*shlicc*], [ : ${LDSHARED='$(CC) -r'}

- rb_cv_dlopen=yes])],

- : ${LDSHARED='$(CC) -shared'}

- if test "$rb_cv_binary_elf" = yes; then

- LDFLAGS="$LDFLAGS -Wl,-export-dynamic"

- rb_cv_dlopen=yes],

- [interix*], [ : ${LDSHARED='$(CC) -shared'}

- XLDFLAGS="$XLDFLAGS -Wl,-E"

- LIBPATHFLAG=" -L%1\$-s"

- rb_cv_dlopen=yes],

- [freebsd*|dragonfly*], [

- : ${LDSHARED='$(CC) -shared'}

- rb_cv_dlopen=yes],

- [openbsd*], [ : ${LDSHARED='$(CC) -shared ${CCDLFLAGS}'}

- rb_cv_dlopen=yes],

- [nextstep*], [ : ${LDSHARED='$(CC) -r -nostdlib'}

- rb_cv_dlopen=yes],

- [openstep*], [ : ${LDSHARED='$(CC) -dynamic -bundle -undefined suppress'}

- rb_cv_dlopen=yes],

- [rhapsody*], [ : ${LDSHARED='$(CC) -dynamic -bundle -undefined suppress'}

- rb_cv_dlopen=yes],

- [darwin*], [ : ${LDSHARED='$(CC) -dynamic -bundle'}

- : ${DLDFLAGS="${linker_flag}-undefined${linker_flag:+,}dynamic_lookup ${linker_flag}-multiply_defined${linker_flag:+,}suppress ${linker_flag}-flat_namespace"}

- : ${LIBPATHENV=DYLD_LIBRARY_PATH}

- # /usr/local/include is always searched for

- # some reason, but /usr/local/lib is not.

- hdr=`find /usr/local/include -name \*.h -type f | sed 's:^/usr/local/include/::;q'`

- if test -n "$hdr" && $CC -E -include "$hdr" -xc /dev/null | fgrep -q "$hdr"; then

- $CC -print-search-dirs | grep -q '^libraries:.*:/usr/local/lib/*' ||

- echo " $LDFLAGS " | grep -q ' -L */usr/local/lib/* ' ||

- LDFLAGS="${LDFLAGS:+$LDFLAGS }-L/usr/local/lib"

- rb_cv_dlopen=yes],

- [aix*], [ : ${LDSHARED='$(CC)'}

- LDSHARED="$LDSHARED ${linker_flag}-G"

- DLDFLAGS='-eInit_$(TARGET)'

- XLDFLAGS="${linker_flag}"'-bE:$(ARCHFILE)'" ${linker_flag}-brtl"

- XLDFLAGS="$XLDFLAGS ${linker_flag}-blibpath:${prefix}/lib:${LIBPATH:-/usr/lib:/lib}"

- TRY_LINK='$(CC) $(LDFLAGS) -oconftest $(INCFLAGS) -I$(hdrdir) $(CPPFLAGS)'

- TRY_LINK="$TRY_LINK"' $(CFLAGS) $(src) $(LIBPATH) $(LOCAL_LIBS) $(LIBS)'

- : ${LIBPATHENV=SHLIB_PATH}

- RPATHFLAG=" ${linker_flag}-blibpath:%1\$-s:${prefix}/lib:${LIBPATH:-/usr/lib:/lib}"

- rb_cv_dlopen=yes],

- [human*], [ : ${DLDFLAGS=''}

- rb_cv_dlopen=yes],

- [beos*], [ AS_CASE(["$target_cpu"],

- : ${LDSHARED="ld -xms"}

- DLDFLAGS="$DLDFLAGS "'-export Init_$(TARGET) -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'

- LDFLAGS="$LDFLAGS -L/boot/home/config/lib -lbe -lroot"

- : ${LDSHARED="ld -shared"}

- DLDFLAGS="$DLDFLAGS -L/boot/develop/lib/x86 -L/boot/home/config/lib \$(topdir)/_APP_ -lbe -lroot"

- LDFLAGS="$LDFLAGS -L/boot/develop/lib/x86 -L/boot/home/config/lib -lbe -lroot"

- : ${LIBPATHENV=LIBRARY_PATH}

- rb_cv_dlopen=yes],

- [haiku*], [ AS_CASE(["$target_cpu"],

- : ${LIBPATHENV=LIBRARY_PATH}

- rb_cv_dlopen=yes ],

- [nto-qnx*], [ DLDFLAGS="$DLDFLAGS -L/lib -L/usr/lib -L/usr/local/lib"

- rb_cv_dlopen=yes],

- [cygwin*|mingw*], [

- : ${LDSHARED='$(CC) -shared $(if $(filter-out -g -g0,$(debugflags)),,-s)'}

- XLDFLAGS="$XLDFLAGS -Wl,--stack,0x00200000,--enable-auto-import"

- DLDFLAGS="${DLDFLAGS} -Wl,--enable-auto-image-base,--enable-auto-import"

- : ${LIBPATHENV=""}

- rb_cv_dlopen=yes],

- [hiuxmpp], [ : ${LDSHARED='ld -r'}],

- [atheos*], [ : ${LDSHARED='$(CC) -shared'}

- rb_cv_dlopen=yes],

- [os2-emx*], [ LDFLAGS="$LDFLAGS -Zomf"

- [ : ${LDSHARED='ld'}])

-if test "${LDSHAREDXX}" = ""; then

- AS_CASE(["${LDSHARED}"],

- LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\$(CC)/$(CXX)/'`

- LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\${CC}/${CXX}/'`

- LDSHAREDXX=`echo "${LDSHARED}" | sed "s|$CC|$CXX|"`

-AS_CASE([${RPATHFLAG}],[*'%1$'*],[: ${LIBPATHFLAG=' -L%1$-s'}],[: ${LIBPATHFLAG=' -L%s'}])

-AC_SUBST(LIBPATHENV, "${LIBPATHENV-LD_LIBRARY_PATH}")

- AS_CASE(["$target_os"],

- [nextstep*|openstep*|rhapsody*|darwin*], [

- RUBY_APPEND_OPTION(XLDFLAGS, [-Wl,-u,_objc_msgSend])

- [cygwin*|mingw*|*djgpp*], [

-if test "$rb_cv_dlopen:$load_relative" = yes:yes; then

- AC_CHECK_FUNCS(dladdr)

- if test "$ac_cv_func_dladdr" = yes; then

- unset load_relative

-n=`expr "$DLEXT" : '.*'`; test "$n" -gt "$len" && len=$n

-n=`expr "$DLEXT2" : '.*'`; test "$n" -gt "$len" && len=$n

-AC_DEFINE_UNQUOTED(DLEXT_MAXLEN, `expr $len + 1`)

-test ".$DLEXT" = "." || AC_DEFINE_UNQUOTED(DLEXT, ".$DLEXT")

-test ".$DLEXT2" = "." || AC_DEFINE_UNQUOTED(DLEXT2, ".$DLEXT2")

-AS_CASE(["$target_os"],

- [linux* | gnu* | k*bsd*-gnu | kopensolaris*-gnu], [

- STRIP='strip -S -x'],

- [nextstep* | openstep* | rhapsody* | darwin*], [

- STRIP='strip -A -n'])

- AC_HELP_STRING([--with-ext=EXTS],

- [pass to --with-ext option of extmk.rb]))

-AC_ARG_WITH(out-ext,

- AC_HELP_STRING([--with-out-ext=EXTS],

- [pass to --without-ext option of extmk.rb]))

- AS_HELP_STRING([--with-static-linked-ext], [link external modules statically]),

- [AS_CASE([$withval],[yes],[STATIC=;EXTSTATIC=static])])

-AS_CASE(["$target_os"],

- test x"$MINIRUBY" = x && MINIRUBY="${RUBY-$BASERUBY} -I`pwd` "-r'$(arch)-fake'

- PREP='$(arch)-fake.rb'

- RUNRUBY='$(MINIRUBY) -I`cd $(srcdir)/lib; pwd`'

- XRUBY='$(MINIRUBY)'

- MINIRUBY='./miniruby$(EXEEXT) -I$(srcdir)/lib'

- MINIRUBY="$MINIRUBY"' -I$(EXTOUT)/common -I./- -r$(srcdir)/ext/purelib.rb'

- PREP='miniruby$(EXEEXT)'

- RUNRUBY='$(MINIRUBY) $(srcdir)/tool/runruby.rb --extout=$(EXTOUT)'

- XRUBY='$(RUNRUBY)'

-AC_SUBST(TEST_RUNNABLE)

-AC_SUBST(EXTOUT, [${EXTOUT=.ext}])

-AS_CASE(["$target_os"],

-AC_ARG_WITH(soname,

- AS_HELP_STRING([--with-soname=SONAME], [base name of shared library]),

- [RUBY_SO_NAME=$withval], [RUBY_SO_NAME='$(RUBY_BASE_NAME)'])

- AS_HELP_STRING([--enable-shared], [build a shared library for Ruby]),

-LIBRUBYARG_SHARED='-l$(RUBY_SO_NAME)'

- test -z "$CCDLFLAGS" || CFLAGS="$CFLAGS $CCDLFLAGS"

- AS_CASE(["$target_os"],

- [linux* | gnu* | k*bsd*-gnu | atheos* | kopensolaris*-gnu], [

- [freebsd*|dragonfly*], [

- LIBRUBY_SO='lib$(RUBY_SO_NAME).so.$(MAJOR)'

- LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR).$(TEENY) lib$(RUBY_SO_NAME).so'

- if test "$GCC" = yes; then

- LIBRUBY_DLDFLAGS="$DLDFLAGS "'-Wl,-h,$(@F)'

- LIBRUBY_DLDFLAGS="${linker_flag}-bnoentry $XLDFLAGS"

- LIBRUBYARG_SHARED='-L${libdir} -l${RUBY_SO_NAME}'

- AS_CASE(["$target_cpu"],

- LIBRUBY_DLDFLAGS='-f ruby.exp -lnet -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'

- RUBY_SO_NAME="$RUBY_SO_NAME"'.$(MAJOR).$(MINOR).$(TEENY)'

- LIBRUBY_LDSHARED='$(CC) -dynamiclib'

- if test "$load_relative" = yes; then

- libprefix='@executable_path/../lib'

- libprefix='$(libdir)'

- LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-install_name '${libprefix}'/$(LIBRUBY_SO)'

- LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-current_version $(MAJOR).$(MINOR).$(TEENY)'

- LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-compatibility_version $(ruby_version)'

- LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_Init_*'

- LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,*_threadptr_*'

- LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "' $(XLDFLAGS)'

- LIBRUBY_SO='lib$(RUBY_SO_NAME).dylib'

- LIBRUBY_ALIASES='lib$(RUBY_BASE_NAME).$(MAJOR).$(MINOR).dylib lib$(RUBY_INSTALL_NAME).dylib'

- LIBRUBYARG_SHARED='-L. -L${libdir} -l$(RUBY_SO_NAME)'

-if test "$enable_rpath" = yes; then

- LIBRUBY_RPATHFLAGS="${linker_flag}-R ${linker_flag}\$(libdir) -L\$(libdir)"

- LIBRUBYARG_SHARED="$LIBRUBY_RPATHFLAGS $LIBRUBYARG_SHARED"

- LIBRUBYARG_STATIC="$LIBRUBY_RPATHFLAGS $LIBRUBYARG_STATIC"

-LDFLAGS="-L. $LDFLAGS"

-if test "$EXEEXT" = .exe; then

- EXECUTABLE_EXTS='".exe",".com",".cmd",".bat"'

- AC_DEFINE_UNQUOTED(EXECUTABLE_EXTS, $EXECUTABLE_EXTS)

- EXECUTABLE_EXTS=`echo $EXECUTABLE_EXTS | tr -d '"' | tr , ' '`

- AC_SUBST(EXECUTABLE_EXTS)

-dnl build section {

-dnl build rdoc index if requested

-AC_ARG_ENABLE(install-doc,

- AS_HELP_STRING([--disable-install-doc], [do not install rdoc indexes during install]),

- [install_doc=$enableval], [install_doc=yes])

-if test "$install_doc" != no; then

- RDOCTARGET="nodoc"

- CAPITARGET="nodoc"

-AC_SUBST(RDOCTARGET)

-AS_CASE(["$RDOCTARGET:$CAPITARGET"],[nodoc:nodoc],[INSTALLDOC=nodoc],[INSTALLDOC=all])

-AC_SUBST(INSTALLDOC)

-if test "$rb_with_pthread" = "yes"; then

- THREAD_MODEL=pthread

-MINIDLNOBJ=dmydln.o

-AS_CASE(["$target_os"],

- RUBY_APPEND_OPTION(CFLAGS, -pipe)

- [nextstep*|openstep*], [

- RUBY_APPEND_OPTION(CPPFLAGS, -I/usr/local/include)

- RUBY_APPEND_OPTIONS(CFLAGS, -pipe -no-precomp)

- RUBY_APPEND_OPTION(CFLAGS, -pipe)

- AC_LIBOBJ([x68.o])

- CFLAGS="$CFLAGS -fansi-only"

- XCFLAGS="$XCFLAGS -cc1-stack=262144 -cpp-stack=2694144"

- CFLAGS="$CFLAGS -DOS2"

- AS_CASE(["`cc -v -I. -c main.c -o /tmp/main.o 2>&1`"],

- [*/gemc_cc*], [ # we have the new DEC GEM CC

- [ # we have the old MIPS CC

- AS_CASE(["$target_cpu"],[powerpc*], [CFLAGS="$CFLAGS -relax_pointers"])

- CPPFLAGS="$CPPFLAGS -I/boot/home/config/include"

- [cygwin*|mingw*], [

- RUBY_SO_NAME="${RUBY_SO_NAME}${MAJOR}${MINOR}${TEENY}"

- LIBRUBY_DLDFLAGS="${DLDFLAGS}"' -Wl,--out-implib=$(LIBRUBY)'

- AS_CASE(["$target_os"],

- LIBRUBY_SO='cyg$(RUBY_SO_NAME)'.dll

- LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)'

- RUBY_SO_NAME="${rb_cv_msvcrt}-${RUBY_SO_NAME}"

- LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)'

- DLDFLAGS="${DLDFLAGS}"' $(DEFFILE)'

-# COMMON_MACROS="WIN32_LEAN_AND_MEAN="

- COMMON_HEADERS="winsock2.h windows.h"

- THREAD_MODEL=win32

- if test x"$enable_shared" = xyes; then

- LIBRUBY='lib$(RUBY_SO_NAME).dll.a'

- AS_CASE(["$YACC"],[*yacc*], [

- FIRSTMAKEFILE=GNUmakefile:djgpp/GNUmakefile.in

-MINIOBJS="$MINIDLNOBJ"

-AS_CASE(["$THREAD_MODEL"],

-[pthread], [AC_CHECK_HEADERS(pthread.h)],

-[""], [AC_MSG_ERROR(thread model is missing)],

- [AC_MSG_ERROR(unknown thread model $THREAD_MODEL)])

-AS_CASE(["$FIRSTMAKEFILE"], [*GNUmakefile:*], [gnumake=yes], [

- AC_MSG_CHECKING([for if ${MAKE-make} is GNU make])

- mkdir conftest.dir

- echo "all:; @echo yes" > conftest.dir/GNUmakefile

- echo "all:; @echo no" > conftest.dir/Makefile

- gnumake=`(cd conftest.dir; ${MAKE-make})`

- rm -fr conftest.dir

- AS_CASE(["$gnumake"],

- echo "include Makefile" > GNUmakefile

- echo "-include uncommon.mk" >> GNUmakefile

- AC_MSG_RESULT($gnumake)

-if test "${universal_binary-no}" = yes ; then

- AC_CACHE_CHECK([for architecture macros], rb_cv_architecture_macros, [

- mv confdefs.h confdefs1.h

- AC_TRY_COMPILE([@%:@if defined __`echo ${universal_archnames} |

- sed 's/=[^ ]*//g;s/ /__ || defined __/g'`__

- rb_cv_architecture_macros=yes

- mv -f confdefs1.h confdefs.h

- rb_cv_architecture_macros=no

- archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`

- new_cflags=`echo "$CFLAGS" | sed "s|$archflagpat"'||'`

- for archs in ${universal_archnames}; do

- CFLAGS="$new_cflags -arch $archs"

- archs="__${archs}__"

- AC_MSG_CHECKING([for macro ${archs} on ${cpu}])

- AC_TRY_COMPILE([@%:@ifndef ${archs}

-@%:@endif], [], [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no])])

- mv -f confdefs1.h confdefs.h

- AC_MSG_ERROR([failed])

-CPPFLAGS="$CPPFLAGS "'$(DEFS)'

-test -z "$CPPFLAGS" || CPPFLAGS="$CPPFLAGS "; CPPFLAGS="$CPPFLAGS"'${cppflags}'

-if test -n "${cflags+set}"; then

- cflagspat=`eval echo '"'"${cflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'`

- CFLAGS=`echo " $CFLAGS " | sed "s|$cflagspat"'|${cflags}|;s/^ *//;s/ *$//'`

-if test -n "${cxxflags+set}"; then

- cxxflagspat=`eval echo '"'"${cxxflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'`

- CXXFLAGS=`echo " $CXXFLAGS " | sed "s|$cxxflagspat"'|${cxxflags}|;s/^ *//;s/ *$//'`

-if test "${ARCH_FLAG}"; then

- archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`

- CFLAGS=`echo "$CFLAGS" | sed "s|$archflagpat"'|$(ARCH_FLAG)|'`

- CXXFLAGS=`echo "$CXXFLAGS" | sed "s|$archflagpat"'|$(ARCH_FLAG)|'`

- LDFLAGS=`echo "$LDFLAGS" | sed "s|$archflagpat"'|$(ARCH_FLAG)|'`

-AC_SUBST(cppflags, [])dnl

-AC_SUBST(cflags, ["$orig_cflags "'${optflags} ${debugflags} ${warnflags}'])dnl

-AC_SUBST(cxxflags, ["$orig_cxxflags "'${optflags} ${debugflags} ${warnflags}'])dnl

-AC_SUBST(optflags)dnl

-AC_SUBST(debugflags)dnl

-AC_SUBST(warnflags)dnl

-AC_SUBST(THREAD_MODEL)

-RUBY_INSTALL_NAME="${ri_prefix}"'$(RUBY_BASE_NAME)'"${ri_suffix}"

-AS_CASE(["$target_os"],

- [cygwin*|mingw*], [

- RUBYW_INSTALL_NAME="${ri_prefix}"'$(RUBYW_BASE_NAME)'"${ri_suffix}"

- rubyw_install_name='$(RUBYW_INSTALL_NAME)'

-rubylibprefix='${libdir}/${RUBY_BASE_NAME}'

-AC_ARG_WITH(rubylibprefix,

- AS_HELP_STRING([--with-rubylibprefix=DIR], [prefix for ruby libraries [[LIBDIR/RUBY_BASE_NAME]]]),

- [rubylibprefix=$withval])

-RUBY_LIB_PREFIX=`eval echo \\"${rubylibprefix}\\"`

-AC_SUBST(rubylibprefix)

-RI_BASE_NAME=`echo ${RUBY_BASE_NAME} | sed 's/ruby/ri/'`

-ridir='${datarootdir}/${RI_BASE_NAME}'

- AS_HELP_STRING([--with-ridir=DIR], [ri documentation [[DATAROOTDIR/ri]]]),

-RIDIR=`eval echo \\"${ridir}\\"`

-AC_SUBST(RI_BASE_NAME)

-AC_ARG_WITH(ruby-version,

- AS_HELP_STRING([--with-ruby-version=STR], [ruby version string for version specific directories [[full]] (full|minor|STR)]),

- [ruby_version=$withval],

- [ruby_version=full])

-unset RUBY_LIB_VERSION

-unset RUBY_LIB_VERSION_STYLE

-AS_CASE(["$ruby_version"],

- [full], [RUBY_LIB_VERSION_STYLE='3 /* full */'],

- [minor], [RUBY_LIB_VERSION_STYLE='2 /* minor */'])

-if test ${RUBY_LIB_VERSION_STYLE+set}; then

- echo "#define RUBY_LIB_VERSION_STYLE $RUBY_LIB_VERSION_STYLE"

- echo '#define STRINGIZE(x) x'

- test -f revision.h -o -f "${srcdir}/revision.h" || echo '#define RUBY_REVISION 0'

- echo '#include "version.h"'

- echo 'ruby_version=RUBY_LIB_VERSION'

- ruby_version="`$CPP -I"${srcdir}" -I"${srcdir}/include" conftest.c | sed '/^ruby_version=/!d;s/ //g'`"

- eval $ruby_version

- RUBY_LIB_VERSION="\"${ruby_version}\""

- AS_HELP_STRING([--with-sitedir=DIR], [site libraries in DIR [[RUBY_LIB_PREFIX/site_ruby]]]),

- [sitedir='${rubylibprefix}/site_ruby'])

-until SITE_DIR=`eval echo \\"${dir}\\"`; test "x${dir}" = "x${SITE_DIR}"; do

-AC_ARG_WITH(vendordir,

- AS_HELP_STRING([--with-vendordir=DIR], [vendor libraries in DIR [[RUBY_LIB_PREFIX/vendor_ruby]]]),

- [vendordir=$withval],

- [vendordir='${rubylibprefix}/vendor_ruby'])

-until VENDOR_DIR=`eval echo \\"${dir}\\"`; test "x${dir}" = "x${VENDOR_DIR}"; do

- dir="${VENDOR_DIR}"

-if test "${LOAD_RELATIVE+set}"; then

- AC_DEFINE_UNQUOTED(LOAD_RELATIVE, $LOAD_RELATIVE)

- RUBY_EXEC_PREFIX=""

- RUBY_LIB_PREFIX="`eval echo "$RUBY_LIB_PREFIX" | sed 's|^NONE/|/|;s|^'"$prefix"'/|/|'`"

- RUBY_SITE_LIB_PATH="`eval echo "$SITE_DIR" | sed 's|^NONE/|/|;s|^'"$prefix"'/|/|'`"

- RUBY_VENDOR_LIB_PATH="`eval echo "$VENDOR_DIR" | sed 's|^NONE/|/|;s|^'"$prefix"'/|/|'`"

- RUBY_EXEC_PREFIX="`eval echo \\"$exec_prefix/\\" | sed 's|^NONE/|'"$prefix"'/|;s|/$||'`"

- RUBY_LIB_PREFIX="`eval echo \\"$RUBY_LIB_PREFIX\\" | sed 's|^NONE/|'"$prefix"'/|'`"

- RUBY_SITE_LIB_PATH="`eval echo \\"$SITE_DIR\\" | sed 's|^NONE/|'"$prefix"'/|'`"

- RUBY_VENDOR_LIB_PATH="`eval echo \\"$VENDOR_DIR\\" | sed 's|^NONE/|'"$prefix"'/|'`"

-pat=`echo "$RUBY_LIB_PREFIX/" | tr -c '\012' .`'$.*$'

-AS_CASE(["$RUBY_SITE_LIB_PATH"],

- ["$RUBY_LIB_PREFIX/"*], [

- RUBY_SITE_LIB_PATH='RUBY_LIB_PREFIX"/'"`expr \"$RUBY_SITE_LIB_PATH\" : \"$pat\"`"'"'

- RUBY_SITE_LIB_PATH="\"${RUBY_SITE_LIB_PATH}\""

-AS_CASE(["$RUBY_VENDOR_LIB_PATH"],

- ["$RUBY_LIB_PREFIX/"*], [

- RUBY_VENDOR_LIB_PATH='RUBY_LIB_PREFIX"/'"`expr \"$RUBY_VENDOR_LIB_PATH\" : \"$pat\"`"'"'

- RUBY_VENDOR_LIB_PATH="\"${RUBY_VENDOR_LIB_PATH}\""

-pat=`echo "$RUBY_EXEC_PREFIX/" | tr -c '\012' .`'$.*$'

-AS_CASE(["$RUBY_LIB_PREFIX"],

- ["$RUBY_EXEC_PREFIX/"*], [

- RUBY_LIB_PREFIX='RUBY_EXEC_PREFIX"/'"`expr \"$RUBY_LIB_PREFIX\" : \"$pat\"`"'"'

- RUBY_LIB_PREFIX="\"${RUBY_LIB_PREFIX}\""

-if test ${RUBY_LIB_VERSION_STYLE+set}; then

- AC_DEFINE_UNQUOTED(RUBY_LIB_VERSION_STYLE, $RUBY_LIB_VERSION_STYLE)

- AC_DEFINE_UNQUOTED(RUBY_LIB_VERSION, [$RUBY_LIB_VERSION])

-AC_DEFINE_UNQUOTED(RUBY_EXEC_PREFIX, "${RUBY_EXEC_PREFIX}")

-AC_DEFINE_UNQUOTED(RUBY_LIB_PREFIX, ${RUBY_LIB_PREFIX})

-AC_DEFINE_UNQUOTED(RUBY_SITE_LIB, ${RUBY_SITE_LIB_PATH})

-AC_DEFINE_UNQUOTED(RUBY_VENDOR_LIB, ${RUBY_VENDOR_LIB_PATH})

-AC_SUBST(ruby_version)dnl

-AC_SUBST(vendordir)dnl

-if test "${universal_binary-no}" = yes ; then

- arch="universal-${target_os}"

- AC_CACHE_CHECK(whether __ARCHITECTURE__ is available, rb_cv_architecture_available,

- AC_TRY_COMPILE([const char arch[] = __ARCHITECTURE__;], [puts(arch);],

- [rb_cv_architecture_available=yes], [rb_cv_architecture_available=no]))

- if test "${rb_cv_architecture_available}" = yes; then

- AC_DEFINE_UNQUOTED(RUBY_PLATFORM_CPU, __ARCHITECTURE__)

- for archs in ${universal_archnames}; do

- cpu=`echo $archs | sed 's/.*=//'`

- archs=`echo $archs | sed 's/=.*//'`

- RUBY_DEFINE_IF([defined __${archs}__], RUBY_PLATFORM_CPU, ["${cpu}"])

- test "$ac_cv_type_long_long" = yes && ints="'long long' $ints"

- AC_SUBST(UNIVERSAL_ARCHNAMES, "${universal_archnames}")

- AC_SUBST(UNIVERSAL_INTS, "${ints}")

- AC_DEFINE_UNQUOTED(RUBY_PLATFORM_OS, "${target_os}")

- AC_DEFINE_UNQUOTED(RUBY_ARCH, "universal-"RUBY_PLATFORM_OS)

- AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "universal."RUBY_PLATFORM_CPU"-"RUBY_PLATFORM_OS)

-AS_CASE(["$target_os"],[mingw*],[sitearch="$target_cpu-$rb_cv_msvcrt"])

-test ${sitearch+set} && AC_DEFINE_UNQUOTED(RUBY_SITEARCH, "${sitearch}")

- AS_HELP_STRING([--with-search-path=DIR], [specify the additional search path]),

-AC_ARG_WITH(rubyhdrdir,

- AS_HELP_STRING([--with-rubyhdrdir=DIR], [core headers in DIR [[INCLUDEDIR/RUBY_BASE_NAME-RUBY_VERSION]]]),

- [rubyhdrdir=$withval],

- [rubyhdrdir='${includedir}/${RUBY_BASE_NAME}-${ruby_version}'])

-AC_ARG_WITH(sitehdrdir,

- AS_HELP_STRING([--with-sitehdrdir=DIR], [core site headers in DIR [[RUBYHDRDIR/site_ruby]]]),

- [sitehdrdir=$withval],

- [sitehdrdir='${rubyhdrdir}/site_ruby'])

-AC_ARG_WITH(vendorhdrdir,

- AS_HELP_STRING([--with-vendorhdrdir=DIR], [core vendor headers in DIR [[RUBYHDRDIR/vendor_ruby]]]),

- [vendorhdrdir=$withval],

- [vendorhdrdir='${rubyhdrdir}/vendor_ruby'])

-AC_SUBST(rubyhdrdir)dnl

-AC_SUBST(sitehdrdir)dnl

-AC_SUBST(vendorhdrdir)dnl

-AC_ARG_WITH(opt-dir,

- AS_HELP_STRING([--with-opt-dir=DIR], [add optional headers and libraries DIR]))

- AS_HELP_STRING([--with-mantype=TYPE], [specify man page type; TYPE is one of man and doc]),

- AS_CASE(["$withval"],

- [man|doc], [MANTYPE=$withval],

- [AC_MSG_ERROR(invalid man type: $withval)])

- if ${NROFF} -mdoc ${srcdir}/man/ruby.1 >/dev/null 2>&1; then

-arch_hdrdir="${EXTOUT}/include/${arch}/ruby"

-AS_MKDIR_P("${arch_hdrdir}")

-config_h="${arch_hdrdir}/config.h"

-tr -d '\015' < confdefs.h | grep -v "^#define PACKAGE_" |

-${srcdir}/tool/ifchange "${config_h}" -

-tr -d '\015' < largefile.h > confdefs.h

-BUILTIN_ENCS=["`sed -n -e '/^BUILTIN_ENCS[ ]*=/{' \

- -e s/// -e :l -e '/\\\\$/N' -e 's/\\\\\\n/ /' -e 't l' -e p \

- -e '}' "${srcdir}/enc/Makefile.in"`"]

-for e in $BUILTIN_ENCS; do BUILTIN_ENCOBJS="$BUILTIN_ENCOBJS `basename $e .c`"'.$(OBJEXT)'; done

-AC_SUBST(BUILTIN_ENCOBJS)

-BUILTIN_TRANSES=["`sed -n -e '/^BUILTIN_TRANSES[ ]*=/{' \

- -e s/// -e :l -e '/\\\\$/N' -e 's/\\\\\\n/ /' -e 't l' -e p \

- -e '}' "${srcdir}/enc/Makefile.in"`"]

-for e in $BUILTIN_TRANSES; do

- BUILTIN_TRANSSRCS="$BUILTIN_TRANSSRCS `basename $e .trans`"'.c';

- BUILTIN_TRANSOBJS="$BUILTIN_TRANSOBJS `basename $e .trans`"'.$(OBJEXT)';

-AC_SUBST(BUILTIN_TRANSSRCS)

-AC_SUBST(BUILTIN_TRANSOBJS)

-PACKAGE=$RUBY_BASE_NAME

-AC_MSG_RESULT($PACKAGE library version = $ruby_version)

-AS_CASE([" $CPP "], [*" $CC "*], [CPP=`echo " $CPP " | sed "s| $CC |"' $(CC) |;s/^ *//;s/ *$//'`])

-AC_CONFIG_FILES($FIRSTMAKEFILE)

-AC_CONFIG_FILES(Makefile, [{

- if test -d "$srcdir/.svn"; then

- VCSUP='$(VCS) up $(SVNUPOPTIONS)'

- elif test -d "$srcdir/.git/svn"; then

- VCSUP='$(VCS) rebase $(GITSVNREBASEOPTIONS)'

- elif test -d "$srcdir/.git"; then

- VCSUP='$(VCS) pull $(GITPULLOPTIONS)'

- sed '/^MISSING/s/\$U\././g;/^VCS *=/s#@VCS@#'"$VCS"'#;/^VCSUP *=/s#@VCSUP@#'"$VCSUP"'#' Makefile

- echo; test x"$EXEEXT" = x || echo 'miniruby: miniruby$(EXEEXT)'

- if test "$gnumake" != yes; then

- echo ['$(MKFILES): $(srcdir)/common.mk']

- sed ['s/{\$([^(){}]*)[^{}]*}//g'] ${srcdir}/common.mk

- echo 'distclean-local::; @$(RM) GNUmakefile uncommon.mk'

- } > confmk$$.tmp && mv -f confmk$$.tmp Makefile &&

- ${MAKE-make} info-program | grep '^PROGRAM=ruby$' > /dev/null ||

- echo 'ruby: $(PROGRAM);' >> Makefile],

-[EXEEXT='$EXEEXT' gnumake='$gnumake'])

-/**********************************************************************

- created at: Thu May 23 09:03:43 2007

-**********************************************************************/

-#include "ruby/ruby.h"

-#include "vm_core.h"

-#include "eval_intern.h"

-#define CAPTURE_JUST_VALID_VM_STACK 1

-enum context_type {

- CONTINUATION_CONTEXT = 0,

- FIBER_CONTEXT = 1,

- ROOT_FIBER_CONTEXT = 2

-typedef struct rb_context_struct {

- enum context_type type;

-#ifdef CAPTURE_JUST_VALID_VM_STACK

- size_t vm_stack_slen; /* length of stack (head of th->stack) */

- size_t vm_stack_clen; /* length of control frames (tail of th->stack) */

- VALUE *machine_stack;

- VALUE *machine_stack_src;

- VALUE *machine_register_stack;

- VALUE *machine_register_stack_src;

- int machine_register_stack_size;

- rb_thread_t saved_thread;

- rb_jmpbuf_t jmpbuf;

- size_t machine_stack_size;

-enum fiber_status {

-typedef struct rb_fiber_struct {

- rb_context_t cont;

- enum fiber_status status;

- struct rb_fiber_struct *prev_fiber;

- struct rb_fiber_struct *next_fiber;

-static const rb_data_type_t cont_data_type, fiber_data_type;

-static VALUE rb_cContinuation;

-static VALUE rb_cFiber;

-static VALUE rb_eFiberError;

-#define GetContPtr(obj, ptr) \

- TypedData_Get_Struct(obj, rb_context_t, &cont_data_type, ptr)

-#define GetFiberPtr(obj, ptr) do {\

- TypedData_Get_Struct(obj, rb_fiber_t, &fiber_data_type, ptr); \

- if (!ptr) rb_raise(rb_eFiberError, "uninitialized fiber"); \

-NOINLINE(static VALUE cont_capture(volatile int *stat));

-void rb_thread_mark(rb_thread_t *th);

-#define THREAD_MUST_BE_RUNNING(th) do { \

- if (!th->tag) rb_raise(rb_eThreadError, "not running thread"); \

-cont_mark(void *ptr)

- RUBY_MARK_ENTER("cont");

- rb_context_t *cont = ptr;

- rb_gc_mark(cont->value);

- rb_thread_mark(&cont->saved_thread);

- if (cont->vm_stack) {

-#ifdef CAPTURE_JUST_VALID_VM_STACK

- rb_gc_mark_locations(cont->vm_stack,

- cont->vm_stack + cont->vm_stack_slen + cont->vm_stack_clen);

- rb_gc_mark_localtion(cont->vm_stack,

- cont->vm_stack, cont->saved_thread.stack_size);

- if (cont->machine_stack) {

- rb_gc_mark_locations(cont->machine_stack,

- cont->machine_stack + cont->machine_stack_size);

- if (cont->machine_register_stack) {

- rb_gc_mark_locations(cont->machine_register_stack,

- cont->machine_register_stack + cont->machine_register_stack_size);

- RUBY_MARK_LEAVE("cont");

-cont_free(void *ptr)

- RUBY_FREE_ENTER("cont");

- rb_context_t *cont = ptr;

- RUBY_FREE_UNLESS_NULL(cont->saved_thread.stack); fflush(stdout);

- RUBY_FREE_UNLESS_NULL(cont->machine_stack);

- RUBY_FREE_UNLESS_NULL(cont->machine_register_stack);

- RUBY_FREE_UNLESS_NULL(cont->vm_stack);

- /* free rb_cont_t or rb_fiber_t */

- RUBY_FREE_LEAVE("cont");

-cont_memsize(const void *ptr)

- const rb_context_t *cont = ptr;

- size = sizeof(*cont);

- if (cont->vm_stack) {

-#ifdef CAPTURE_JUST_VALID_VM_STACK

- size_t n = (cont->vm_stack_slen + cont->vm_stack_clen);

- size_t n = cont->saved_thread.stack_size;

- size += n * sizeof(*cont->vm_stack);

- if (cont->machine_stack) {

- size += cont->machine_stack_size * sizeof(*cont->machine_stack);

- if (cont->machine_register_stack) {

- size += cont->machine_register_stack_size * sizeof(*cont->machine_register_stack);

-fiber_mark(void *ptr)

- RUBY_MARK_ENTER("cont");

- rb_fiber_t *fib = ptr;

- rb_gc_mark(fib->prev);

- cont_mark(&fib->cont);

- RUBY_MARK_LEAVE("cont");

-fiber_link_join(rb_fiber_t *fib)

- VALUE current_fibval = rb_fiber_current();

- rb_fiber_t *current_fib;

- GetFiberPtr(current_fibval, current_fib);

- /* join fiber link */

- fib->next_fiber = current_fib->next_fiber;

- fib->prev_fiber = current_fib;

- current_fib->next_fiber->prev_fiber = fib;

- current_fib->next_fiber = fib;

-fiber_link_remove(rb_fiber_t *fib)

- fib->prev_fiber->next_fiber = fib->next_fiber;

- fib->next_fiber->prev_fiber = fib->prev_fiber;

-fiber_free(void *ptr)

- RUBY_FREE_ENTER("fiber");

- rb_fiber_t *fib = ptr;

- if (fib->cont.type != ROOT_FIBER_CONTEXT &&

- fib->cont.saved_thread.local_storage) {

- st_free_table(fib->cont.saved_thread.local_storage);

- fiber_link_remove(fib);

- cont_free(&fib->cont);

- RUBY_FREE_LEAVE("fiber");

-fiber_memsize(const void *ptr)

- const rb_fiber_t *fib = ptr;

- size = sizeof(*fib);

- if (fib->cont.type != ROOT_FIBER_CONTEXT) {

- size += st_memsize(fib->cont.saved_thread.local_storage);

- size += cont_memsize(&fib->cont);

-cont_save_machine_stack(rb_thread_t *th, rb_context_t *cont)

- rb_thread_t *sth = &cont->saved_thread;

- SET_MACHINE_STACK_END(&th->machine_stack_end);

- th->machine_register_stack_end = rb_ia64_bsp();

- if (th->machine_stack_start > th->machine_stack_end) {

- size = cont->machine_stack_size = th->machine_stack_start - th->machine_stack_end;

- cont->machine_stack_src = th->machine_stack_end;

- size = cont->machine_stack_size = th->machine_stack_end - th->machine_stack_start;

- cont->machine_stack_src = th->machine_stack_start;

- if (cont->machine_stack) {

- REALLOC_N(cont->machine_stack, VALUE, size);

- cont->machine_stack = ALLOC_N(VALUE, size);

- FLUSH_REGISTER_WINDOWS;

- MEMCPY(cont->machine_stack, cont->machine_stack_src, VALUE, size);

- rb_ia64_flushrs();

- size = cont->machine_register_stack_size = th->machine_register_stack_end - th->machine_register_stack_start;

- cont->machine_register_stack_src = th->machine_register_stack_start;

- if (cont->machine_register_stack) {

- REALLOC_N(cont->machine_register_stack, VALUE, size);

- cont->machine_register_stack = ALLOC_N(VALUE, size);

- MEMCPY(cont->machine_register_stack, cont->machine_register_stack_src, VALUE, size);

- sth->machine_stack_start = sth->machine_stack_end = 0;

- sth->machine_register_stack_start = sth->machine_register_stack_end = 0;

-static const rb_data_type_t cont_data_type = {

- cont_mark, cont_free, cont_memsize,

-cont_init(rb_context_t *cont, rb_thread_t *th)

- /* save thread context */

- cont->saved_thread = *th;

- cont->saved_thread.local_storage = 0;

-static rb_context_t *

-cont_new(VALUE klass)

- rb_context_t *cont;

- volatile VALUE contval;

- rb_thread_t *th = GET_THREAD();

- THREAD_MUST_BE_RUNNING(th);

- contval = TypedData_Make_Struct(klass, rb_context_t, &cont_data_type, cont);

- cont->self = contval;

- cont_init(cont, th);

-void rb_vm_stack_to_heap(rb_thread_t *th);

-cont_capture(volatile int *stat)

- rb_context_t *cont;

- rb_thread_t *th = GET_THREAD(), *sth;

- volatile VALUE contval;

- THREAD_MUST_BE_RUNNING(th);

- rb_vm_stack_to_heap(th);

- cont = cont_new(rb_cContinuation);

- contval = cont->self;

- sth = &cont->saved_thread;

-#ifdef CAPTURE_JUST_VALID_VM_STACK

- cont->vm_stack_slen = th->cfp->sp + th->mark_stack_len - th->stack;

- cont->vm_stack_clen = th->stack + th->stack_size - (VALUE*)th->cfp;

- cont->vm_stack = ALLOC_N(VALUE, cont->vm_stack_slen + cont->vm_stack_clen);

- MEMCPY(cont->vm_stack, th->stack, VALUE, cont->vm_stack_slen);

- MEMCPY(cont->vm_stack + cont->vm_stack_slen, (VALUE*)th->cfp, VALUE, cont->vm_stack_clen);

- cont->vm_stack = ALLOC_N(VALUE, th->stack_size);

- MEMCPY(cont->vm_stack, th->stack, VALUE, th->stack_size);

- cont_save_machine_stack(th, cont);

- if (ruby_setjmp(cont->jmpbuf)) {

- value = cont->value;

- if (cont->argc == -1) rb_exc_raise(value);

- cont->value = Qnil;

- return cont->self;

-NOINLINE(NORETURN(static void cont_restore_1(rb_context_t *)));

-cont_restore_1(rb_context_t *cont)

- rb_thread_t *th = GET_THREAD(), *sth = &cont->saved_thread;

- /* restore thread context */

- if (cont->type == CONTINUATION_CONTEXT) {

- /* continuation */

- th->fiber = sth->fiber;

- fib = th->fiber ? th->fiber : th->root_fiber;

- rb_fiber_t *fcont;

- GetFiberPtr(fib, fcont);

- th->stack_size = fcont->cont.saved_thread.stack_size;

- th->stack = fcont->cont.saved_thread.stack;

-#ifdef CAPTURE_JUST_VALID_VM_STACK

- MEMCPY(th->stack, cont->vm_stack, VALUE, cont->vm_stack_slen);

- MEMCPY(th->stack + sth->stack_size - cont->vm_stack_clen,

- cont->vm_stack + cont->vm_stack_slen, VALUE, cont->vm_stack_clen);

- MEMCPY(th->stack, cont->vm_stack, VALUE, sth->stack_size);

- th->stack = sth->stack;

- th->stack_size = sth->stack_size;

- th->local_storage = sth->local_storage;

- th->fiber = cont->self;

- th->cfp = sth->cfp;

- th->safe_level = sth->safe_level;

- th->raised_flag = sth->raised_flag;

- th->state = sth->state;

- th->status = sth->status;

- th->tag = sth->tag;

- th->protect_tag = sth->protect_tag;

- th->errinfo = sth->errinfo;

- th->first_proc = sth->first_proc;

- /* restore machine stack */

- /* workaround for x64 SEH */

- ((_JUMP_BUFFER*)(&cont->jmpbuf))->Frame =

- ((_JUMP_BUFFER*)(&buf))->Frame;

- if (cont->machine_stack_src) {

- FLUSH_REGISTER_WINDOWS;

- MEMCPY(cont->machine_stack_src, cont->machine_stack,

- VALUE, cont->machine_stack_size);

- if (cont->machine_register_stack_src) {

- MEMCPY(cont->machine_register_stack_src, cont->machine_register_stack,

- VALUE, cont->machine_register_stack_size);

- ruby_longjmp(cont->jmpbuf, 1);

-NORETURN(NOINLINE(static void cont_restore_0(rb_context_t *, VALUE *)));

-#define C(a) rse_##a##0, rse_##a##1, rse_##a##2, rse_##a##3, rse_##a##4

-#define E(a) rse_##a##0= rse_##a##1= rse_##a##2= rse_##a##3= rse_##a##4

-static volatile int C(a), C(b), C(c), C(d), C(e);

-static volatile int C(f), C(g), C(h), C(i), C(j);

-static volatile int C(k), C(l), C(m), C(n), C(o);

-static volatile int C(p), C(q), C(r), C(s), C(t);

-{/* the above lines make cc-mode.el confused so much */}

-int rb_dummy_false = 0;

-NORETURN(NOINLINE(static void register_stack_extend(rb_context_t *, VALUE *, VALUE *)));

-register_stack_extend(rb_context_t *cont, VALUE *vp, VALUE *curr_bsp)

- if (rb_dummy_false) {

- /* use registers as much as possible */

- E(a) = E(b) = E(c) = E(d) = E(e) =

- E(f) = E(g) = E(h) = E(i) = E(j) =

- E(k) = E(l) = E(m) = E(n) = E(o) =

- E(p) = E(q) = E(r) = E(s) = E(t) = 0;

- E(a) = E(b) = E(c) = E(d) = E(e) =

- E(f) = E(g) = E(h) = E(i) = E(j) =

- E(k) = E(l) = E(m) = E(n) = E(o) =

- E(p) = E(q) = E(r) = E(s) = E(t) = 0;

- if (curr_bsp < cont->machine_register_stack_src+cont->machine_register_stack_size) {

- register_stack_extend(cont, vp, (VALUE*)rb_ia64_bsp());

- cont_restore_0(cont, vp);

-cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame)

- if (cont->machine_stack_src) {

-#define STACK_PAD_SIZE 1

-#define STACK_PAD_SIZE 1024

- VALUE space[STACK_PAD_SIZE];

-#if !STACK_GROW_DIRECTION

- if (addr_in_prev_frame > &space[0]) {

- /* Stack grows downward */

-#if STACK_GROW_DIRECTION <= 0

- volatile VALUE *const end = cont->machine_stack_src;

- if (&space[0] > end) {

-# ifdef HAVE_ALLOCA

- volatile VALUE *sp = ALLOCA_N(VALUE, &space[0] - end);

- cont_restore_0(cont, &space[0]);

-#if !STACK_GROW_DIRECTION

- /* Stack grows upward */

-#if STACK_GROW_DIRECTION >= 0

- volatile VALUE *const end = cont->machine_stack_src + cont->machine_stack_size;

- if (&space[STACK_PAD_SIZE] < end) {

-# ifdef HAVE_ALLOCA

- volatile VALUE *sp = ALLOCA_N(VALUE, end - &space[STACK_PAD_SIZE]);

- cont_restore_0(cont, &space[STACK_PAD_SIZE-1]);

-#if !STACK_GROW_DIRECTION

- cont_restore_1(cont);

-#define cont_restore_0(cont, vp) register_stack_extend(cont, vp, (VALUE*)rb_ia64_bsp());

- * Document-class: Continuation

- * Continuation objects are generated by

- * <code>Kernel#callcc</code>. They hold a return address and execution

- * context, allowing a nonlocal return to the end of the

- * <code>callcc</code> block from anywhere within a program.

- * Continuations are somewhat analogous to a structured version of C's

- * <code>setjmp/longjmp</code> (although they contain more state, so

- * you might consider them closer to threads).

- * arr = [ "Freddie", "Herbie", "Ron", "Max", "Ringo" ]

- * puts(message = arr.shift)

- * $cc.call unless message =~ /Max/

- * produces:

- * This (somewhat contrived) example allows the inner loop to abandon

- * processing early:

- * print "\n#{i}: "

- * for j in i*5...(i+1)*5

- * cont.call() if j == 17

- * produces:

- * 2: 10 11 12 13 14

- * callcc {|cont| block } -> obj

- * Generates a <code>Continuation</code> object, which it passes to the

- * associated block. Performing a cont<code>.call</code> will

- * cause the <code>callcc</code> to return (as will falling through the

- * end of the block). The value returned by the <code>callcc</code> is

- * the value of the block, or the value passed to

- * cont<code>.call</code>. See class <code>Continuation</code>

- * for more details. Also see <code>Kernel::throw</code> for

- * an alternative mechanism for unwinding a call stack.

-rb_callcc(VALUE self)

- volatile int called;

- volatile VALUE val = cont_capture(&called);

- return rb_yield(val);

-make_passing_arg(int argc, VALUE *argv)

- return rb_ary_new4(argc, argv);

- * cont.call(args, ...)

- * Invokes the continuation. The program continues from the end of the

- * <code>callcc</code> block. If no arguments are given, the original

- * <code>callcc</code> returns <code>nil</code>. If one argument is

- * given, <code>callcc</code> returns it. Otherwise, an array

- * containing args is returned.

- * callcc {|cont| cont.call } #=> nil

- * callcc {|cont| cont.call 1 } #=> 1

- * callcc {|cont| cont.call 1, 2, 3 } #=> [1, 2, 3]

-rb_cont_call(int argc, VALUE *argv, VALUE contval)

- rb_context_t *cont;

- rb_thread_t *th = GET_THREAD();

- GetContPtr(contval, cont);

- if (cont->saved_thread.self != th->self) {

- rb_raise(rb_eRuntimeError, "continuation called across threads");

- if (cont->saved_thread.protect_tag != th->protect_tag) {

- rb_raise(rb_eRuntimeError, "continuation called across stack rewinding barrier");

- if (cont->saved_thread.fiber) {

- rb_fiber_t *fcont;

- GetFiberPtr(cont->saved_thread.fiber, fcont);

- if (th->fiber != cont->saved_thread.fiber) {

- rb_raise(rb_eRuntimeError, "continuation called across fiber");

- cont->argc = argc;

- cont->value = make_passing_arg(argc, argv);

- cont_restore_0(cont, &contval);

- return Qnil; /* unreachable */

- * Document-class: Fiber

- * Fibers are primitives for implementing light weight cooperative

- * concurrency in Ruby. Basically they are a means of creating code blocks

- * that can be paused and resumed, much like threads. The main difference

- * is that they are never preempted and that the scheduling must be done by

- * the programmer and not the VM.

- * As opposed to other stackless light weight concurrency models, each fiber

- * comes with a small 4KB stack. This enables the fiber to be paused from deeply

- * nested function calls within the fiber block.

- * When a fiber is created it will not run automatically. Rather it must be

- * be explicitly asked to run using the <code>Fiber#resume</code> method.

- * The code running inside the fiber can give up control by calling

- * <code>Fiber.yield</code> in which case it yields control back to caller

- * (the caller of the <code>Fiber#resume</code>).

- * Upon yielding or termination the Fiber returns the value of the last

- * executed expression

- * fiber = Fiber.new do

- * puts fiber.resume

- * produces

- * FiberError: dead fiber called

- * The <code>Fiber#resume</code> method accepts an arbitrary number of

- * parameters, if it is the first call to <code>resume</code> then they

- * will be passed as block arguments. Otherwise they will be the return

- * value of the call to <code>Fiber.yield</code>

- * fiber = Fiber.new do |first|

- * second = Fiber.yield first + 2

- * puts fiber.resume 10

- * puts fiber.resume 14

- * puts fiber.resume 18

- * produces

- * FiberError: dead fiber called

-#define FIBER_VM_STACK_SIZE (4 * 1024)

-static const rb_data_type_t fiber_data_type = {

- fiber_mark, fiber_free, fiber_memsize,

-fiber_alloc(VALUE klass)

- return TypedData_Wrap_Struct(klass, &fiber_data_type, 0);

-fiber_t_alloc(VALUE fibval)

- rb_thread_t *th = GET_THREAD();

- THREAD_MUST_BE_RUNNING(th);

- fib = ALLOC(rb_fiber_t);

- memset(fib, 0, sizeof(rb_fiber_t));

- fib->cont.self = fibval;

- fib->cont.type = FIBER_CONTEXT;

- cont_init(&fib->cont, th);

- fib->status = CREATED;

- DATA_PTR(fibval) = fib;

-fiber_init(VALUE fibval, VALUE proc)

- rb_fiber_t *fib = fiber_t_alloc(fibval);

- rb_context_t *cont = &fib->cont;

- rb_thread_t *th = &cont->saved_thread;

- /* initialize cont */

- cont->vm_stack = 0;

- th->stack_size = 0;

- fiber_link_join(fib);

- th->stack_size = FIBER_VM_STACK_SIZE;

- th->stack = ALLOC_N(VALUE, th->stack_size);

- th->cfp = (void *)(th->stack + th->stack_size);

- th->cfp->sp = th->stack + 1;

- th->cfp->lfp = th->stack;

- *th->cfp->lfp = 0;

- th->cfp->dfp = th->stack;

- th->cfp->self = Qnil;

- th->cfp->flag = 0;

- th->cfp->iseq = 0;

- th->cfp->proc = 0;

- th->cfp->block_iseq = 0;

- th->local_storage = st_init_numtable();

- th->first_proc = proc;

- MEMCPY(&cont->jmpbuf, &th->root_jmpbuf, rb_jmpbuf_t, 1);

-rb_fiber_init(VALUE fibval)

- return fiber_init(fibval, rb_block_proc());

-rb_fiber_new(VALUE (*func)(ANYARGS), VALUE obj)

- return fiber_init(fiber_alloc(rb_cFiber), rb_proc_new(func, obj));

- VALUE curr = rb_fiber_current();

- GetFiberPtr(curr, fib);

- if (fib->prev == Qnil) {

- rb_thread_t *th = GET_THREAD();

- if (th->root_fiber != curr) {

- return th->root_fiber;

- rb_raise(rb_eFiberError, "can't yield from root fiber");

- VALUE prev = fib->prev;

-VALUE rb_fiber_transfer(VALUE fib, int argc, VALUE *argv);

-rb_fiber_terminate(rb_fiber_t *fib)

- VALUE value = fib->cont.value;

- fib->status = TERMINATED;

- rb_fiber_transfer(return_fiber(), 1, &value);

-rb_fiber_start(void)

- rb_thread_t *th = GET_THREAD();

- rb_context_t *cont;

- GetFiberPtr(th->fiber, fib);

- cont = &fib->cont;

- if ((state = EXEC_TAG()) == 0) {

- VALUE *argv, args;

- GetProcPtr(cont->saved_thread.first_proc, proc);

- args = cont->value;

- argv = (argc = cont->argc) > 1 ? RARRAY_PTR(args) : &args;

- cont->value = Qnil;

- th->errinfo = Qnil;

- th->local_lfp = proc->block.lfp;

- th->local_svar = Qnil;

- fib->status = RUNNING;

- cont->value = rb_vm_invoke_proc(th, proc, proc->block.self, argc, argv, 0);

- if (state == TAG_RAISE) {

- th->thrown_errinfo = th->errinfo;

- th->thrown_errinfo =

- rb_vm_make_jump_tag_but_local_jump(state, th->errinfo);

- RUBY_VM_SET_INTERRUPT(th);

- rb_fiber_terminate(fib);

- rb_bug("rb_fiber_start: unreachable");

-static rb_fiber_t *

-root_fiber_alloc(rb_thread_t *th)

- /* no need to allocate vm stack */

- fib = fiber_t_alloc(fiber_alloc(rb_cFiber));

- fib->cont.type = ROOT_FIBER_CONTEXT;

- fib->prev_fiber = fib->next_fiber = fib;

-rb_fiber_current(void)

- rb_thread_t *th = GET_THREAD();

- if (th->fiber == 0) {

- rb_fiber_t *fib = root_fiber_alloc(th);

- th->root_fiber = th->fiber = fib->cont.self;

-fiber_store(rb_fiber_t *next_fib)

- rb_thread_t *th = GET_THREAD();

- GetFiberPtr(th->fiber, fib);

- fib->cont.saved_thread = *th;

- /* create current fiber */

- fib = root_fiber_alloc(th);

- th->root_fiber = th->fiber = fib->cont.self;

- cont_save_machine_stack(th, &fib->cont);

- if (ruby_setjmp(fib->cont.jmpbuf)) {

- GetFiberPtr(th->fiber, fib);

- if (fib->cont.argc == -1) rb_exc_raise(fib->cont.value);

- return fib->cont.value;

-static inline VALUE

-fiber_switch(VALUE fibval, int argc, VALUE *argv, int is_resume)

- rb_context_t *cont;

- rb_thread_t *th = GET_THREAD();

- GetFiberPtr(fibval, fib);

- cont = &fib->cont;

- if (cont->saved_thread.self != th->self) {

- rb_raise(rb_eFiberError, "fiber called across threads");

- else if (cont->saved_thread.protect_tag != th->protect_tag) {

- rb_raise(rb_eFiberError, "fiber called across stack rewinding barrier");

- else if (fib->status == TERMINATED) {

- value = rb_exc_new2(rb_eFiberError, "dead fiber called");

- if (th->fiber != fibval) {

- GetFiberPtr(th->fiber, fib);

- if (fib->status != TERMINATED) rb_exc_raise(value);

- fibval = th->root_fiber;

- fibval = fib->prev;

- if (NIL_P(fibval)) fibval = th->root_fiber;

- GetFiberPtr(fibval, fib);

- cont = &fib->cont;

- cont->value = value;

- cont_restore_0(cont, &value);

- fib->prev = rb_fiber_current();

- cont->argc = argc;

- cont->value = make_passing_arg(argc, argv);

- if ((value = fiber_store(fib)) == Qundef) {

- cont_restore_0(cont, &value);

- rb_bug("rb_fiber_resume: unreachable");

- RUBY_VM_CHECK_INTS();

-rb_fiber_transfer(VALUE fib, int argc, VALUE *argv)

- return fiber_switch(fib, argc, argv, 0);

-rb_fiber_resume(VALUE fibval, int argc, VALUE *argv)

- GetFiberPtr(fibval, fib);

- if (fib->prev != Qnil) {

- rb_raise(rb_eFiberError, "double resume");

- return fiber_switch(fibval, argc, argv, 1);

-rb_fiber_yield(int argc, VALUE *argv)

- return rb_fiber_transfer(return_fiber(), argc, argv);

- * fiber.alive? -> true or false

- * Returns true if the fiber can still be resumed (or transferred to).

- * After finishing execution of the fiber block this method will always

-rb_fiber_alive_p(VALUE fibval)

- GetFiberPtr(fibval, fib);

- return fib->status != TERMINATED ? Qtrue : Qfalse;

- * fiber.resume(args, ...) -> obj

- * Resumes the fiber from the point at which the last <code>Fiber.yield</code>

- * was called, or starts running it if it is the first call to

- * <code>resume</code>. Arguments passed to resume will be the value of

- * the <code>Fiber.yield</code> expression or will be passed as block

- * parameters to the fiber's block if this is the first <code>resume</code>.

- * Alternatively, when resume is called it evaluates to the arguments passed

- * to the next <code>Fiber.yield</code> statement inside the fiber's block

- * or to the block value if it runs to completion without any

- * <code>Fiber.yield</code>

-rb_fiber_m_resume(int argc, VALUE *argv, VALUE fib)

- return rb_fiber_resume(fib, argc, argv);

- * fiber.transfer(args, ...) -> obj

- * Transfer control to another fiber, resuming it from where it last

- * stopped or starting it if it was not resumed before. The calling

- * fiber will be suspended much like in a call to <code>Fiber.yield</code>.

- * The fiber which receives the transfer call is treats it much like

- * a resume call. Arguments passed to transfer are treated like those

- * passed to resume.

- * You cannot resume a fiber that transferred control to another one.

- * This will cause a double resume error. You need to transfer control

- * back to this fiber before it can yield and resume.

-rb_fiber_m_transfer(int argc, VALUE *argv, VALUE fib)

- return rb_fiber_transfer(fib, argc, argv);

- * Fiber.yield(args, ...) -> obj

- * Yields control back to the context that resumed the fiber, passing

- * along any arguments that were passed to it. The fiber will resume

- * processing at this point when <code>resume</code> is called next.

- * Any arguments passed to the next <code>resume</code> will be the

- * value that this <code>Fiber.yield</code> expression evaluates to.

-rb_fiber_s_yield(int argc, VALUE *argv, VALUE klass)

- return rb_fiber_yield(argc, argv);

- * Fiber.current() -> fiber

- * Returns the current fiber. You need to <code>require 'fiber'</code>

- * before using this method. If you are not running in the context of

- * a fiber this method will return the root fiber.

-rb_fiber_s_current(VALUE klass)

- return rb_fiber_current();

- * Document-class: FiberError

- * Raised when an invalid operation is attempted on a Fiber, in

- * particular when attempting to call/resume a dead fiber,

- * attempting to yield from the root fiber, or calling a fiber across

- * fiber = Fiber.new{}

- * fiber.resume #=> nil

- * fiber.resume #=> FiberError: dead fiber called

- rb_cFiber = rb_define_class("Fiber", rb_cObject);

- rb_define_alloc_func(rb_cFiber, fiber_alloc);

- rb_eFiberError = rb_define_class("FiberError", rb_eStandardError);

- rb_define_singleton_method(rb_cFiber, "yield", rb_fiber_s_yield, -1);

- rb_define_method(rb_cFiber, "initialize", rb_fiber_init, 0);

- rb_define_method(rb_cFiber, "resume", rb_fiber_m_resume, -1);

-ruby_Init_Continuation_body(void)

- rb_cContinuation = rb_define_class("Continuation", rb_cObject);

- rb_undef_alloc_func(rb_cContinuation);

- rb_undef_method(CLASS_OF(rb_cContinuation), "new");

- rb_define_method(rb_cContinuation, "call", rb_cont_call, -1);

- rb_define_method(rb_cContinuation, "[]", rb_cont_call, -1);

- rb_define_global_function("callcc", rb_callcc, 0);

-ruby_Init_Fiber_as_Coroutine(void)

- rb_define_method(rb_cFiber, "transfer", rb_fiber_m_transfer, -1);

- rb_define_method(rb_cFiber, "alive?", rb_fiber_alive_p, 0);

- rb_define_singleton_method(rb_cFiber, "current", rb_fiber_s_current, 0);

--include uncommon.mk

-DLLWRAP = @DLLWRAP@ --target=@target_os@

- DLL_BASE_NAME := $(LIBRUBY_SO:.dll=)

- DLLWRAP += -mno-cygwin

- VPATH := $(VPATH):$(srcdir)/win32

-EXTOBJS += $(if $(filter-out $(RUBYW_INSTALL_NAME),$(@:$(EXEEXT)=)),$(RUBY_INSTALL_NAME),$(@:$(EXEEXT)=)).res.$(OBJEXT)

-RCFILES = $(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(DLL_BASE_NAME).rc

-RUBYDEF = $(DLL_BASE_NAME).def

-$(RCFILES): $(RBCONFIG)

-$(OBJS) $(MAINOBJ): win32.h

-dir.$(OBJEXT) win32.$(OBJEXT): win32/dir.h

-$(LIBRUBY_SO): $(RUBYDEF)

-$(RUBYDEF): $(LIBRUBY_A) $(PREP) $(RBCONFIG)

- $(MINIRUBY) $(srcdir)/win32/mkexports.rb -output=$@ $(LIBRUBY_A)

-cygwin-$(RUBY_INSTALL_NAME)$(MAJOR)$(MINOR)$(TEENY).dll: $(LIBRUBY_A) $(RUBYDEF)

- @DLLWRAP@ -s --def=$(RUBYDEF) -o $@

- @$(RM) $(RUBY_EXP) $(RCFILES:.rc=.res.@OBJEXT@)

-/**********************************************************************

- created at: 04/08/25 02:31:54 JST

-**********************************************************************/

-#include "ruby/ruby.h"

-#include "ruby/encoding.h"

-#include "ruby/util.h"

-#include "eval_intern.h"

-#include "vm_core.h"

- enum ruby_special_consts special_consts;

- enum ruby_value_type value_type;

- enum ruby_tag_type tag_type;

- enum node_type node_type;

- enum ruby_method_ids method_ids;

- RUBY_ENCODING_INLINE_MAX = ENCODING_INLINE_MAX,

- RUBY_ENCODING_SHIFT = ENCODING_SHIFT,

- RUBY_ENC_CODERANGE_MASK = ENC_CODERANGE_MASK,

- RUBY_ENC_CODERANGE_UNKNOWN = ENC_CODERANGE_UNKNOWN,

- RUBY_ENC_CODERANGE_7BIT = ENC_CODERANGE_7BIT,

- RUBY_ENC_CODERANGE_VALID = ENC_CODERANGE_VALID,

- RUBY_ENC_CODERANGE_BROKEN = ENC_CODERANGE_BROKEN,

- RUBY_FL_MARK = FL_MARK,

- RUBY_FL_RESERVED = FL_RESERVED,

- RUBY_FL_FINALIZE = FL_FINALIZE,

- RUBY_FL_TAINT = FL_TAINT,

- RUBY_FL_UNTRUSTED = FL_UNTRUSTED,

- RUBY_FL_EXIVAR = FL_EXIVAR,

- RUBY_FL_FREEZE = FL_FREEZE,

- RUBY_FL_SINGLETON = FL_SINGLETON,

- RUBY_FL_USER0 = FL_USER0,

- RUBY_FL_USER1 = FL_USER1,

- RUBY_FL_USER2 = FL_USER2,

- RUBY_FL_USER3 = FL_USER3,

- RUBY_FL_USER4 = FL_USER4,

- RUBY_FL_USER5 = FL_USER5,

- RUBY_FL_USER6 = FL_USER6,

- RUBY_FL_USER7 = FL_USER7,

- RUBY_FL_USER8 = FL_USER8,

- RUBY_FL_USER9 = FL_USER9,

- RUBY_FL_USER10 = FL_USER10,

- RUBY_FL_USER11 = FL_USER11,

- RUBY_FL_USER12 = FL_USER12,

- RUBY_FL_USER13 = FL_USER13,

- RUBY_FL_USER14 = FL_USER14,

- RUBY_FL_USER15 = FL_USER15,

- RUBY_FL_USER16 = FL_USER16,

- RUBY_FL_USER17 = FL_USER17,

- RUBY_FL_USER18 = FL_USER18,

- RUBY_FL_USHIFT = FL_USHIFT,

- RUBY_NODE_TYPESHIFT = NODE_TYPESHIFT,

- RUBY_NODE_TYPEMASK = NODE_TYPEMASK,

- RUBY_NODE_LSHIFT = NODE_LSHIFT,

- RUBY_NODE_FL_NEWLINE = NODE_FL_NEWLINE

-} ruby_dummy_gdb_enums;

-const VALUE RUBY_FL_USER19 = FL_USER19;

-const SIGNED_VALUE RUBY_NODE_LMASK = NODE_LMASK;

-const VALUE RUBY_ENCODING_MASK = ENCODING_MASK;

-ruby_debug_print_indent(int level, int debug_level, int indent_level)

- if (level < debug_level) {

- fprintf(stderr, "%*s", indent_level, "");

-ruby_debug_printf(const char *format, ...)

- va_start(ap, format);

- vfprintf(stderr, format, ap);

-ruby_debug_print_value(int level, int debug_level, const char *header, VALUE obj)

- if (level < debug_level) {

- str = rb_inspect(obj);

- fprintf(stderr, "DBG> %s: %s\n", header,

- obj == (VALUE)(SIGNED_VALUE)-1 ? "" : StringValueCStr(str));

-ruby_debug_print_v(VALUE v)

- ruby_debug_print_value(0, 1, "", v);

-ruby_debug_print_id(int level, int debug_level, const char *header, ID id)

- if (level < debug_level) {

- fprintf(stderr, "DBG> %s: %s\n", header, rb_id2name(id));

-ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node)

- if (level < debug_level) {

- fprintf(stderr, "DBG> %s: %s (%u)\n", header,

- ruby_node_name(nd_type(node)), nd_line(node));

- return (NODE *)node;

-ruby_debug_breakpoint(void)

-#ifdef RUBY_DEBUG_ENV

-set_debug_option(const char *str, int len, void *arg)

-#define SET_WHEN(name, var) do { \

- if (len == sizeof(name) - 1 && \

- strncmp(str, name, len) == 0) { \

- SET_WHEN("gc_stress", *ruby_initial_gc_stress_ptr);

- SET_WHEN("core", ruby_enable_coredump);

-#if defined _WIN32 && defined _MSC_VER && _MSC_VER >= 1400

- SET_WHEN("rtc_error", ruby_w32_rtc_error);

- fprintf(stderr, "unexpected debug option: %.*s\n", len, str);

-ruby_set_debug_option(const char *str)

- ruby_each_words(str, set_debug_option, 0);

-/**********************************************************************

- debug.h - YARV Debug function interface

- created at: 04/08/25 02:33:49 JST

-**********************************************************************/

-#ifndef RUBY_DEBUG_H

-#define RUBY_DEBUG_H

-#include "ruby/ruby.h"

-#define dpv(h,v) ruby_debug_print_value(-1, 0, h, v)

-#define dp(v) ruby_debug_print_value(-1, 0, "", v)

-#define dpi(i) ruby_debug_print_id(-1, 0, "", i)

-#define dpn(n) ruby_debug_print_node(-1, 0, "", n)

-#define bp() ruby_debug_breakpoint()

-VALUE ruby_debug_print_value(int level, int debug_level, const char *header, VALUE v);

-ID ruby_debug_print_id(int level, int debug_level, const char *header, ID id);

-NODE *ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node);

-int ruby_debug_print_indent(int level, int debug_level, int indent_level);

-void ruby_debug_breakpoint(void);

-void ruby_debug_gc_check_func(void);

-#ifdef RUBY_DEBUG_ENV

-void ruby_set_debug_option(const char *str);

-#endif /* RUBY_DEBUG_H */

-struct kwtable {const char *name; int id[2]; enum lex_state_e state;};

-const struct kwtable *rb_reserved_word(const char *, unsigned int);

-static const struct kwtable *reserved_word(const char *, unsigned int);

-#define rb_reserved_word(str, len) reserved_word(str, len)

-__ENCODING__, {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END

-__LINE__, {keyword__LINE__, keyword__LINE__}, EXPR_END

-__FILE__, {keyword__FILE__, keyword__FILE__}, EXPR_END

-BEGIN, {keyword_BEGIN, keyword_BEGIN}, EXPR_END

-END, {keyword_END, keyword_END}, EXPR_END

-alias, {keyword_alias, keyword_alias}, EXPR_FNAME

-and, {keyword_and, keyword_and}, EXPR_VALUE

-begin, {keyword_begin, keyword_begin}, EXPR_BEG

-break, {keyword_break, keyword_break}, EXPR_MID

-case, {keyword_case, keyword_case}, EXPR_VALUE

-class, {keyword_class, keyword_class}, EXPR_CLASS

-def, {keyword_def, keyword_def}, EXPR_FNAME

-defined?, {keyword_defined, keyword_defined}, EXPR_ARG

-do, {keyword_do, keyword_do}, EXPR_BEG

-else, {keyword_else, keyword_else}, EXPR_BEG

-elsif, {keyword_elsif, keyword_elsif}, EXPR_VALUE

-end, {keyword_end, keyword_end}, EXPR_END

-ensure, {keyword_ensure, keyword_ensure}, EXPR_BEG

-false, {keyword_false, keyword_false}, EXPR_END

-for, {keyword_for, keyword_for}, EXPR_VALUE

-if, {keyword_if, modifier_if}, EXPR_VALUE

-in, {keyword_in, keyword_in}, EXPR_VALUE

-module, {keyword_module, keyword_module}, EXPR_VALUE

-next, {keyword_next, keyword_next}, EXPR_MID

-nil, {keyword_nil, keyword_nil}, EXPR_END

-not, {keyword_not, keyword_not}, EXPR_ARG

-or, {keyword_or, keyword_or}, EXPR_VALUE

-redo, {keyword_redo, keyword_redo}, EXPR_END

-rescue, {keyword_rescue, modifier_rescue}, EXPR_MID

-retry, {keyword_retry, keyword_retry}, EXPR_END

-return, {keyword_return, keyword_return}, EXPR_MID

-self, {keyword_self, keyword_self}, EXPR_END

-super, {keyword_super, keyword_super}, EXPR_ARG

-then, {keyword_then, keyword_then}, EXPR_BEG

-true, {keyword_true, keyword_true}, EXPR_END

-undef, {keyword_undef, keyword_undef}, EXPR_FNAME

-unless, {keyword_unless, modifier_unless}, EXPR_VALUE

-until, {keyword_until, modifier_until}, EXPR_VALUE

-when, {keyword_when, keyword_when}, EXPR_VALUE

-while, {keyword_while, modifier_while}, EXPR_VALUE

-yield, {keyword_yield, keyword_yield}, EXPR_ARG

-struct kwtable {const char *name; int id[2]; enum lex_state_e state;};

-const struct kwtable *rb_reserved_word(const char *, unsigned int);

-static const struct kwtable *reserved_word(const char *, unsigned int);

-#define rb_reserved_word(str, len) reserved_word(str, len)

-__ENCODING__, {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END

-__LINE__, {keyword__LINE__, keyword__LINE__}, EXPR_END

-__FILE__, {keyword__FILE__, keyword__FILE__}, EXPR_END

-BEGIN, {keyword_BEGIN, keyword_BEGIN}, EXPR_END

-END, {keyword_END, keyword_END}, EXPR_END

-alias, {keyword_alias, keyword_alias}, EXPR_FNAME

-and, {keyword_and, keyword_and}, EXPR_VALUE

-begin, {keyword_begin, keyword_begin}, EXPR_BEG

-break, {keyword_break, keyword_break}, EXPR_MID

-case, {keyword_case, keyword_case}, EXPR_VALUE

-class, {keyword_class, keyword_class}, EXPR_CLASS

-def, {keyword_def, keyword_def}, EXPR_FNAME

-defined?, {keyword_defined, keyword_defined}, EXPR_ARG

-do, {keyword_do, keyword_do}, EXPR_BEG

-else, {keyword_else, keyword_else}, EXPR_BEG

-elsif, {keyword_elsif, keyword_elsif}, EXPR_VALUE

-end, {keyword_end, keyword_end}, EXPR_END

-ensure, {keyword_ensure, keyword_ensure}, EXPR_BEG

-false, {keyword_false, keyword_false}, EXPR_END

-for, {keyword_for, keyword_for}, EXPR_VALUE

-if, {keyword_if, modifier_if}, EXPR_VALUE

-in, {keyword_in, keyword_in}, EXPR_VALUE

-module, {keyword_module, keyword_module}, EXPR_VALUE

-next, {keyword_next, keyword_next}, EXPR_MID

-nil, {keyword_nil, keyword_nil}, EXPR_END

-not, {keyword_not, keyword_not}, EXPR_ARG

-or, {keyword_or, keyword_or}, EXPR_VALUE

-redo, {keyword_redo, keyword_redo}, EXPR_END

-rescue, {keyword_rescue, modifier_rescue}, EXPR_MID

-retry, {keyword_retry, keyword_retry}, EXPR_END

-return, {keyword_return, keyword_return}, EXPR_MID

-self, {keyword_self, keyword_self}, EXPR_END

-super, {keyword_super, keyword_super}, EXPR_ARG

-then, {keyword_then, keyword_then}, EXPR_BEG

-true, {keyword_true, keyword_true}, EXPR_END

-undef, {keyword_undef, keyword_undef}, EXPR_FNAME

-unless, {keyword_unless, modifier_unless}, EXPR_VALUE

-until, {keyword_until, modifier_until}, EXPR_VALUE

-when, {keyword_when, keyword_when}, EXPR_VALUE

-while, {keyword_while, modifier_while}, EXPR_VALUE

-yield, {keyword_yield, keyword_yield}, EXPR_ARG

-# a definition of instruction unification

-putobject putobject

-putobject putstring

-putobject setdynamic

-putstring putstring

-putstring putobject

-putstring setdynamic

-# from tak, ackermann

-# configration file for operand union optimization

-# [insn name] op1, op2 ...

-putobject INT2FIX(0)

-putobject INT2FIX(1)

-send *, *, Qfalse, 0, *

-send *, 0, Qfalse, 0, *

-send *, 1, Qfalse, 0, *

-send *, 2, Qfalse, 0, *

-send *, 3, Qfalse, 0, *

-send *, *, Qfalse, 0x04, *

-send *, 0, Qfalse, 0x04, *

-send *, 1, Qfalse, 0x04, *

-send *, 2, Qfalse, 0x04, *

-send *, 3, Qfalse, 0x04, *

-send *, 0, Qfalse, 0x0c, *

-#include "ruby/ruby.h"

-#include "ruby/encoding.h"

-char *strchr(char*,char);

-#include "ruby/util.h"

-#if !defined HAVE_LSTAT && !defined lstat

-/* define system APIs */

-#define chdir(p) rb_w32_uchdir(p)

-#define mkdir(p, m) rb_w32_umkdir(p, m)

-#define rmdir(p) rb_w32_urmdir(p)

-#if CASEFOLD_FILESYSTEM

-#define FNM_SYSCASE FNM_CASEFOLD

-#define FNM_SYSCASE 0

-# define Next(p, e, enc) (p + rb_enc_mbclen(p, e, enc))

-# define Inc(p, e, enc) ((p) = Next(p, e, enc))

- const char *p, /* pattern (next to '[') */

- const char *s, /* string */

- const int nocase = flags & FNM_CASEFOLD;

- const int escape = !(flags & FNM_NOESCAPE);

- unsigned int c1, c2;

- int ok = 0, not = 0;

- if (*p == '!' || *p == '^') {

- while (*p != ']') {

- const char *t1 = p;

- if (escape && *t1 == '\\')

- p = t1 + (r = rb_enc_mbclen(t1, pend, enc));

- if (p[0] == '-' && p[1] != ']') {

- const char *t2 = p + 1;

- if (escape && *t2 == '\\')

- p = t2 + (r2 = rb_enc_mbclen(t2, pend, enc));

- if ((r <= (send-s) && memcmp(t1, s, r) == 0) ||

- (r2 <= (send-s) && memcmp(t2, s, r) == 0)) {

- c1 = rb_enc_codepoint(s, send, enc);

- if (nocase) c1 = rb_enc_toupper(c1, enc);

- c2 = rb_enc_codepoint(t1, pend, enc);

- if (nocase) c2 = rb_enc_toupper(c2, enc);

- if (c1 < c2) continue;

- c2 = rb_enc_codepoint(t2, pend, enc);

- if (nocase) c2 = rb_enc_toupper(c2, enc);

- if (c1 > c2) continue;

- if (r <= (send-s) && memcmp(t1, s, r) == 0) {

- if (!nocase) continue;

- c1 = rb_enc_toupper(rb_enc_codepoint(s, send, enc), enc);

- c2 = rb_enc_toupper(rb_enc_codepoint(p, pend, enc), enc);

- if (c1 != c2) continue;

- return ok == not ? NULL : (char *)p + 1;

-/* If FNM_PATHNAME is set, only path element will be matched. (upto '/' or '\0')

- Otherwise, entire string will be matched.

- End marker itself won't be compared.

- And if function succeeds, *pcur reaches end marker.

-#define UNESCAPE(p) (escape && *(p) == '\\' ? (p) + 1 : (p))

-#define ISEND(p) (!*(p) || (pathname && *(p) == '/'))

-#define RETURN(val) return *pcur = p, *scur = s, (val);

- const char **pcur, /* pattern */

- const char **scur, /* string */

- const int period = !(flags & FNM_DOTMATCH);

- const int pathname = flags & FNM_PATHNAME;

- const int escape = !(flags & FNM_NOESCAPE);

- const int nocase = flags & FNM_CASEFOLD;

- const char *ptmp = 0;

- const char *stmp = 0;

- const char *p = *pcur;

- const char *pend = p + strlen(p);

- const char *s = *scur;

- const char *send = s + strlen(s);

- if (period && *s == '.' && *UNESCAPE(p) != '.') /* leading period */

- RETURN(FNM_NOMATCH);

- do { p++; } while (*p == '*');

- if (ISEND(UNESCAPE(p))) {

- RETURN(FNM_NOMATCH);

- Inc(s, send, enc);

- RETURN(FNM_NOMATCH);

- if ((t = bracket(p + 1, pend, s, send, flags, enc)) != 0) {

- Inc(s, send, enc);

- RETURN(ISEND(p) ? 0 : FNM_NOMATCH);

- r = rb_enc_precise_mbclen(p, pend, enc);

- if (!MBCLEN_CHARFOUND_P(r))

- if (r <= (send-s) && memcmp(p, s, r) == 0) {

- if (!nocase) goto failed;

- if (rb_enc_toupper(rb_enc_codepoint(p, pend, enc), enc) !=

- rb_enc_toupper(rb_enc_codepoint(s, send, enc), enc))

- Inc(s, send, enc);

- failed: /* try next '*' position */

- if (ptmp && stmp) {

- Inc(stmp, send, enc); /* !ISEND(*stmp) */

- RETURN(FNM_NOMATCH);

- const char *pattern,

- const char *string,

- const char *p = pattern;

- const char *s = string;

- const char *send = s + strlen(string);

- const int period = !(flags & FNM_DOTMATCH);

- const int pathname = flags & FNM_PATHNAME;

- const char *ptmp = 0;

- const char *stmp = 0;

- if (p[0] == '*' && p[1] == '*' && p[2] == '/') {

- do { p += 3; } while (p[0] == '*' && p[1] == '*' && p[2] == '/');

- if (fnmatch_helper(&p, &s, flags, enc) == 0) {

- while (*s && *s != '/') Inc(s, send, enc);

- /* failed : try next recursion */

- if (ptmp && stmp && !(period && *stmp == '.')) {

- while (*stmp && *stmp != '/') Inc(stmp, send, enc);

- return fnmatch_helper(&p, &s, flags, enc);

-dir_mark(void *ptr)

- struct dir_data *dir = ptr;

- rb_gc_mark(dir->path);

-dir_free(void *ptr)

- struct dir_data *dir = ptr;

- if (dir->dir) closedir(dir->dir);

-dir_memsize(const void *ptr)

- return ptr ? sizeof(struct dir_data) : 0;

-static const rb_data_type_t dir_data_type = {

- dir_mark, dir_free, dir_memsize

-static VALUE dir_close(VALUE);

-#define GlobPathValue(str, safe) \

- /* can contain null bytes as separators */ \

- (!RB_TYPE_P(str, T_STRING) ? \

- FilePathValue(str) : \

- (check_safe_glob(str, safe), \

- check_glob_encoding(str), (str)))

-#define check_safe_glob(str, safe) ((safe) ? rb_check_safe_obj(str) : (void)0)

-#define check_glob_encoding(str) rb_enc_check((str), rb_enc_from_encoding(rb_usascii_encoding()))

-dir_s_alloc(VALUE klass)

- VALUE obj = TypedData_Make_Struct(klass, struct dir_data, &dir_data_type, dirp);

- dirp->path = Qnil;

-dir_initialize(int argc, VALUE *argv, VALUE dir)

- rb_encoding *fsenc;

- VALUE dirname, opt;

- static VALUE sym_enc;

- sym_enc = ID2SYM(rb_intern("encoding"));

- fsenc = rb_filesystem_encoding();

- rb_scan_args(argc, argv, "11", &dirname, &opt);

- if (!NIL_P(opt)) {

- VALUE v, enc=Qnil;

- opt = rb_convert_type(opt, T_HASH, "Hash", "to_hash");

- v = rb_hash_aref(opt, sym_enc);

- if (!NIL_P(v)) enc = v;

- if (!NIL_P(enc)) {

- fsenc = rb_to_encoding(enc);

- GlobPathValue(dirname, FALSE);

- TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dp);

- dp->dir = opendir(RSTRING_PTR(dirname));

- rb_sys_fail(RSTRING_PTR(dirname));

- dp->path = rb_str_dup_frozen(dirname);

- * Dir.open( string ) -> aDir

- * Dir.open( string ) {| aDir | block } -> anObject

-dir_s_open(int argc, VALUE *argv, VALUE klass)

- VALUE dir = TypedData_Make_Struct(klass, struct dir_data, &dir_data_type, dp);

- dir_initialize(argc, argv, dir);

-static struct dir_data *

-dir_check(VALUE dir)

- struct dir_data *dirp;

- if (!OBJ_UNTRUSTED(dir) && rb_safe_level() >= 4)

- rb_raise(rb_eSecurityError, "Insecure: operation on trusted Dir");

- rb_check_frozen(dir);

- dirp = rb_check_typeddata(dir, &dir_data_type);

- if (!dirp->dir) dir_closed();

-#define GetDIR(obj, dirp) (dirp = dir_check(obj))

- * dir.inspect -> string

- * Return a string describing this Dir object.

-dir_inspect(VALUE dir)

- struct dir_data *dirp;

- TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);

- if (!NIL_P(dirp->path)) {

- const char *c = rb_obj_classname(dir);

- return rb_sprintf("#<%s:%s>", c, RSTRING_PTR(dirp->path));

- return rb_funcall(dir, rb_intern("to_s"), 0, 0);

- * dir.path -> string or nil

-dir_path(VALUE dir)

- TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);

- if (NIL_P(dirp->path)) return Qnil;

- return rb_str_dup(dirp->path);

-#if defined HAVE_READDIR_R

-# define READDIR(dir, enc, entry, dp) (readdir_r(dir, entry, &(dp)) == 0 && dp != 0)

-#elif defined _WIN32

-# define READDIR(dir, enc, entry, dp) ((dp = rb_w32_readdir_with_enc(dir, enc)) != 0)

-# define READDIR(dir, enc, entry, dp) ((dp = readdir(dir)) != 0)

-#if defined HAVE_READDIR_R

-# define IF_HAVE_READDIR_R(something) something

-# define IF_HAVE_READDIR_R(something) /* nothing */

-#if defined SIZEOF_STRUCT_DIRENT_TOO_SMALL

-# include <limits.h>

-# define NAME_MAX_FOR_STRUCT_DIRENT 255

-# if defined NAME_MAX

-# if NAME_MAX_FOR_STRUCT_DIRENT < NAME_MAX

-# undef NAME_MAX_FOR_STRUCT_DIRENT

-# define NAME_MAX_FOR_STRUCT_DIRENT NAME_MAX

-# if defined _POSIX_NAME_MAX

-# if NAME_MAX_FOR_STRUCT_DIRENT < _POSIX_NAME_MAX

-# undef NAME_MAX_FOR_STRUCT_DIRENT

-# define NAME_MAX_FOR_STRUCT_DIRENT _POSIX_NAME_MAX

-# if defined _XOPEN_NAME_MAX

-# if NAME_MAX_FOR_STRUCT_DIRENT < _XOPEN_NAME_MAX

-# undef NAME_MAX_FOR_STRUCT_DIRENT

-# define NAME_MAX_FOR_STRUCT_DIRENT _XOPEN_NAME_MAX

-# define DEFINE_STRUCT_DIRENT \

- struct dirent dirent; \

- char dummy[offsetof(struct dirent, d_name) + \

- NAME_MAX_FOR_STRUCT_DIRENT + 1]; \

-# define STRUCT_DIRENT(entry) ((entry).dirent)

-# define DEFINE_STRUCT_DIRENT struct dirent

-# define STRUCT_DIRENT(entry) (entry)

- * dir.read -> string or nil

-dir_read(VALUE dir)

- IF_HAVE_READDIR_R(DEFINE_STRUCT_DIRENT entry);

- if (READDIR(dirp->dir, dirp->enc, &STRUCT_DIRENT(entry), dp)) {

- return rb_external_str_new_with_enc(dp->d_name, NAMLEN(dp), dirp->enc);

- * dir.each { |filename| block } -> dir

- * dir.each -> an_enumerator

- * If no block is given, an enumerator is returned instead.

-dir_each(VALUE dir)

- IF_HAVE_READDIR_R(DEFINE_STRUCT_DIRENT entry);

- RETURN_ENUMERATOR(dir, 0, 0);

- rewinddir(dirp->dir);

- while (READDIR(dirp->dir, dirp->enc, &STRUCT_DIRENT(entry), dp)) {

- rb_yield(rb_external_str_new_with_enc(dp->d_name, NAMLEN(dp), dirp->enc));

-#ifdef HAVE_TELLDIR

- * dir.pos -> integer

- * dir.tell -> integer

-dir_tell(VALUE dir)

-#define dir_tell rb_f_notimplement

-#ifdef HAVE_SEEKDIR

- * dir.seek( integer ) -> dir

-dir_seek(VALUE dir, VALUE pos)

- long p = NUM2LONG(pos);

- seekdir(dirp->dir, p);

-#define dir_seek rb_f_notimplement

- * dir.pos( integer ) -> integer

-dir_set_pos(VALUE dir, VALUE pos)

- * dir.rewind -> dir

-dir_rewind(VALUE dir)

- if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(dir)) {

- rb_raise(rb_eSecurityError, "Insecure: can't close");

- * dir.close -> nil

-dir_close(VALUE dir)

-dir_chdir(VALUE path)

- path = rb_str_encode_ospath(path);

- if (chdir(RSTRING_PTR(path)) < 0)

- rb_sys_fail(RSTRING_PTR(path));

-struct chdir_data {

- VALUE old_path, new_path;

-chdir_yield(struct chdir_data *args)

- dir_chdir(args->new_path);

- args->done = TRUE;

- if (chdir_thread == Qnil)

- chdir_thread = rb_thread_current();

- return rb_yield(args->new_path);

-chdir_restore(struct chdir_data *args)

- if (chdir_blocking == 0)

- chdir_thread = Qnil;

- dir_chdir(args->old_path);

- * Dir.chdir( [ string] ) -> 0

- * Dir.chdir( [ string] ) {| path | block } -> anObject

-dir_s_chdir(int argc, VALUE *argv, VALUE obj)

- FilePathValue(path);

- const char *dist = getenv("HOME");

- path = rb_str_new2(dist);

- struct chdir_data args;

- args.old_path = rb_tainted_str_new2(cwd); xfree(cwd);

- args.new_path = path;

- args.done = FALSE;

- return rb_ensure(chdir_yield, (VALUE)&args, chdir_restore, (VALUE)&args);

- path = my_getcwd();

- cwd = rb_tainted_str_new2(path);

- rb_enc_associate(cwd, rb_filesystem_encoding());

- * Dir.getwd -> string

- * Dir.pwd -> string

-dir_s_getwd(VALUE dir)

- return rb_dir_getwd();

-check_dirname(volatile VALUE *dir)

- FilePathValue(*dir);

- path = RSTRING_PTR(*dir);

-#if defined(HAVE_CHROOT)

- * Dir.chroot( string ) -> 0

-dir_s_chroot(VALUE dir, VALUE path)

- path = rb_str_encode_ospath(path);

- if (chroot(RSTRING_PTR(path)) == -1)

- rb_sys_fail(RSTRING_PTR(path));

-#define dir_s_chroot rb_f_notimplement

- * Dir.mkdir( string [, integer] ) -> 0

-dir_s_mkdir(int argc, VALUE *argv, VALUE obj)

- path = rb_str_encode_ospath(path);

- if (mkdir(RSTRING_PTR(path), mode) == -1)

- rb_sys_fail(RSTRING_PTR(path));

- * Dir.delete( string ) -> 0

- * Dir.rmdir( string ) -> 0

- * Dir.unlink( string ) -> 0

-dir_s_rmdir(VALUE obj, VALUE dir)

- dir = rb_str_encode_ospath(dir);

- if (rmdir(RSTRING_PTR(dir)) < 0)

- rb_sys_fail(RSTRING_PTR(dir));

-sys_warning_1(VALUE mesg)

- rb_sys_warning("%s", (const char *)mesg);

-#define GLOB_VERBOSE (1U << (sizeof(int) * CHAR_BIT - 1))

-#define sys_warning(val) \

- (void)((flags & GLOB_VERBOSE) && rb_protect(sys_warning_1, (VALUE)(val), 0))

-#define GLOB_ALLOC(type) (type *)malloc(sizeof(type))

-#define GLOB_ALLOC_N(type, n) (type *)malloc(sizeof(type) * (n))

-#define GLOB_FREE(ptr) free(ptr)

-#define GLOB_JUMP_TAG(status) ((status == -1) ? rb_memerror() : rb_jump_tag(status))

- * ENOTDIR can be returned by stat(2) if a non-leaf element of the path

- * is not a directory.

-#define to_be_ignored(e) ((e) == ENOENT || (e) == ENOTDIR)

-/* System call with warning */

-do_stat(const char *path, struct stat *pst, int flags)

- int ret = stat(path, pst);

- if (ret < 0 && !to_be_ignored(errno))

- sys_warning(path);

-do_lstat(const char *path, struct stat *pst, int flags)

- int ret = lstat(path, pst);

- if (ret < 0 && !to_be_ignored(errno))

- sys_warning(path);

-do_opendir(const char *path, int flags)

- DIR *dirp = opendir(path);

- if (dirp == NULL && !to_be_ignored(errno))

- sys_warning(path);

-has_magic(const char *p, const char *pend, int flags, rb_encoding *enc)

- const int escape = !(flags & FNM_NOESCAPE);

- const int nocase = flags & FNM_CASEFOLD;

- while (p < pend && (c = *p++) != 0) {

- if (escape && !(c = *p++))

- if (!FNM_SYSCASE && ISALPHA(c) && nocase)

- p = Next(p-1, pend, enc);

-/* Find separator in globbing pattern. */

-find_dirsep(const char *p, const char *pend, int flags, rb_encoding *enc)

- const int escape = !(flags & FNM_NOESCAPE);

- while ((c = *p++) != 0) {

- return (char *)p-1;

- if (escape && !(c = *p++))

- return (char *)p-1;

- p = Next(p-1, pend, enc);

- return (char *)p-1;

-/* Remove escaping backslashes */

-remove_backslashes(char *p, rb_encoding *enc)

- register const char *pend = p + strlen(p);

- memmove(t, s, p - s);

- Inc(p, pend, enc);

- memmove(t, s, p - s); /* move '\0' too */

-/* Globing pattern */

-enum glob_pattern_type { PLAIN, MAGICAL, RECURSIVE, MATCH_ALL, MATCH_DIR };

-struct glob_pattern {

- enum glob_pattern_type type;

- struct glob_pattern *next;

-static void glob_free_pattern(struct glob_pattern *list);

-static struct glob_pattern *

-glob_make_pattern(const char *p, const char *e, int flags, rb_encoding *enc)

- struct glob_pattern *list, *tmp, **tail = &list;

- int dirsep = 0; /* pattern is terminated with '/' */

- while (p < e && *p) {

- tmp = GLOB_ALLOC(struct glob_pattern);

- if (!tmp) goto error;

- if (p[0] == '*' && p[1] == '*' && p[2] == '/') {

- /* fold continuous RECURSIVEs (needed in glob_helper) */

- do { p += 3; while (*p == '/') p++; } while (p[0] == '*' && p[1] == '*' && p[2] == '/');

- tmp->type = RECURSIVE;

- const char *m = find_dirsep(p, e, flags, enc);

- int magic = has_magic(p, m, flags, enc);

- if (!magic && *m) {

- while (!has_magic(m+1, m2 = find_dirsep(m+1, e, flags, enc), flags, enc) &&

- buf = GLOB_ALLOC_N(char, m-p+1);

- memcpy(buf, p, m-p);

- tmp->type = magic ? MAGICAL : PLAIN;

- tail = &tmp->next;

- tmp = GLOB_ALLOC(struct glob_pattern);

- glob_free_pattern(list);

- tmp->type = dirsep ? MATCH_DIR : MATCH_ALL;

-glob_free_pattern(struct glob_pattern *list)

- struct glob_pattern *tmp = list;

- list = list->next;

- GLOB_FREE(tmp->str);

-join_path(const char *path, int dirsep, const char *name)

- long len = strlen(path);

- long len2 = strlen(name)+(dirsep?1:0)+1;

- char *buf = GLOB_ALLOC_N(char, len+len2);

- if (!buf) return 0;

- memcpy(buf, path, len);

- strlcat(buf+len, name, len2);

-enum answer { YES, NO, UNKNOWN };

-# define S_ISLNK(m) (0)

-# define S_ISLNK(m) ((m & S_IFMT) == S_IFLNK)

- void (*func)(const char *, VALUE, void *);

-glob_func_caller(VALUE val)

- (*args->func)(args->path, args->value, args->enc);

-#define glob_call_func(func, path, arg, enc) (*func)(path, arg, enc)

- int dirsep, /* '/' should be placed before appending child entry's name to 'path'. */

- enum answer exist, /* Does 'path' indicate an existing entry? */

- enum answer isdir, /* Does 'path' indicate a directory or a symlink to a directory? */

- struct glob_pattern **beg,

- struct glob_pattern **end,

- ruby_glob_func *func,

- struct glob_pattern **cur, **new_beg, **new_end;

- int plain = 0, magical = 0, recursive = 0, match_all = 0, match_dir = 0;

- int escape = !(flags & FNM_NOESCAPE);

- for (cur = beg; cur < end; ++cur) {

- struct glob_pattern *p = *cur;

- if (p->type == RECURSIVE) {

- switch (p->type) {

- rb_bug("continuous RECURSIVEs");

- if (match_all && exist == UNKNOWN) {

- if (do_lstat(path, &st, flags) == 0) {

- isdir = S_ISDIR(st.st_mode) ? YES : S_ISLNK(st.st_mode) ? UNKNOWN : NO;

- if (match_dir && isdir == UNKNOWN) {

- if (do_stat(path, &st, flags) == 0) {

- isdir = S_ISDIR(st.st_mode) ? YES : NO;

- if (match_all && exist == YES) {

- status = glob_call_func(func, path, arg, enc);

- if (status) return status;

- if (match_dir && isdir == YES) {

- char *tmp = join_path(path, dirsep, "");

- if (!tmp) return -1;

- status = glob_call_func(func, tmp, arg, enc);

- if (status) return status;

- if (exist == NO || isdir == NO) return 0;

- if (magical || recursive) {

- struct dirent *dp;

- IF_HAVE_READDIR_R(DEFINE_STRUCT_DIRENT entry);

- dirp = do_opendir(*path ? path : ".", flags);

- if (dirp == NULL) return 0;

- while (READDIR(dirp, enc, &STRUCT_DIRENT(entry), dp)) {

- char *buf = join_path(path, dirsep, dp->d_name);

- enum answer new_isdir = UNKNOWN;

- if (recursive && strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0

- && fnmatch("*", rb_usascii_encoding(), dp->d_name, flags) == 0) {

- if (do_lstat(buf, &st, flags) == 0)

- new_isdir = S_ISDIR(st.st_mode) ? YES : S_ISLNK(st.st_mode) ? UNKNOWN : NO;

- new_isdir = dp->d_isdir ? (!dp->d_isrep ? YES : UNKNOWN) : NO;

- new_beg = new_end = GLOB_ALLOC_N(struct glob_pattern *, (end - beg) * 2);

- for (cur = beg; cur < end; ++cur) {

- struct glob_pattern *p = *cur;

- if (p->type == RECURSIVE) {

- if (new_isdir == YES) /* not symlink but real directory */

- *new_end++ = p; /* append recursive pattern */

- p = p->next; /* 0 times recursion */

- if (p->type == PLAIN || p->type == MAGICAL) {

- if (fnmatch(p->str, enc, dp->d_name, flags) == 0)

- *new_end++ = p->next;

- status = glob_helper(buf, 1, YES, new_isdir, new_beg, new_end,

- flags, func, arg, enc);

- GLOB_FREE(new_beg);

- if (status) break;

- struct glob_pattern **copy_beg, **copy_end, **cur2;

- copy_beg = copy_end = GLOB_ALLOC_N(struct glob_pattern *, end - beg);

- if (!copy_beg) return -1;

- for (cur = beg; cur < end; ++cur)

- *copy_end++ = (*cur)->type == PLAIN ? *cur : 0;

- for (cur = copy_beg; cur < copy_end; ++cur) {

- size_t len = strlen((*cur)->str) + 1;

- name = GLOB_ALLOC_N(char, len);

- memcpy(name, (*cur)->str, len);

- if (escape) remove_backslashes(name, enc);

- new_beg = new_end = GLOB_ALLOC_N(struct glob_pattern *, end - beg);

- *new_end++ = (*cur)->next;

- for (cur2 = cur + 1; cur2 < copy_end; ++cur2) {

- if (*cur2 && fnmatch((*cur2)->str, enc, name, flags) == 0) {

- *new_end++ = (*cur2)->next;

- buf = join_path(path, dirsep, name);

- GLOB_FREE(new_beg);

- status = glob_helper(buf, 1, UNKNOWN, UNKNOWN, new_beg,

- new_end, flags, func, arg, enc);

- GLOB_FREE(new_beg);

- if (status) break;

- GLOB_FREE(copy_beg);

-ruby_glob0(const char *path, int flags, ruby_glob_func *func, VALUE arg, rb_encoding *enc)

- struct glob_pattern *list;

- const char *root, *start;

- start = root = path;

- flags |= FNM_SYSCASE;

- root = rb_path_skip_prefix(root);

- if (root && *root == '/') root++;

- buf = GLOB_ALLOC_N(char, n + 1);

- if (!buf) return -1;

- MEMCPY(buf, start, char, n);

- list = glob_make_pattern(root, root + strlen(root), flags, enc);

- status = glob_helper(buf, 0, UNKNOWN, UNKNOWN, &list, &list + 1, flags, func, arg, enc);

- glob_free_pattern(list);

-ruby_glob(const char *path, int flags, ruby_glob_func *func, VALUE arg)

- return ruby_glob0(path, flags & ~GLOB_VERBOSE, func, arg,

- rb_ascii8bit_encoding());

-rb_glob_caller(const char *path, VALUE a, void *enc)

- struct glob_args *args = (struct glob_args *)a;

- args->path = path;

- rb_protect(glob_func_caller, a, &status);

-rb_glob2(const char *path, int flags,

- void (*func)(const char *, VALUE, void *), VALUE arg,

- struct glob_args args;

- if (flags & FNM_SYSCASE) {

- rb_warning("Dir.glob() ignores File::FNM_CASEFOLD");

- return ruby_glob0(path, flags | GLOB_VERBOSE, rb_glob_caller, (VALUE)&args,

-rb_glob(const char *path, void (*func)(const char *, VALUE, void *), VALUE arg)

- int status = rb_glob2(path, 0, func, arg, rb_ascii8bit_encoding());

- if (status) GLOB_JUMP_TAG(status);

-push_pattern(const char *path, VALUE ary, void *enc)

- rb_ary_push(ary, rb_external_str_new_with_enc(path, strlen(path), enc));

-ruby_brace_expand(const char *str, int flags, ruby_glob_func *func, VALUE arg,

- const int escape = !(flags & FNM_NOESCAPE);

- const char *p = str;

- const char *pend = p + strlen(p);

- const char *s = p;

- const char *lbrace = 0, *rbrace = 0;

- int nest = 0, status = 0;

- if (*p == '{' && nest++ == 0) {

- if (*p == '}' && --nest <= 0) {

- if (*p == '\\' && escape) {

- Inc(p, pend, enc);

- size_t len = strlen(s) + 1;

- char *buf = GLOB_ALLOC_N(char, len);

- if (!buf) return -1;

- shift = (lbrace-s);

- while (p < rbrace) {

- const char *t = ++p;

- while (p < rbrace && !(*p == ',' && nest == 0)) {

- if (*p == '{') nest++;

- if (*p == '}') nest--;

- if (*p == '\\' && escape) {

- if (++p == rbrace) break;

- Inc(p, pend, enc);

- memcpy(buf+shift, t, p-t);

- strlcpy(buf+shift+(p-t), rbrace+1, len-(shift+(p-t)));

- status = ruby_brace_expand(buf, flags, func, arg, enc);

- if (status) break;

- else if (!lbrace && !rbrace) {

- status = (*func)(s, arg, enc);

-struct brace_args {

- ruby_glob_func *func;

-glob_brace(const char *path, VALUE val, void *enc)

- struct brace_args *arg = (struct brace_args *)val;

- return ruby_glob0(path, arg->flags, arg->func, arg->value, enc);

-ruby_brace_glob0(const char *str, int flags, ruby_glob_func *func, VALUE arg,

- struct brace_args args;

- args.flags = flags;

- return ruby_brace_expand(str, flags, glob_brace, (VALUE)&args, enc);

-ruby_brace_glob(const char *str, int flags, ruby_glob_func *func, VALUE arg)

- return ruby_brace_glob0(str, flags & ~GLOB_VERBOSE, func, arg,

- rb_ascii8bit_encoding());

-ruby_brace_glob_with_enc(const char *str, int flags, ruby_glob_func *func, VALUE arg, rb_encoding *enc)

- return ruby_brace_glob0(str, flags & ~GLOB_VERBOSE, func, arg, enc);

-push_glob(VALUE ary, VALUE str, int flags)

- struct glob_args args;

- rb_encoding *enc = rb_enc_get(str);

- if (enc == rb_usascii_encoding()) enc = rb_filesystem_encoding();

- args.func = push_pattern;

- return ruby_brace_glob0(RSTRING_PTR(str), flags | GLOB_VERBOSE,

- rb_glob_caller, (VALUE)&args, enc);

-rb_push_glob(VALUE str, int flags) /* '\0' is delimiter */

- GlobPathValue(str, TRUE);

- ary = rb_ary_new();

- while (offset < RSTRING_LEN(str)) {

- p = RSTRING_PTR(str) + offset;

- status = push_glob(ary, rb_enc_str_new(p, strlen(p), rb_enc_get(str)),

- if (status) GLOB_JUMP_TAG(status);

- if (offset >= RSTRING_LEN(str)) break;

- p += strlen(p) + 1;

- pend = RSTRING_PTR(str) + RSTRING_LEN(str);

- while (p < pend && !*p)

- offset = p - RSTRING_PTR(str);

-dir_globs(long argc, VALUE *argv, int flags)

- VALUE ary = rb_ary_new();

- for (i = 0; i < argc; ++i) {

- VALUE str = argv[i];

- GlobPathValue(str, TRUE);

- status = push_glob(ary, str, flags);

- if (status) GLOB_JUMP_TAG(status);

- * Dir[ array ] -> array

- * Dir[ string [, string ...] ] -> array

- * <code>Dir.glob(</code>array,<code>0)</code> and

- * <code>Dir.glob([</code>string,...<code>],0)</code>.

-dir_s_aref(int argc, VALUE *argv, VALUE obj)

- return rb_push_glob(argv[0], 0);

- return dir_globs(argc, argv, 0);

- * Dir.glob( pattern, [flags] ) -> array

- * Dir.glob( pattern, [flags] ) {| filename | block } -> nil

- * Returns the filenames found by expanding pattern which is

- * an +Array+ of the patterns or the pattern +String+, either as an

- * array or as parameters to the block. Note that this pattern

- * is not a regexp (it's closer to a shell glob). See

- * <code>File::fnmatch</code> for the meaning of the flags

- * parameter. Note that case sensitivity depends on your system (so

- * <code>File::FNM_CASEFOLD</code> is ignored)

- * <code>*</code>:: Matches any file. Can be restricted by

- * other values in the glob. <code>*</code>

- * will match all files; <code>c*</code> will

- * match all files beginning with

- * <code>c</code>; <code>*c</code> will match

- * all files ending with <code>c</code>; and

- * <code>\*c\*</code> will match all files that

- * have <code>c</code> in them (including at

- * the beginning or end). Equivalent to

- * <code>/ .* /x</code> in regexp. Note, this

- * will not match Unix-like hidden files (dotfiles).

- * In order to include those in the match results,

- * you must use something like "{*,.*}".

- * <code>**</code>:: Matches directories recursively.

- * <code>?</code>:: Matches any one character. Equivalent to

- * <code>/.{1}/</code> in regexp.

- * <code>[set]</code>:: Matches any one character in +set+.

- * Behaves exactly like character sets in

- * Regexp, including set negation

- * (<code>[^a-z]</code>).

- * <code>{p,q}</code>:: Matches either literal <code>p</code> or

- * literal <code>q</code>. Matching literals

- * may be more than one character in length.

- * More than two literals may be specified.

- * Equivalent to pattern alternation in

- * <code>\</code>:: Escapes the next metacharacter.

- * Note that this means you cannot use backslash in windows

- * as part of a glob, i.e. Dir["c:\\foo*"] will not work

- * use Dir["c:/foo*"] instead

- * rbfiles = File.join("**", "*.rb")

- * Dir.glob(rbfiles) #=> ["main.rb",

- * # "lib/song.rb",

- * # "lib/song/karaoke.rb"]

- * libdirs = File.join("**", "lib")

- * Dir.glob(libdirs) #=> ["lib"]

- * librbfiles = File.join("**", "lib", "**", "*.rb")

- * Dir.glob(librbfiles) #=> ["lib/song.rb",

- * # "lib/song/karaoke.rb"]

- * librbfiles = File.join("**", "lib", "*.rb")

- * Dir.glob(librbfiles) #=> ["lib/song.rb"]

-dir_s_glob(int argc, VALUE *argv, VALUE obj)

- VALUE str, rflags, ary;

- ary = rb_check_array_type(str);

- ary = rb_push_glob(str, flags);

- volatile VALUE v = ary;

- ary = dir_globs(RARRAY_LEN(v), RARRAY_PTR(v), flags);

- if (rb_block_given_p()) {

-dir_open_dir(int argc, VALUE *argv)

- VALUE dir = rb_funcall2(rb_cDir, rb_intern("open"), argc, argv);

- struct dir_data *dirp;

- TypedData_Get_Struct(dir, struct dir_data, &dir_data_type, dirp);

- * Dir.foreach( dirname ) {| filename | block } -> nil

- * Dir.foreach( dirname ) -> an_enumerator

- * If no block is given, an enumerator is returned instead.

-dir_foreach(int argc, VALUE *argv, VALUE io)

- RETURN_ENUMERATOR(io, argc, argv);

- dir = dir_open_dir(argc, argv);

- * Dir.entries( dirname ) -> array

-dir_entries(int argc, VALUE *argv, VALUE io)

- dir = dir_open_dir(argc, argv);

- * File.fnmatch( pattern, path, [flags] ) -> (true or false)

- * File.fnmatch?( pattern, path, [flags] ) -> (true or false)

- * <code>*</code>:: Matches any file. Can be restricted by

- * other values in the glob. <code>*</code>

- * will match all files; <code>c*</code> will

- * match all files beginning with

- * <code>c</code>; <code>*c</code> will match

- * all files ending with <code>c</code>; and

- * <code>*c*</code> will match all files that

- * have <code>c</code> in them (including at

- * the beginning or end). Equivalent to

- * <code>/ .* /x</code> in regexp.

- * <code>**</code>:: Matches directories recursively or files

- * <code>?</code>:: Matches any one character. Equivalent to

- * <code>/.{1}/</code> in regexp.

- * <code>[set]</code>:: Matches any one character in +set+.

- * Behaves exactly like character sets in

- * Regexp, including set negation

- * (<code>[^a-z]</code>).

- * <code>\</code>:: Escapes the next metacharacter.

- * flags is a bitwise OR of the <code>FNM_xxx</code>

- * parameters. The same glob pattern and flags are used by

- * <code>Dir::glob</code>.

- * File.fnmatch('cat', 'cat') #=> true # match entire string

- * File.fnmatch('cat', 'category') #=> false # only match partial string

- * File.fnmatch('c{at,ub}s', 'cats') #=> false # { } isn't supported

- * File.fnmatch('c?t', 'cat') #=> true # '?' match only 1 character

- * File.fnmatch('c??t', 'cat') #=> false # ditto

- * File.fnmatch('c*', 'cats') #=> true # '*' match 0 or more characters

- * File.fnmatch('c*t', 'c/a/b/t') #=> true # ditto

- * File.fnmatch('ca[a-z]', 'cat') #=> true # inclusive bracket expression

- * File.fnmatch('ca[^t]', 'cat') #=> false # exclusive bracket expression ('^' or '!')

- * File.fnmatch('cat', 'CAT') #=> false # case sensitive

- * File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true # case insensitive

- * File.fnmatch('?', '/', File::FNM_PATHNAME) #=> false # wildcard doesn't match '/' on FNM_PATHNAME

- * File.fnmatch('*', '/', File::FNM_PATHNAME) #=> false # ditto

- * File.fnmatch('[/]', '/', File::FNM_PATHNAME) #=> false # ditto

- * File.fnmatch('\?', '?') #=> true # escaped wildcard becomes ordinary

- * File.fnmatch('\a', 'a') #=> true # escaped ordinary remains ordinary

- * File.fnmatch('\a', '\a', File::FNM_NOESCAPE) #=> true # FNM_NOESACPE makes '\' ordinary

- * File.fnmatch('[\?]', '?') #=> true # can escape inside bracket expression

- * File.fnmatch('*', '.profile') #=> false # wildcard doesn't match leading

- * File.fnmatch('*', '.profile', File::FNM_DOTMATCH) #=> true # period by default.

- * File.fnmatch('.*', '.profile') #=> true

- * rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.

- * File.fnmatch(rbfiles, 'main.rb') #=> false

- * File.fnmatch(rbfiles, './main.rb') #=> false

- * File.fnmatch(rbfiles, 'lib/song.rb') #=> true

- * File.fnmatch('**.rb', 'main.rb') #=> true

- * File.fnmatch('**.rb', './main.rb') #=> false

- * File.fnmatch('**.rb', 'lib/song.rb') #=> true

- * File.fnmatch('*', 'dave/.profile') #=> true

- * pattern = '*' '/' '*'

- * File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME) #=> false

- * File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

- * pattern = '**' '/' 'foo'

- * File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME) #=> true

- * File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME) #=> true

- * File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME) #=> true

- * File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME) #=> false

- * File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true

-file_s_fnmatch(int argc, VALUE *argv, VALUE obj)

- FilePathStringValue(path);

- if (fnmatch(RSTRING_PTR(pattern), rb_enc_get(pattern), RSTRING_PTR(path),

-VALUE rb_home_dir(const char *user, VALUE result);

- * Dir.home() -> "/home/me"

- * Dir.home("root") -> "/root"

- * Returns the home directory of the current user or the named user

-dir_s_home(int argc, VALUE *argv, VALUE obj)

- const char *u = 0;

- rb_scan_args(argc, argv, "01", &user);

- if (!NIL_P(user)) {

- SafeStringValue(user);

- u = StringValueCStr(user);

- return rb_home_dir(u, rb_str_new(0, 0));

- rb_define_singleton_method(rb_cDir, "open", dir_s_open, -1);

- rb_define_singleton_method(rb_cDir, "foreach", dir_foreach, -1);

- rb_define_singleton_method(rb_cDir, "entries", dir_entries, -1);

- rb_define_method(rb_cDir,"initialize", dir_initialize, -1);

- rb_define_method(rb_cDir,"to_path", dir_path, 0);

- rb_define_method(rb_cDir,"inspect", dir_inspect, 0);

- rb_define_singleton_method(rb_cDir,"home", dir_s_home, -1);

- rb_define_singleton_method(rb_cDir,"[]", dir_s_aref, -1);

- rb_define_singleton_method(rb_cDir,"exist?", rb_file_directory_p, 1); /* in file.c */

- rb_define_singleton_method(rb_cDir,"exists?", rb_file_directory_p, 1); /* in file.c */

- rb_file_const("FNM_SYSCASE", INT2FIX(FNM_SYSCASE));

-#include "ruby/ruby.h"

-#define dln_notimplement rb_notimplement

-#define dln_memerror rb_memerror

-#define dln_exit rb_exit

-#define dln_loaderror rb_loaderror

-#define dln_notimplement --->>> dln not implemented <<<---

-#define dln_memerror abort

-#define dln_exit exit

-static void dln_loaderror(const char *format, ...);

-#define free(x) xfree(x)

-#if defined(_WIN32)

-#if defined(__APPLE__) && defined(__MACH__) /* Mac OS X */

-# if defined(HAVE_DLOPEN)

- /* Mac OS X with dlopen (10.3 or later) */

-# define MACOSX_DLOPEN

-# define MACOSX_DYLD

-#if defined(__BEOS__) || defined(__HAIKU__)

-# include <image.h>

-#ifndef dln_loaderror

-dln_loaderror(const char *format, ...)

- va_start(ap, format);

- vfprintf(stderr, format, ap);

-#if defined(HAVE_DLOPEN) && !defined(USE_DLN_A_OUT) && !defined(_AIX) && !defined(MACOSX_DYLD) && !defined(_UNICOSMP)

-# if defined(__hp9000s300) || ((defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(__ELF__)) || defined(__BORLANDC__) || defined(NeXT) || defined(__WATCOMC__) || defined(MACOSX_DYLD)

-init_funcname_len(char **buf, const char *file)

- size_t len = init_funcname_len(buf, file);\

- strlcpy(tmp, *buf, len + 1);\

-#define DLN_ENOINIT 1202 /* No initializer given */

-#include "ruby/util.h"

-#include "ruby/st.h"

-load_header(int fd, struct exec *hdrp, long disp)

-load_reloc(int fd, struct exec *hdrp, long disp)

-load_sym(int fd, struct exec *hdrp, long disp)

-sym_hash(struct exec *hdrp, struct nlist *syms)

-dln_init(const char *prog)

- char *file, fbuf[MAXPATHLEN];

- file = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf));

- /* skip forwarding spaces */

-load_text_data(int fd, struct exec *hdrp, int bss, long disp)

-undef_print(char *key, char *value)

-dln_print_undef(void)

-dln_undefined(void)

-link_undef(const char *name, long base, struct relocation_info *reloc)

-reloc_undef(int no, struct undef *undef, struct reloc_arg *arg)

-unlink_undef(const char *name, long value)

-reloc_repl(int no, struct undef *undef, struct indr_data *data)

-load_1(int fd, long disp, const char *need_init)

- static const char *libc = LIBC_NAME;

- switch (R_SYMBOL(rel)) {

-search_undef(const char *key, int value, st_table *lib_tbl)

-const char *dln_librrb_ary_path = DLN_DEFAULT_LIB_PATH;

-load_lib(const char *lib)

- char *path, *file, fbuf[MAXPATHLEN];

- char *envpath = 0;

- long len = strlen(lib) + 4;

- char *p = alloca(len);

- snprintf(p, len, "lib%s.a", lib+2);

- else path = envpath = strdup(path);

- file = dln_find_file_r(lib, path, fbuf, sizeof(fbuf));

- if (envpath) free(envpath);

-load(const char *file)

-dln_sym(const char *name)

-# include <dlfcn.h>

- return "No initializer given";

- char *message[1024], errbuf[1024];

- snprintf(errbuf, sizeof(errbuf), "load failed - %s. ", pathname);

- if (loadquery(L_GETMESSAGES, &message[0], sizeof(message)) != -1) {

- ERRBUF_APPEND("Please issue below command for detailed reasons:\n\t");

- ERRBUF_APPEND("/usr/sbin/execerror ruby ");

- for (i=0; message[i]; i++) {

- ERRBUF_APPEND("\"");

- ERRBUF_APPEND(message[i]);

- ERRBUF_APPEND("\" ");

- ERRBUF_APPEND("\n");

- ERRBUF_APPEND(strerror(errno));

- ERRBUF_APPEND("[loadquery failed]");

- dln_loaderror("%s", errbuf);

-#if defined(DLN_NEEDS_ALT_SEPARATOR) && DLN_NEEDS_ALT_SEPARATOR

-#define translit_separator(src) do { \

- char *tmp = ALLOCA_N(char, strlen(src) + 1), *p = tmp, c; \

- *p++ = ((c = *file++) == '/') ? DLN_NEEDS_ALT_SEPARATOR : c; \

-#define translit_separator(str) (void)(str)

-dln_load(const char *file)

- if (strlen(file) >= MAXPATHLEN) dln_loaderror("filename too long");

- strlcpy(winfile, file, sizeof(winfile));

- dln_loaderror("%s - %s\n%s", dln_strerror(), buf, file);

- translit_separator(file);

-# undef RTLD_GLOBAL

- init_fct = (void(*)())(VALUE)dlsym(handle, buf);

-#if defined __SYMBIAN32__

- if (init_fct == NULL) {

- init_fct = (void(*)())dlsym(handle, "1"); /* Some Symbian versions do not support symbol table in DLL, ordinal numbers only */

- dln_loaderror("%s - %s", strerror(errno), file);

- dln_loaderror("%s - %s", strerror(ENOSYM), file);

-#if defined(NeXT) || defined(MACOSX_DYLD)

- dln_loaderror("Failed to load %.200s", file);

- dln_loaderror("Failed to lookup Init function %.200s", file);

- function pointer */

- dln_loaderror("Failed to load %.200s", file);

- dln_loaderror("Failed to lookup Init function %.200s",file);

-#if defined(__BEOS__) || defined(__HAIKU__)

- image_id img_id; /* extension module unique id */

- void (*init_fct)(); /* initialize function for extension module */

- /* load extension module */

- dln_loaderror("Failed to load add_on %.200s error_code=%x",

- strlcpy(real_name, buf, MAXPATHLEN);

- strlcat(real_name, "__Fv", MAXPATHLEN);

- dln_loaderror("Failed to lookup Init function %.200s", file);

- dln_loaderror(errmsg, strerror(err_stat), buf);

-#endif /* __BEOS__ || __HAIKU__ */

- dln_notimplement();

- dln_loaderror("%s - %s", error, file);

-DEPRECATED(char *dln_find_exe(const char*,const char*));

-DEPRECATED(char *dln_find_file(const char*,const char*));

-char *dln_find_exe_r(const char*,const char*,char*,size_t);

-char *dln_find_file_r(const char*,const char*,char*,size_t);

-void *dln_load(const char*);

-/**********************************************************************

- created at: Tue Jan 18 17:05:06 JST 1994

-**********************************************************************/

-#include "ruby/ruby.h"

-#define dln_notimplement rb_notimplement

-#define dln_memerror rb_memerror

-#define dln_exit rb_exit

-#define dln_loaderror rb_loaderror

-#define dln_notimplement --->>> dln not implemented <<<---

-#define dln_memerror abort

-#define dln_exit exit

-static void dln_loaderror(const char *format, ...);

-#ifdef HAVE_STDLIB_H

-# include <stdlib.h>

-#ifdef USE_DLN_A_OUT

-#if defined(HAVE_ALLOCA_H)

-#include <alloca.h>

-#ifdef HAVE_STRING_H

-# include <string.h>

-# include <strings.h>

-#define free(x) xfree(x)

-#if defined(_WIN32)

-#include "missing/file.h"

-#include <sys/types.h>

-#include <sys/stat.h>

-# define S_ISDIR(m) ((m & S_IFMT) == S_IFDIR)

-#ifdef HAVE_SYS_PARAM_H

-# include <sys/param.h>

-# define MAXPATHLEN 1024

-#ifdef HAVE_UNISTD_H

-# include <unistd.h>

-static char *dln_find_1(const char *fname, const char *path, char *buf, size_t size, int exe_flag);

-dln_find_exe_r(const char *fname, const char *path, char *buf, size_t size)

- char *envpath = 0;

- path = getenv(PATH_ENV);

- if (path) path = envpath = strdup(path);

-#if defined(_WIN32)

- path = "/usr/local/bin;/usr/ucb;/usr/bin;/bin;.";

- path = "/usr/local/bin:/usr/ucb:/usr/bin:/bin:.";

- buf = dln_find_1(fname, path, buf, size, 1);

- if (envpath) free(envpath);

-dln_find_file_r(const char *fname, const char *path, char *buf, size_t size)

- if (!path) path = ".";

- return dln_find_1(fname, path, buf, size, 0);

-static char fbuf[MAXPATHLEN];

-dln_find_exe(const char *fname, const char *path)

- return dln_find_exe_r(fname, path, fbuf, sizeof(fbuf));

-dln_find_file(const char *fname, const char *path)

- return dln_find_file_r(fname, path, fbuf, sizeof(fbuf));

-dln_find_1(const char *fname, const char *path, char *fbuf, size_t size,

- int exe_flag /* non 0 if looking for executable. */)

- register const char *dp;

- register const char *ep;

- register char *bp;

- static const char extension[][5] = {

- int is_abs = 0, has_path = 0;

- const char *ext = 0;

- const char *p = fname;

- static const char pathname_too_long[] = "openpath: pathname too long (ignored)\n\

-\tDirectory \"%.*s\"\n\tFile \"%s\"\n";

-#define PATHNAME_TOO_LONG() fprintf(stderr, pathname_too_long, (int)(bp - fbuf), fbuf, fname)

-#define RETURN_IF(expr) if (expr) return (char *)fname;

- RETURN_IF(!fname);

-# define CharNext(p) ((p)+1)

-# ifdef DOSISH_DRIVE_LETTER

- if (((p[0] | 0x20) - 'a') < 26 && p[1] == ':') {

- case '/': case '\\':

- has_path = is_abs;

- case '/': case '\\':

- for (j = 0; STRCASECMP(ext, extension[j]); ) {

- if (++j == sizeof(extension) / sizeof(extension[0])) {

- RETURN_IF(is_abs);

- else if (has_path) {

- if (i + 1 > size) goto toolong;

- fspace = size - i - 1;

- memcpy(fbuf, fname, i + 1);

- goto needs_extension;

- if (*p == '.' && *++p == '.') ++p;

- RETURN_IF(*p == '/');

- RETURN_IF(exe_flag && strchr(fname, '/'));

- for (dp = path;; dp = ++ep) {

- register size_t l;

- /* extract a component */

- ep = strchr(dp, PATH_SEP[0]);

- ep = dp+strlen(dp);

- /* find the length of that component */

- fspace = size - 2;

- ** If the length of the component is zero length,

- ** start from the current directory. If the

- ** component begins with "~", start from the

- ** user's $HOME environment variable. Otherwise

- ** take the path literally.

- if (*dp == '~' && (l == 1 ||

-#if defined(DOSISH)

- home = getenv("HOME");

- if (home != NULL) {

- memcpy(bp, home, i);

- memcpy(bp, dp, l);

- /* add a "/" between directory and filename */

- if (ep[-1] != '/')

- /* now append the file name */

- i = strlen(fname);

- PATHNAME_TOO_LONG();

- memcpy(bp, fname, i + 1);

-#if defined(DOSISH)

- if (exe_flag && !ext) {

- for (j = 0; j < sizeof(extension) / sizeof(extension[0]); j++) {

- if (fspace < strlen(extension[j])) {

- PATHNAME_TOO_LONG();

- strlcpy(bp + i, extension[j], fspace);

- if (stat(fbuf, &st) == 0)

-#endif /* _WIN32 or __EMX__ */

- if (stat(fbuf, &st) == 0) {

- if (exe_flag == 0) return fbuf;

- /* looking for executable */

- if (!S_ISDIR(st.st_mode) && eaccess(fbuf, X_OK) == 0)

- /* if not, and no other alternatives, life is bleak */

- if (*ep == '\0') {

- /* otherwise try the next component in the search path */

-#include "ruby/ruby.h"

-dln_load(const char *file)

- rb_loaderror("this executable file can't load extension libraries");

-#define NO_LOCALE_CHARMAP 1

-#include "encoding.c"

-#define NO_INITIAL_LOAD_PATH 1

-#include "version.c"

-Thu Jan 17 09:43:05 2002 TAKAHASHI Kaoru <kaoru@kaisei.org>

- * misc/ruby-mode.el (ruby-add-log-current-method): New function

- for `add-log-current-defun-function'.

-# $Id: ChangeLog 590 2006-12-31 09:02:34Z ko1 $

-# from Mon, 03 May 2004 01:24:19 +0900

-Sun Dec 31 18:01:50 2006 Koichi Sasada <ko1@atdot.net>

- * bin/* : ruby/trunk/bin 11437

-Sun Dec 31 17:42:05 2006 Koichi Sasada <ko1@atdot.net>

- * eval.c : remove old Kernel#funcall definition

-2006-12-30(Sat) 07:59:26 +0900 Koichi Sasada <ko1@atdot.net>

- * catch up ruby/trunk 11437

- * eval_intern.h : reorder tag initialization

- * eval.c : fix to support __send!, funcall and prohibit funcall as

- * eval_error.h, eval_jump.h, eval_safe.h : fix prototypes

- * eval_method.h, vm.c : check re-definition at rb_add_method()

- * yarvcore.h : fix typo

- * compile.c : fix white spaces

- * lib/delegate.rb : fix to support __send, ...

- * lib/getoptlong.rb : fix to work on YARV

- * lib/rss/parser.rb : use __send! instead of __send__

- * sample/test.rb : comment out codes which use |&b| type block parameter

- * ext/ripper/extconf.rb : turn off

- * test/ripper/test_files.rb, test_parser_events.rb,

- test_scanner_events.rb : fix to check it has ripper module

- * vm_dump.c : remove showing file path length limitation

- * yarvtest/test_eval.rb : use __send! instead of __send__

-2006-12-19(Tue) 11:46:08 +0900 Koichi Sasada <ko1@atdot.net>

- * ext/openssl : added

- * ext/ripper : added

- * test/openssl : added

- * test/ripper : added

- * rb/ -> tool/ : renamed

- * common.mk : fixed for above change

- * ruby_doc/* : move to topdir

- * sample/* : added

- * test2.rb : removed

-2006-12-15(Fri) 09:42:46 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : remove obsolete codes

- * insns.def : fix a comment of getconstant

-2006-12-13(Wed) 16:26:06 +0900 Koichi Sasada <ko1@atdot.net>

- * blockinlining.c, compile.c, compile.h, debug.c, debug.h,

- insnhelper.h, insns.def, iseq.c, thread.c, thread_pthread.ci,

- thread_pthread.h, thread_win32.ci, thread_win32.h, vm.c, vm.h,

- vm_dump.c, vm_evalbody.ci, vm_opts.h.base, yarv.h,

- yarv_version.h, yarvcore.c, yarvcore.h :

- add a header includes copyright

-2006-12-12(Tue) 13:13:32 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb : add PREFETCH() statement

- * yarvcore.h : fix LIKELY(x) and

- remove main_thread_val field from yarv_vm_t

- * yarvcore.c : ditto

- * thread.c : support fork

- * eval_thread.c : ditto

- * process.c : ditto

- * signal.c : ditto

- * test/ruby/test_signal.rb :

- * thread_pthread.ci : rename timer thread functions

- * thread_win32.ci : ditto

-2006-11-10(Fri) 21:29:13 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix to compile arguments

- * insns.def : fix to duplicate first array value on concatarray

- * yarvtest/test_bin.rb : add a test for above change

- * sample/test.rb : fix to catch up Ruby HEAD (fix to remove test about

-2006-11-10(Fri) 12:49:11 +0900 Koichi Sasada <ko1@atdot.net>

- * vm_macro.def : fix to inherit visibility on

- NODE_SUPER method invocation

-2006-11-10(Fri) 09:13:46 +0900 Koichi Sasada <ko1@atdot.net>

- * class.c : revert module duplicate inclusion

- * parse.y : catch up current Ruby HEAD

- * compile.c : ditto

- * eval_thread.c : define Continuation (null class)

- * vm_dump.c : fix to output backtrae to stderr

- * yarvtest/test_block.rb : remove unsupported test

- * yarvtest/test_class.rb : add a test about super

- * yarvtest/test_syntax.rb : add a test about case/when

-2006-11-09(Thu) 10:22:59 +0900 Koichi Sasada <ko1@atdot.net>

- * call_cfunc.h -> call_cfunc.ci : renamed

- * vm_evalbody.h, vm_evalbody.ci : ditto

- * thread_pthread.h, thread_pthread.ci : separate declaration and

- * thread_win32.h, thread_win32.ci : ditto

- * thread.c : use *.ci instead of *.c as implementation

- * common.mk : fix rules for above changes

-2006-11-08(Wed) 17:23:23 +0900 Koichi Sasada <ko1@atdot.net>

- * vm_dump.c : show C level backtrace (pointer only) with

- backtrace() function (glibc feature)

- * configure.in : ditto

- * yarvcore.c : add NSDR method (show C level backtrace)

- * error.c : fix indent

-2006-11-07(Tue) 13:17:10 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c (rb_set_errinfo) : added

- * version.h : fix version number

- * lib/webrick/utils.rb : fix to remove Thread.critical

- * ext/dbm, dl, gdbm, iconv, io, pty, sdbm : added

- * test/dbm, gdbm, io, logger, net, readline, sdbm, soap,

- webrick, win32ole, wsdl, xsd : added

-2006-11-06(Mon) 22:32:18 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c : import Ruby HEAD

- * ext/socket/extconf.rb : ditto

- * ext/socket/socket.c : ditto

- * lib/date.rb : ditto

- * lib/net/imap.rb : ditto

- * lib/rss/0.9.rb : ditto

- * lib/set.rb : ditto

- * lib/soap/mapping/rubytypeFactory.rb : ditto

- * lib/soap/mimemessage.rb : ditto

- * lib/soap/property.rb : ditto

- * lib/webrick/httprequest.rb : ditto

- * lib/webrick/httputils.rb : ditto

- * lib/xmlrpc/create.rb : ditto

- * lib/xsd/codegen/gensupport.rb : ditto

- * object.c : ditto

- * string.c : ditto

- * version.h : ditto

- * rb/ir.rb : fix to use "diffs" directory

- * vm_dump.c : add "const"

-2006-11-06(Mon) 16:36:47 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_proc.c : remove "static" from external global variables

- * eval_thread.c : ditto

- * array.c : fix indent

- * insns.def : add a suitable cast

- * vm_macro.def : allow scalar value on splat arguments

- * yarvtest/test_block.rb : fix to synchronize Ruby HEAD

- * rb/insns2vm.rb : remove String#each for 1.9

- * template/vm.inc.tmpl : ditto (remove String#each_with_index)

-2006-11-06(Mon) 13:22:34 +0900 Koichi Sasada <ko1@atdot.net>

- * iseq.c : fixed GC debugging outputs

- * rb/parse.rb : fixed output format

-2006-11-04(Sat) 09:46:50 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix to duplicate "#{'foo'}" string

- * yarvtest/test_bin.rb : add a test for above

- * ext/readline/readline.c : import Ruby HEAD

- * keywords : ditto

- * lib/mkmf.rb : ditto

- * test/ruby/test_hash.rb : fix to current specification

- * test/ruby/test_string.rb : ditto

-2006-11-03(Fri) 20:58:36 +0900 Koichi Sasada <ko1@atdot.net>

- * ext/nkf/nkf-utf8/utf8tbl.h : missed to add

- * configure.in : import ruby HEAD

- * test/ruby/test_array.rb : ditto

- * test/ruby/test_assignment.rb : ditto

- * test/ruby/test_clone.rb : ditto

- * test/socket/test_socket.rb : ditto

- * test/socket/test_unix.rb : ditto

- * test/strscan/test_stringscanner.rb : ditto

- * test/testunit/collector/test_dir.rb : ditto

-2006-11-03(Fri) 20:22:24 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c : import current ruby HEAD and apply API changes

- This version has some known bugs

- * bignum.c : ditto

- * blockinlining.c : ditto

- * compile.c : ditto

- * enumerator.c : ditto

- * eval_error.h : ditto

- * eval_jump.h : ditto

- * eval_load.c : ditto

- * eval_proc.c : ditto

- * insns.def : ditto

- * instruby.rb : ditto

- * intern.h : ditto

- * marshal.c : ditto

- * missing/vsnprintf.c : ditto

- * mkconfig.rb : ditto

- * numeric.c : ditto

- * object.c : ditto

- * oniguruma.h : ditto

- * process.c : ditto

- * random.c : ditto

- * rb/ir.rb : ditto

- * regcomp.c : ditto

- * regerror.c : ditto

- * regexec.c : ditto

- * regint.h : ditto

- * regparse.c : ditto

- * regparse.h : ditto

- * rubytest.rb : ditto

- * runruby.rb : ditto

- * sample/test.rb : ditto

- * signal.c : ditto

- * sprintf.c : ditto

- * string.c : ditto

- * struct.c : ditto

- * thread.c : ditto

- * variable.c : ditto

- * version.h : ditto

- * vm_dump.c : ditto

- * vm_macro.def : ditto

-2006-10-31(Tue) 22:47:50 +0900 Koichi Sasada <ko1@atdot.net>

- * parse.y : fix NEWHEAP bugs (import HEAD)

- * ruby.c, intern.h, yarvcore.c (rb_load_file) : change to

- return parsed node pointer

- * rb/ir.rb : add check mode

-2006-09-01(Fri) 22:05:28 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix a bug of peephole optimization and enable

- regexp optimization

-2006-08-21(Mon) 05:27:48 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/mathn.rb : remove "remove_method :gcd2"

- * opt_insn_unif.def : unset opt setting

- * opt_operand.def : ditto

-2006-08-18(Fri) 17:55:31 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add dependency of yarvcore.h to thread.o

- * gc.c : change comment line

- * thread.c : remove some line break

- * yarvcore.c : reoder initialize sequence to mark main thread

-2006-08-18(Fri) 16:51:34 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : add a support for cache values per thread

- * yarvcore.c : ditto

- * thread.c : move a expression after acquiring lock

- * compile.c : add a cast to remove warning

-2006-08-18(Fri) 02:07:45 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix to return rhs value on ATTRASGIN

- * insns.def (setn) : add insn setn

- * yarvtest/test_bin.rb : add tests for above

-2006-08-17(Thu) 22:46:08 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : clear callee_id ([yarv-dev:1073])

-2006-08-17(Thu) 22:14:15 +0900 Koichi Sasada <ko1@atdot.net>

- * thread_pthread.h : fix error message

-2006-08-17(Thu) 12:23:52 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : change initilize routine order ([yarv-dev:1067])

- * yarvcore.c (Init_yarv) : init th->machine_stack_start

- * thread_pthread.h : add malloc value check ([yarv-dev:1066])

- * insns.def (opt_eq) : fix typo ([yarv-dev:1072])

- * yarvtest/test_opts.rb : add a test for above

- * yarvtest/test_class.rb : add a test for last commit

-2006-08-17(Thu) 11:02:16 +0900 Koichi Sasada <ko1@atdot.net>

- * class.c (clone_method) : check undef-ed method ([yarv-dev:1068])

-2006-08-15(Tue) 15:07:43 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix opt_plus routine ([yarv-dev-en:149])

- * yarvtest/test_opts.rb : add tests for above

-2006-08-06(Sun) 06:24:51 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : fix build rule (build only ruby binary when benchmark)

- * yarvcore.[ch] : fix and add yarv_iseq_new_with_* API

- * blockinlining.c : ditto

- * compile.c : ditto

- * compile.h : ditto

- * eval_method.h : check redefinition for specialized instruction

- * insnhelper.h : ditto

- * insns.def : ditto

- * numeric.c : add Fixnum#succ

- * thread.c : remove duplicated method Thread#current

- * yarvcore.c : remove duplicated method Proc#clone

- * yarvtest/test_opts.rb : added

-2006-07-20(Thu) 04:10:13 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix [yarv-dev:1041] problem (raise TypeError)

- * eval.c : rb_funcall2 send as NOEX_PRIVATE and check scope

-2006-07-20(Thu) 03:38:46 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : fix [yarv-dev:1040] bug

-2006-07-18(Tue) 18:45:52 +0900 Koichi Sasada <ko1@atdot.net>

- * some files : set property "svn:eol-style" as native

-2006-07-18(Tue) 18:35:55 +0900 Koichi Sasada <ko1@atdot.net>

- * gc.h : fix a static function name

- * vm.c : remove Japanese comments

- * yarvcore.c : add a comment

- * some files : set property "svn:eol-style" as native

-2006-07-18(Tue) 16:48:01 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : remove unused code

- * compile.c : add checking value

- * yarvcore.c : fix yarv_th_eval prototype declaration

- * yarvtest/yarvtest.rb : use compile instead of parse method

-2006-07-12(Wed) 15:18:58 +0900 Koichi Sasada <ko1@atdot.net>

- * yarv_version.h : 0.4.1

-2006-07-12(Wed) 13:38:03 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : fix indent

- * gc.h : fix syntax bug

- * thread_pthread.h : vanish warnning message

- * compile.c : ditto

- * thread.c : ditto

- * yarvcore.c : prohibit tail call optimization to mark

- * yarvcore.h : add some allocator function declaration

- * yarvtest/test_eval.rb : remove output

-2006-07-12(Wed) 05:01:23 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : undef alloc funcs

- * eval_proc.c : ditto (use factory faction)

- * thread.c : ditto

- * iseq.c : fix compile option creation

- * rb/allload.rb : use compile_file method

- * rb/compile.rb : ditto

- * rb/parse.rb : ditto

- * template/insnstbl.html : hide mail addr

-2006-07-11(Tue) 21:34:29 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_dir.rb: new test test_JVN_13947696.

-2006-07-11(Tue) 21:26:41 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_alias.rb: new test test_JVN_83768862.

-2006-07-11(Tue) 11:33:49 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix compile error on C90

-2006-07-11(Tue) 10:40:23 +0900 Koichi Sasada <ko1@atdot.net>

- * disasm.c : removed

- * common.mk : ditto

- * blockinlining.c : Get*Val => Get*Ptr

- * yarvcore.c : ditto

- * eval_proc.c : ditto

- * vm_dump.c : ditto

- * vm_macro.def : ditto

- * signal.c : ditto

- * thread.c : ditto

- * compile.c : rename local variable insnobj => iobj

- * compile.c : support yarv_compile_option_t

- * insns.def : use OPT_CHECKED_RUN instead of IGNORE_OPTIMIZE

- * rb/compile.rb : use compile option

- * template/optinsn.inc.tmpl : fix function name

- * vm_opts.h.base : change macros

- * rb/insns2vm.rb : ditto

- * yarv.h : fix yarvcore_eval_parsed parameter type

- * yarvcore.c : fix some interfaces (functions)

- * yarvcore.h : add a type yarv_compile_option_t

-2006-07-06(Thu) 13:45:20 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/yasm.rb : pass builder object if block arity == 1

-2006-07-05(Wed) 11:23:50 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/yasm.rb : fix method name

- * vm.c (th_set_top_stack) : check toplevel or not

-2006-07-04(Tue) 20:05:38 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/compile.rb : added

- * yarvtest/yarvtest.rb : disable load/store test

-2006-07-04(Tue) 18:17:15 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix some bugs about load iseq data

- * disasm.c : ditto (store)

- * eval.c (rb_f_local_variables) : fix bugs

- * insns.def : fix otp_ltlt condition bug

- * yarvcore.c : rename some functions

- * yarvtest/yarvtest.rb : add iseq load/store tests

- (to enable this, remove comment)

-2006-07-03(Mon) 01:54:23 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_thread.c : add parameter "th" to thread_set_raised

- * yarvcore.h : ditto

- * eval_intern.h : ditto

- * eval_error.h : declare with ANSI style

- * disasm.c : rename iseq_iseq2simpledata() to iseq_data_to_ary

- * lib/yasm.rb : rename Instruction#to_simpledata to

- * yarvcore.c : ditto

- * vm.c : fix bug (Proc.new{|*args| p args}.call(1) #=> 1)

- * yarvtest/test_proc.rb : add a tests for above

-2006-06-21(Wed) 09:19:06 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : remove yarv_iseq_t#catch_table_ary and

- add yarv_iseq_t#compile_data#catch_table_ary

- * compile.h : ditto

- * yarvcore.c : ditto

- * yarvcore.h : ditto

- * eval_thread.c : remove unused code

- * thread.c : add rb_gc_mark_threads() (from eval_thread.c)

-2006-05-31(Wed) 21:26:38 +0900 Koichi Sasada <ko1@atdot.net>

- * parse.y : prohibit tail call optimization to mark vparsr

-2006-05-25(Thu) 15:37:11 +0900 Koichi Sasada <ko1@atdot.net>

- * blockinlining.c : support NEW_ATTRASGN node

- * class.c : skip undefined method to collect ([yarv-dev:999])

- * yarvtest/test_class.rb : add a test for above

- * compile.c : fix opt_regexpmatch1 condition

- * lib/monitor.rb : fix [yarv-dev:1009]

- * rb/insns2vm.rb : fix typo

- * thread.c : prohibit unlock by not mutex owner thread

- * vm_opts.h.base : change default option

-2006-05-18(Thu) 16:00:50 +0900 Koichi Sasada <ko1@atdot.net>

- * intern.h : fix prototype declarations for last re.c change

-2006-05-18(Thu) 12:12:03 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/runruby.rb : added

- * thread.c (rb_thread_alone) : check if vm->living_threads

-2006-05-18(Thu) 12:05:35 +0900 Koichi Sasada <ko1@atdot.net>

- * signal.c : not mask SIGSEGV

- * thread.c : fix debug output on Win32

- * thread.c, thread_pthread.h : add some debug prints

- * yarvcore.c : mark machine registers on thread_mark

-2006-05-17(Wed) 18:09:20 +900 Yukihiro Matsumoto <matz@ruby-lang.org>

- * dir.c (sys_warning): should not call a vararg function

- rb_sys_warning() indirectly. [ruby-core:07886]

-2006-05-17(Wed) 16:41:41 +900 Yukihiro Matsumoto <matz@ruby-lang.org>

- * re.c (rb_reg_initialize): should not allow modifying literal

- regexps. frozen check moved from rb_reg_initialize_m as well.

- * re.c (rb_reg_initialize): should not modify untainted objects in

- safe levels higher than 3.

- * re.c (rb_memcmp): type change from char* to const void*.

- * dir.c (dir_close): should not close untainted dir stream.

- * dir.c (GetDIR): add tainted/frozen check for each dir operation.

-2006-05-07(Sun) 21:06:28 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c : remove Mutex#unlock_and_stop and add Mutex#sleep

- * lib/monitor.rb : ditto

- * lib/thread.rb : ditto

- * thread_pthread.h : fix stack size

- * thread_win32.h : fix sleep

- * yarvcore.h : disable to use get/setcontext

- * lib/webrick/server.rb : add experimental implementation

- using thraeds pool

-2006-05-05(Fri) 13:59:00 +0900 Koichi Sasada <ko1@atdot.net>

- * test/ruby/test_signal.rb : disable a test

- * thread.c : do trylock before lock on mutex_lock

- * thread_win32.h : use CriticalSection instead of Mutex

-2006-05-05(Fri) 03:03:22 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : vtune rule make run test.rb

- * disasm.c : fix syntax errors (on VC)

- * yarvcore.c : ditto

- * lib/thread.rb : Mutex#synchronize is defined here

- * lib/*.rb : ditto

- * signal.c : separate pthread or not

- * thread.c : support lightweight wakeup

- * thread_pthread.h : ditto

- * thread_win32.h : ditto

- * yarvcore.h : ditto

- * yarvtest/test_thread.rb : restore last change

-2006-05-04(Thu) 18:11:43 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_thread.c : remove rb_thread_interrupt

- * intern.h : ditto

- * signal.c : change signal transfer route

- * thread.c : ditto

- * thread_pthread.h : ditto

- * thread_win32.h : ditto

- * yarv.h : support GET_VM()

- * yarvcore.h : change yarv_thread_t/yarv_vm_t structure

- * yarvtest/test_thread.rb : decrease threads to test

-2006-05-04(Thu) 00:26:18 +0900 Koichi Sasada <ko1@atdot.net>

- * thread_pthread.h : experimental support of thread cache

-2006-04-25(Tue) 22:30:14 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : remove struct yarv_cmethod_info, add

- data structure for profiling and extend yarv_control_frame_t

- * vm.c : make pop_frame() and apply above change

- * vm_dump.c : ditto

- * vm_macro.def : ditto

- * insns.def (leave): use pop_frame() instead of

- POP_CONTROL_STACK_FRAME() macro

- * insnhelper.h : remove some macros

- * yarvcore.c : change th_set_top_stack() prototype

-2006-04-18(Tue) 18:37:08 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, disasm.c : support export/import exception

- * yarvcore.h : change "struct catch_table_entry" member variable

-2006-04-13(Thu) 17:11:30 +0900 Koichi Sasada <ko1@atdot.net>

- * bignum.c : import ruby 1.9 HEAD (Ruby 1.9.0 2006-04-08)

- * enumerator.c : ditto

- * ext/.document : ditto

- * ext/extmk.rb : ditto

- * ext/nkf/lib/kconv.rb : ditto

- * ext/nkf/nkf-utf8/nkf.c : ditto

- * ext/nkf/nkf-utf8/utf8tbl.c : ditto

- * ext/nkf/nkf.c : ditto

- * ext/nkf/test.rb : ditto

- * ext/socket/.cvsignore : ditto

- * ext/win32ole/sample/excel2.rb : ditto

- * ext/win32ole/tests/testOLEMETHOD.rb : ditto

- * ext/win32ole/tests/testOLEPARAM.rb : ditto

- * ext/win32ole/tests/testOLETYPE.rb : ditto

- * ext/win32ole/tests/testOLETYPELIB.rb : ditto

- * ext/win32ole/tests/testOLEVARIABLE.rb : ditto

- * ext/win32ole/tests/testOLEVARIANT.rb : ditto

- * ext/win32ole/tests/testWIN32OLE.rb : ditto

- * ext/win32ole/tests/testall.rb : ditto

- * ext/win32ole/win32ole.c : ditto

- * instruby.rb : ditto

- * lib/delegate.rb : ditto

- * lib/fileutils.rb : ditto

- * lib/find.rb : ditto

- * lib/irb/ruby-lex.rb : ditto

- * lib/mkmf.rb : ditto

- * lib/net/http.rb : ditto

- * lib/open-uri.rb : ditto

- * lib/pathname.rb : ditto

- * lib/rational.rb : ditto

- * lib/rdoc/parsers/parse_rb.rb : ditto

- * lib/rdoc/ri/ri_paths.rb : ditto

- * lib/resolv.rb : ditto

- * lib/test/unit/collector/objectspace.rb : ditto

- * lib/webrick/httpservlet/cgihandler.rb : ditto

- * mkconfig.rb : ditto

- * object.c : ditto

- * oniguruma.h : ditto

- * regcomp.c : ditto

- * regerror.c : ditto

- * regparse.c : ditto

- * rubytest.rb : ditto

- * runruby.rb : ditto

- * string.c : ditto

- * test/digest/test_digest.rb : ditto

- * test/pathname/test_pathname.rb : ditto

- * test/ruby/envutil.rb : ditto

- * test/ruby/test_float.rb : ditto

- * test/ruby/test_pack.rb : ditto

- * version.h : ditto

- * win32/mkexports.rb : ditto

- * win32/resource.rb : ditto

- * win32/win32.c : ditto

-2006-04-11(Tue) 11:26:53 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/yasm.rb : move to lib/yasm.rb

-2006-04-09(Sun) 03:04:04 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : change to accept method iseq object when loading from

- * yarvcore.c : add a debug output

- * rb/yasm.rb : change some interfaces

-2006-04-07(Fri) 20:25:03 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix miss about range of catch "next"

- * eval.c : add braces

-2006-04-07(Fri) 11:09:43 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : fix some make rules

- * insns.def : rename some instructions name

- * rb/insns2vm.rb : change some operand type name

- * vm_evalbody.h : ditto

- * template/insns.inc.tmpl : add YARV_MAX_INSTRUCTION_SIZE macro

- * compile.c, disasm.c, yarvcore.c : support load/store iseq from/to simple

- data structure such as array, literals, and so on

- * rb/yasm.rb : supported

- * vm.c : change interface of eval_define_method

- * yarvcore.h : remove unused externals

-2006-03-08(Wed) 10:31:29 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/delegate.rb (DelegateClass): do not delegate #send and

-2006-02-27(Mon) 22:39:17 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/thread.rb: last commit causes busy loop, revert it. [yarv-dev:990]

- * lib/thread.rb: non_block=true wrongly caused ThreadError.

-2006-02-27(Mon) 21:33:49 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : fix to display command line

- * compile.c : fix comparison between a pointer and 0

- * debug.c : fix to output stder

- * disasm.c : add debug function

- * vm_dump.c : ditto

- * eval_proc.c : fix to skip class definition

- * ruby.h : fix T_VALUE to T_VALUES

- * node.h : fix prototypes

- * vm.c : add VM_DEBUG macro

- * vm.c : fix compile error on VC++

- * vm.c : fix to inherit last lfp[0] on th_set_finish_env

- * vm.c : fix to add one svar location for any frame

- * vm_macro.def : ditto

- * yarvcore.h : add YARV_CLASS_SPECIAL_P() and YARV_BLOCK_PTR_P()

- * insns.def : fix to propagete throw state

-2006-02-27(Mon) 13:54:47 +0900 Minero Aoki <aamine@loveruby.net>

- * ext/syslog: imported from Ruby CVS trunk HEAD.

- * ext/racc: ditto.

-2006-02-27(Mon) 12:47:10 +0900 Minero Aoki <aamine@loveruby.net>

- * parse.y: follow coding style change.

-2006-02-27(Mon) 11:53:07 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/README: imported from Ruby CVS trunk HEAD.

- * lib/gserver.rb: ditto.

- * lib/readbytes.rb: ditto.

- * lib/parsearg.rb: ditto.

- * lib/racc: ditto.

- * lib/rinda: ditto.

-2006-02-27(Mon) 11:27:19 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/thread.rb (Queue#pop): faster code. [yarv-dev:973]

- * lib/thread.rb (Queue#pop): avoid to push same thread in to

-2006-02-23(Thu) 23:32:53 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/open3.rb: imported from Ruby CVS trunk HEAD (rev 1.12).

-2006-02-23(Thu) 15:10:09 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : support rb_frame_self()

- * eval_intern.h (th_get_ruby_level_cfp) : return 0 if no cfp

- * eval_load.c : comment out scope set

- * yarvcore.c : fix to initialize/free process of iseq

- * vm.c (th_invoke_proc) : fix to set special cref always

- * yarvtest/test_proc.rb : add a test for above

-2006-02-22(Wed) 23:33:47 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add rule "runruby"

- * eval_thread.c : remove obsolete comment

- * eval.c : remove unused functions

- * signal.c : ditto

- * gc.c : add rb_register_mark_object() and use it

- * eval_load.c : ditto

- * eval_proc.c : ditto

- * ext/etc/etc.c : ditto

- * ext/win32ole/win32ole.c : ditto

- * yarvcore.h : ditto

- * thread.c : add rb_thread_run_parallel()

- * yarvcore.c : change bootstrap

-2006-02-22(Wed) 19:27:33 +0900 Koichi Sasada <ko1@atdot.net>

- * ext/win32ole/.cvsignore : removed

- * ext/win32ole/.document : ditto

-2006-02-22(Wed) 18:17:06 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : set Binding as YARVCore::VM::Binding

-2006-02-22(Wed) 12:54:45 +0900 Koichi Sasada <ko1@atdot.net>

- * ChangeLog : remove needless line

-2006-02-22(Wed) 12:49:02 +0900 Koichi Sasada <ko1@atdot.net>

- * rubysig.h : remove CHECK_INTS

- * eval_load.c : ditto

- * ext/readline/readline.c : ditto

- * thread.c : ditto

- * win32/win32.c : ditto

- * yarv_version.h : 0.4.0

-2006-02-22(Wed) 11:36:04 +0900 Koichi Sasada <ko1@atdot.net>

- * test.rb : removed

-2006-02-22(Wed) 11:12:17 +0900 Koichi Sasada <ko1@atdot.net>

- * README : renewed

- * version.c : fixed version message

- * yarvext/ : removed

-2006-02-22(Wed) 10:33:04 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/.document : imported from Ruby 1.9 HEAD

- * .document : ditto

- * ext/.document : ditto

- * lib/ftools.rb : ditto

- * lib/rdoc/ : ditto

- * eval_thread.c : remove unused functions

- * process.c : ditto

- * rb/insns2vm.rb : compare modified date of vm_opts.h and

- * ruby.h : rename RValue to RValues

-2006-02-22(Wed) 06:32:10 +0900 Koichi Sasada <ko1@atdot.net>

- * configure.in : remove last commit

-2006-02-22(Wed) 06:18:53 +0900 Koichi Sasada <ko1@atdot.net>

- * configure.in : add default program prefix "-yarv"

-2006-02-22(Wed) 06:11:36 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : change default rule (same as HEAD)

- * configure : removed

- * eval.c : remove last commit

- * vm.c : fix stack traverse

- * yarvcore.c : initialize top of control frame

- * version.h : ditto

-2006-02-22(Wed) 04:50:42 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : change to rewind C level control frame

- * vm.c : change to initialize cfp#proc and fix comparison of

- * yarvcore.c : remove last commit

-2006-02-22(Wed) 03:25:56 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : initialize each stack of thread

-2006-02-22(Wed) 00:02:08 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c : fix synchornize return value ([yarv-dev:957])

- and some synchornization error

- * thread_pthread.h : add debug helper function

-2006-02-21(Tue) 20:54:28 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : fix place of rb_thread_terminate_all()

- * eval_thread.c : remove unused functions

- * yarv.h : remove GET_VM()

- * eval_jump.h : ditto

- * insns.def : ditto

- * intern.h : change rb_thread_signal_raise/exit interface

- * signal.c : ditto

- * thread.c : ditto

- * test/ruby/test_beginendblock.rb : use block with IO.popen

- * thread_pthread.h : fix interrupt process

- * thread_win32.h : ditto

- * yarvcore.c : fix thread free process

- * yarvcore.h : remove yarv_vm_t#thread_critical, etc

-2006-02-21(Tue) 12:42:44 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_thread.c : remove unused function rb_thread_schedule()

- * thread.c : rename yarv_thread_schedule to rb_thread_schedule()

- * thread.c, eval.c : fix to terminate all thread and barrier at

- eval.c#ruby_cleanup()

- * thread_win32.h : remove native_thread_cleanup()

- * thread_pthread.h : ditto

- * yarvcore.c : ditto

- * yarvtest/test_thread.rb : separete assersions to tests

-2006-02-21(Tue) 02:13:33 +900 Yukihiro Matsumoto <matz@ruby-lang.org>

- * parse.y (f_arglist): should set command_start = Qtrue for

- command body. [ruby-talk:180648]

-2006-02-20(Mon) 20:41:07 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c : fix to synchronize signal_thread_list access

-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

- * eval_intern.h : fix to initialize tag->tag

- * yarvtest/test_jump.rb : add tests for above

- * eval_jump.h : use local variable

-2006-02-20(Mon) 15:13:24 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_vm3_thread_create_join.rb : added

- * test/yaml/test_yaml.rb : imported from Ruby CVS trunk HEAD

-2006-02-20(Mon) 14:49:46 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/yaml.rb: imported from Ruby CVS trunk HEAD.

- * lib/yaml: ditto.

- * ext/syck: ditto.

-2006-02-20(Mon) 13:58:03 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support block parameter which is NODE_ATTRASGN

- * yarvtest/test_block.rb : add tests for above

- * compile.c : fix NODE_DASGN_CURR level check

- * compile.c : fix "||=" (at firtst, check "defined? val")

- * compile.c : fix NODE_MATCH3 (permute receiver and argument)

- * yarvtest/test_bin.rb : add tests for above

- * eval.c : add rb_each()

- * test/ruby/test_signal.rb : increment a timeout value

- * thread.c, yarvcore.h : fix "join" flow

- * thread_pthread.h : ditto

- * thread_win32.h : ditto

- * yarvtest/test_thread.rb : add a test for above

- * vm.h, vm.c, vm_dump.c, insns.def : add FRAME_MAGIC_LAMBDA and

- support return from lambda (especially retrun from method defined

- by "define_method")

- * yarvtest/test_method.rb : add a test for above

- * yarvcore.c : remove unused functions

-2006-02-20(Mon) 11:22:31 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_eval.rb: now Object#funcall is defined.

-2006-02-20(Mon) 11:04:32 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/irb/lc/ja/CVS: removed.

-2006-02-20(Mon) 10:55:59 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/mutex_m.rb: imported from Ruby CVS trunk HEAD.

- * lib/observer.rb: ditto.

- * lib/wsdl: ditto.

- * lib/monitor.rb: ditto (removing Thread.critical=).

- * lib/soap: ditto.

- * lib/drb.rb: ditto.

-2006-02-20(Mon) 10:49:31 +0900 Minero Aoki <aamine@loveruby.net>

- * yarvcore.c (Init_yarvcore): fix typo (duo -> dup).

-2006-02-19(Sun) 01:27:08 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : "return" from lambda{} break block

- * eval.c : Unsupport Proc as Binding

- * test/ruby/test_eval.rb : apply above changes

- * yarvcore.c : remove unused function yarv_yield_values()

-2006-02-18(Sat) 03:19:36 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c, insns.def : fix passing value when thread killed

- * yarvtest/test_thread.rb : add tests for above

-2006-02-19(Sun) 01:19:42 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/thread.rb (SizedQueue): didn't work. This patch was

- contributed by yukimizake. [yarv-dev:916]

-2006-02-18(Sat) 03:19:36 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c, insns.def : fix passing value when thread killed

- * yarvtest/test_thread.rb : add tests for above

-2006-02-18(Sat) 02:40:18 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, vm.c, vm_macro.def : change BMETHOD algorithm

- * yarvtest/test_class.rb : add a test for above

-2006-02-17(Fri) 23:59:51 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c, yarv.h : change th_invoke_proc() interface

- * eval_proc.c : ditto

- * signal.c : ditto

- * thread.c : ditto

- * yarvcore.c : ditto

- * vm_macro.def : ditto and fix NODE_BMETHOD call

- * vm.c : change name ("th_set_env()" to "push_frame()") and

- * insns.def : ditto

- * eval.c : remove proc_jump_error()

- * benchmark/bm_app_answer.rb : added

- * vm_opts.h.base : add optimize option

-2006-02-17(Fri) 13:37:57 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, ruby.h : add rb_errinfo()

- * eval_error.h (error_pos) : fix process order

- * bin/erb : imported from ruby 1.9

- * bin/rdoc : ditto

- * bin/testrb : ditto

- * ext/curses/.cvsignore : ditto

- * ext/curses/curses.c : ditto

- * ext/curses/depend : ditto

- * ext/curses/extconf.rb : ditto

- * ext/curses/hello.rb : ditto

- * ext/curses/mouse.rb : ditto

- * ext/curses/rain.rb : ditto

- * ext/curses/view.rb : ditto

- * ext/curses/view2.rb : ditto

- * ext/fcntl/.cvsignore : ditto

- * ext/fcntl/depend : ditto

- * ext/fcntl/extconf.rb : ditto

- * ext/fcntl/fcntl.c : ditto

- * ext/readline/README : ditto

- * ext/readline/README.ja : ditto

- * ext/readline/depend : ditto

- * ext/readline/extconf.rb : ditto

- * ext/readline/readline.c : ditto

- * ext/win32ole/.document : ditto

- * ext/zlib/doc/zlib.rd : ditto

- * ext/zlib/extconf.rb : ditto

- * ext/zlib/zlib.c : ditto

- * lib/cgi/.document : ditto

- * lib/cgi/session.rb : ditto

- * lib/cgi/session/pstore.rb : ditto

- * lib/shell/builtin-command.rb : ditto

- * lib/shell/command-processor.rb : ditto

- * lib/shell/error.rb : ditto

- * lib/shell/filter.rb : ditto

- * lib/shell/process-controller.rb : ditto

- * lib/shell/system-command.rb : ditto

- * lib/shell/version.rb : ditto

- * lib/xmlrpc/.document : ditto

- * lib/xmlrpc/README.rdoc : ditto

- * lib/xmlrpc/README.txt : ditto

- * lib/xmlrpc/base64.rb : ditto

- * lib/xmlrpc/client.rb : ditto

- * lib/xmlrpc/config.rb : ditto

- * lib/xmlrpc/create.rb : ditto

- * lib/xmlrpc/datetime.rb : ditto

- * lib/xmlrpc/httpserver.rb : ditto

- * lib/xmlrpc/marshal.rb : ditto

- * lib/xmlrpc/parser.rb : ditto

- * lib/xmlrpc/server.rb : ditto

- * lib/xmlrpc/utils.rb : ditto

- * rdoc/README : ditto

- * rdoc/code_objects.rb : ditto

- * rdoc/diagram.rb : ditto

- * rdoc/dot/dot.rb : ditto

- * rdoc/generators/chm_generator.rb : ditto

- * rdoc/generators/html_generator.rb : ditto

- * rdoc/generators/ri_generator.rb : ditto

- * rdoc/generators/template/chm/chm.rb : ditto

- * rdoc/generators/template/html/hefss.rb : ditto

- * rdoc/generators/template/html/html.rb : ditto

- * rdoc/generators/template/html/kilmer.rb : ditto

- * rdoc/generators/template/html/old_html.rb : ditto

- * rdoc/generators/template/html/one_page_html.rb : ditto

- * rdoc/generators/template/xml/rdf.rb : ditto

- * rdoc/generators/template/xml/xml.rb : ditto

- * rdoc/generators/xml_generator.rb : ditto

- * rdoc/markup/sample/rdoc2latex.rb : ditto

- * rdoc/markup/sample/sample.rb : ditto

- * rdoc/markup/simple_markup.rb : ditto

- * rdoc/markup/simple_markup/fragments.rb : ditto

- * rdoc/markup/simple_markup/inline.rb : ditto

- * rdoc/markup/simple_markup/lines.rb : ditto

- * rdoc/markup/simple_markup/preprocess.rb : ditto

- * rdoc/markup/simple_markup/to_flow.rb : ditto

- * rdoc/markup/simple_markup/to_html.rb : ditto

- * rdoc/markup/simple_markup/to_latex.rb : ditto

- * rdoc/markup/test/AllTests.rb : ditto

- * rdoc/markup/test/TestInline.rb : ditto

- * rdoc/markup/test/TestParse.rb : ditto

- * rdoc/options.rb : ditto

- * rdoc/parsers/parse_c.rb : ditto

- * rdoc/parsers/parse_f95.rb : ditto

- * rdoc/parsers/parse_rb.rb : ditto

- * rdoc/parsers/parse_simple.rb : ditto

- * rdoc/parsers/parserfactory.rb : ditto

- * rdoc/rdoc.rb : ditto

- * rdoc/ri/ri_cache.rb : ditto

- * rdoc/ri/ri_descriptions.rb : ditto

- * rdoc/ri/ri_display.rb : ditto

- * rdoc/ri/ri_driver.rb : ditto

- * rdoc/ri/ri_formatter.rb : ditto

- * rdoc/ri/ri_options.rb : ditto

- * rdoc/ri/ri_paths.rb : ditto

- * rdoc/ri/ri_reader.rb : ditto

- * rdoc/ri/ri_util.rb : ditto

- * rdoc/ri/ri_writer.rb : ditto

- * rdoc/template.rb : ditto

- * rdoc/tokenstream.rb : ditto

- * rdoc/usage.rb : ditto

- * test/xmlrpc/data/bug_bool.expected : ditto

- * test/xmlrpc/data/bug_bool.xml : ditto

- * test/xmlrpc/data/bug_cdata.expected : ditto

- * test/xmlrpc/data/bug_cdata.xml : ditto

- * test/xmlrpc/data/bug_covert.expected : ditto

- * test/xmlrpc/data/bug_covert.xml : ditto

- * test/xmlrpc/data/datetime_iso8601.xml : ditto

- * test/xmlrpc/data/fault.xml : ditto

- * test/xmlrpc/data/value.expected : ditto

- * test/xmlrpc/data/value.xml : ditto

- * test/xmlrpc/data/xml1.expected : ditto

- * test/xmlrpc/data/xml1.xml : ditto

- * test/xmlrpc/test_datetime.rb : ditto

- * test/xmlrpc/test_features.rb : ditto

- * test/xmlrpc/test_marshal.rb : ditto

- * test/xmlrpc/test_parser.rb : ditto

- * test/xmlrpc/test_webrick_server.rb : ditto

- * test/xmlrpc/webrick_testing.rb : ditto

- * test/zlib/test_zlib.rb : ditto

-2006-02-17(Fri) 09:41:35 +900 Yukihiro Matsumoto <matz@ruby-lang.org>

- * thread.c (sleep_timeval): sleep should always sleep for

- specified amount of time. [ruby-talk:180067]

-2006-02-17(Fri) 02:20:32 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_safe.h, ruby.h : remove ruby_safe_level and add

- rb_safe_level() and rb_set_safe_level_force()

- * eval.c : use above functions

- * eval_jump.h : ditto

- * eval_load.c : ditto

- * eval_method.h : ditto

- * eval_proc.c : ditto

- * eval_thread.c : ditto

- * signal.c : ditto

- * variable.c : ditto

- * ext/win32ole/win32ole.c : ditto

- * vm.c (th_invoke_proc) : save and restore safe level

- * yarvtest/test_proc.rb : add tests for above

- * thread.c : remove unused functions

-2006-02-17(Fri) 01:08:23 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : remove a setspecial second unused operand

- * eval_load.c : remove unused variable th

- * eval_proc.c, yarvcore.c : remove some functions from eval_proc.c

- and move to yarvcore.c

- * insns.def : fix to delete warnings

- * sample/test.rb : comment out Proc#clone tests

- * version.c : add constant RUBY_VM_DATE

- * vm.c : fix some functions

-2006-02-16(Thu) 22:58:27 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, vm.c : use th_yield_setup_args at yield and Proc#call

-2006-02-16(Thu) 19:51:52 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix analysis of block parameter

- * disasm.c : remove rb_bug() (temporarily)

- * insns.def, vm.c : fix passing block parameter

- * sample/test.rb : add "Proc = YARVCore::VM::Proc"

- * test/ruby/test_readpartial.rb : disable on mswin32

- * test/socket/test_tcp.rb : ditto

- * thread.c : fix syntax error (for non GCC)

-2006-02-15(Wed) 22:34:04 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_method.h : move rb_clear_cache_by_id position

- * thread.c : fix Thread#kill

- * test/ruby/test_readpartial.rb : enable tests except cygwin version

- * test/ruby/test_signal.rb : ditto and enable timeout

-2006-02-15(Wed) 22:13:29 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/runit: forgot to commit.

-2006-02-15(Wed) 22:12:25 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/weakref.rb: do not use Thread.critical=.

- * lib/singleton.rb: ditto.

- * lib/timeout.rb: ditto.

- * lib/thread.rb: ditto.

- * test/inlinetest.rb: forgot to commit.

-2006-02-15(Wed) 21:34:17 +0900 Minero Aoki <aamine@loveruby.net>

- * test/test_pp.rb: imported from Ruby CVS trunk HEAD.

- * test/test_shellwords.rb: ditto.

- * test/test_set.rb: ditto.

- * test/test_time.rb: ditto.

- * test/test_ipaddr.rb: ditto.

- * test/test_prettyprint.rb: ditto.

- * test/test_tsort.rb: ditto.

- * test/strscan: ditto.

- * test/testunit: ditto.

-2006-02-15(Wed) 20:03:21 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_method.h : duplicate NODE_METHOD at make an alias

- * yarvtest/test_method.rb : add a test for above

-2006-02-15(Wed) 19:48:59 +0900 Minero Aoki <aamine@loveruby.net>

- * test/rss: imported from Ruby CVS trunk HEAD.

-2006-02-15(Wed) 19:47:51 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c, vm.c : remove methoddef, singletonmethoddef

- instructions and make new insn definemethod

- * yarvcore.c : set toplevel visibility to private

-2006-02-15(Wed) 17:39:16 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_jump.h, vm.c : localjump_error() and jump_tag_but_local_jump()

- move to th_localjump_error and th_jump_tag_but_local_jump at vm.c

- * eval_load.c : ditto

- * insns.def : ditto

- * vm.c (th_make_jump_tag_but_local_jump) : added

- * opt_insn_unif.def : fix indnet (revert change)

- * opt_operand.def : ditto

- * rb/insns2vm.rb : fix error message

- * thread.c : raise exception at join if illegal local jump

-2006-02-15(Wed) 14:21:45 +900 Yukihiro Matsumoto <matz@ruby-lang.org>

- * ChangeLog: add local variables line to support Emacs.

- * eval.c (rb_obj_instance_exec): add new method from 1.9.

- * eval.c (rb_mod_module_exec): ditto.

- * eval.c (yield_under_i): should not pass self as an argument to

- the block for instance_eval. [ruby-core:07364]

- * eval.c (rb_obj_instance_eval): should be no singleton classes for

- true, false, and nil. [ruby-dev:28186]

-2006-02-14(Tue) 19:30:20 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c : fix indent

- * eval.c : fix block_given

- * gc.c : add STACK_START and use it as a substitute for

- * vm.c : fix to raise error if th_yield doesn't have block given

- * yarvcore.c : fix to skip iseq mark array at ObjectSpace.each_object

-2006-02-14(Tue) 18:15:03 +0900 Koichi Sasada <ko1@atdot.net>

- * configure.in : enable pthread by deafult

- * ascii.c : import ruby 1.9 HEAD

- * bignum.c : ditto

- * compar.c : ditto

- * configure : ditto

- * defines.h : ditto

- * enumerator.c : ditto

- * euc_jp.c : ditto

- * ext/win32ole/tests/testWIN32OLE.rb : ditto

- * ext/win32ole/win32ole.c : ditto

- * lib/irb/init.rb : ditto

- * lib/rexml/document.rb : ditto

- * marshal.c : ditto

- * missing.h : ditto

- * object.c : ditto

- * oniguruma.h : ditto

- * process.c : ditto

- * random.c : ditto

- * rb/ir.rb : ditto

- * regcomp.c : ditto

- * regenc.c : ditto

- * regenc.h : ditto

- * regerror.c : ditto

- * regexec.c : ditto

- * regint.h : ditto

- * regparse.c : ditto

- * regparse.h : ditto

- * rubyio.h : ditto

- * sprintf.c : ditto

- * struct.c : ditto

- * test/ruby/envutil.rb : ditto

- * test/ruby/test_struct.rb : ditto

- * version.h : ditto

- * win32/Makefile.sub : ditto

- * win32/win32.c : ditto

-2006-02-14(Tue) 16:40:01 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, eval_proc.c : fix rb_proc_arity

- * eval.c : declare funcall same as send (temporarily)

- * lib/thread.rb : added

- * test/pathname/test_pathname.rb : imported from ruby 1.9

- * test/scanf/data.txt : ditto

- * test/scanf/test_scanf.rb : ditto

- * test/scanf/test_scanfblocks.rb : ditto

- * test/scanf/test_scanfio.rb : ditto

- * test/socket/test_socket.rb : ditto

- * test/socket/test_tcp.rb : ditto

- * test/socket/test_udp.rb : ditto

- * test/socket/test_unix.rb : ditto

- * test/stringio/test_stringio.rb : ditto

- * test/uri/test_common.rb : ditto

- * test/uri/test_ftp.rb : ditto

- * test/uri/test_generic.rb : ditto

- * test/uri/test_http.rb : ditto

- * test/uri/test_ldap.rb : ditto

- * test/uri/test_mailto.rb : ditto

-2006-02-14(Tue) 15:59:28 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c : Change Thread.critical warnning message

- * lib/webrick.rb : imported from ruby 1.9

- * lib/webrick/accesslog.rb : ditto

- * lib/webrick/cgi.rb : ditto

- * lib/webrick/compat.rb : ditto

- * lib/webrick/config.rb : ditto

- * lib/webrick/cookie.rb : ditto

- * lib/webrick/htmlutils.rb : ditto

- * lib/webrick/httpauth.rb : ditto

- * lib/webrick/httpauth/authenticator.rb : ditto

- * lib/webrick/httpauth/basicauth.rb : ditto

- * lib/webrick/httpauth/digestauth.rb : ditto

- * lib/webrick/httpauth/htdigest.rb : ditto

- * lib/webrick/httpauth/htgroup.rb : ditto

- * lib/webrick/httpauth/htpasswd.rb : ditto

- * lib/webrick/httpauth/userdb.rb : ditto

- * lib/webrick/httpproxy.rb : ditto

- * lib/webrick/httprequest.rb : ditto

- * lib/webrick/httpresponse.rb : ditto

- * lib/webrick/https.rb : ditto

- * lib/webrick/httpserver.rb : ditto

- * lib/webrick/httpservlet.rb : ditto

- * lib/webrick/httpservlet/abstract.rb : ditto

- * lib/webrick/httpservlet/cgi_runner.rb : ditto

- * lib/webrick/httpservlet/cgihandler.rb : ditto

- * lib/webrick/httpservlet/erbhandler.rb : ditto

- * lib/webrick/httpservlet/filehandler.rb : ditto

- * lib/webrick/httpservlet/prochandler.rb : ditto

- * lib/webrick/httpstatus.rb : ditto

- * lib/webrick/httputils.rb : ditto

- * lib/webrick/httpversion.rb : ditto

- * lib/webrick/log.rb : ditto

- * lib/webrick/server.rb : ditto

- * lib/webrick/ssl.rb : ditto

- * lib/webrick/utils.rb : ditto

- * lib/webrick/version.rb : ditto

-2006-02-14(Tue) 14:55:51 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : support "defined?($1)", ...

- * yarvtest/test_syntax.rb : add a test for above

- * rb/makedocs.rb : fix template directory path

- * vm.c : fix to handle break from proc

-2006-02-14(Tue) 12:42:59 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : fix rb_iterate hook

- * yarvtest/test_block.rb : add a tests for above

- * vm.c : remove unused comment

-2006-02-14(Tue) 12:01:06 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : fix to check passed block at block_given_p

- * eval_proc.c : fix to pass block at Method#call

- * runruby.rb : fix to apply ruby

- * test/runner.rb : GC.stress (comment out)

- * vm.c : fix indnet

-2006-02-14(Tue) 08:04:33 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/tempfile.rb: use Mutex instead of Thread.critical.

- * lib/rss/dublincore.rb: |x,| -> |x,_| to avoid YARV bug (tmp).

- * lib/rexml: imported from ruby CVS trunk HEAD.

- * test/digest: ditto.

- * test/fileutils: ditto.

- * test/ostruct: ditto.

- * test/erb: ditto.

- * test/optparse: ditto.

- * test/ruby/test_signal.rb: turn off a test to avoid unknown error

-2006-02-14(Tue) 07:52:03 +0900 Minero Aoki <aamine@loveruby.net>

- * test/digest: imported from ruby CVS trunk HEAD.

- * test/fileutils: ditto.

- * test/ostruct: ditto.

- * test/erb: ditto.

- * test/optparse: ditto.

-2006-02-14(Tue) 06:26:21 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, parse.y : support BEGIN{} (remove local scope)

- * test/ruby/beginmainend.rb : fix to apply YARV's specification

- * test/ruby/test_beginendblock.rb : enable BEGIN{} test

- * signal.c : exit at double segv

- * insns.def (preexe) : remove instruction "preexe"

-2006-02-14(Tue) 05:53:56 +0900 Minero Aoki <aamine@loveruby.net>

- * eval.c (ruby_cleanup): th->errinfo contains a NODE while

- break'ing, check it before refering klass.

-2006-02-14(Tue) 05:45:07 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix stack calc of send

- * sample/test.rb : remove SEGV causing code

-2006-02-14(Tue) 02:24:21 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_module.rb: list order is not a matter.

- * test/csv: imported from ruby CVS trunk HEAD.

-2006-02-14(Tue) 02:06:25 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_beginendblock.rb: unlock tests.

- * test/ruby/beginmainend.rb: new file (imported from ruby CVS

- * test/ruby/endblockwarn.rb: new file (imported from ruby CVS

- * test/ruby/test_file.rb: new file (imported from ruby CVS trunk

-2006-02-14(Tue) 01:42:11 +0900 Koichi Sasada <ko1@atdot.net>

- * error.c : fix include file positon

- * test/ruby/test_signal.rb : skip test_exit_action on cygwin

-2006-02-14(Tue) 01:36:57 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_class.rb: new file (imported from rubicon).

-2006-02-14(Tue) 01:32:23 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_module.rb: ignore PP mixins.

-2006-02-14(Tue) 01:24:56 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_lambda.rb: removed (->(){...} syntax is

-2006-02-14(Tue) 01:20:54 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_module.rb: import many tests from rubicon.

-2006-02-14(Tue) 01:06:57 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix to avoid stack consistency error

- * yarvtest/test_exception.rb : add a test for above

-2006-02-14(Tue) 00:42:47 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, vm_macro.def : rename VM_CALL_SUPER to VM_CALL_SUPER_BIT

- * insns.def (send) : set a flag of super as fcall

- * yarvtest/test_class.rb : add a test for above

-2006-02-14(Tue) 00:31:24 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_eval.rb: fix typo.

- * test/ruby/test_signal.rb: unlock tests.

-2006-02-13(Mon) 23:53:27 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, vm_macro.def : fix NODE_ZSUPER dispatch and

- fix error message when super without suitable method ([yarv-dev:846])

- * yarvcore.h : add VM_CALL_SUPER definition

- * yarvtest/test_method.rb : add a test of Module#private_class_method

-2006-02-13(Mon) 22:49:42 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : traverse all iseq to find super method ([yarv-dev:859])

- * yarvtest/test_class.rb : add a test for above

- * yarvcore.c : add clear iseq->defined_method_id

- * signal.c : fix to prohibit double segv handler kicked

-2006-02-13(Mon) 22:09:12 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_DECL, NODE_CLASS with NODE_CLON3 prefix

- * yarvtest/test_class.rb : add tests for above

-2006-02-13(Mon) 21:20:57 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix indent

- * compile.c : fix to prohibit "redo" from eval expression

-2006-02-13(Mon) 20:36:06 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : fix constant search bug ([yarv-dev:788])

- * yarvtest/test_class.rb : add a test of [yarv-dev:788]

-2006-02-13(Mon) 18:09:28 +0900 Koichi Sasada <ko1@atdot.net>

- * test/ruby/test_clone.rb : enable tests with Class#clone

- * test/ruby/test_marshal.rb : ditto

-2006-02-13(Mon) 17:42:37 +0900 Koichi Sasada <ko1@atdot.net>

- * class.c : support Class#clone

- * compile.c, insns.def : remove popcref

- * yarvcore.h, vm.c, insns.def : remove yarv_thread_t#cref_stack

- * eval.c, eval_intern.h, eval_load.c : ditto

- * yarvtest/test_class.rb : add tests for singleton class

- * gc.c : remove "FRAME *" unused variable

- * insnhelper.h : fix COPY_CREF

- * rb/mklog.rb : add default message

- * vm_macro.def : support NODE_ZSUPER as method type

-2006-02-13(Mon) 00:11:17 +0900 Koichi Sasada <ko1@atdot.net>

- * blockinlining.c : refoctoring with CFLAGS+=-Wunused

- * eval_intern.h : ditto

- * eval_load.c : ditto

- * eval_method.h : ditto

- * eval_proc.c : ditto

- * eval_thread.c : ditto

- * insns.def : ditto

- * thread.c : ditto

-2006-02-13(Mon) 02:32:34 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_const.rb: show better message.

- * test/ruby/test_eval.rb: ditto.

- * test/ruby/test_module.rb: new file.

-2006-02-12(Sun) 22:22:35 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c : revert last commit

- * bignum.c : ditto

- * compar.c : ditto

- * defines.h : ditto

- * enumerator.c : ditto

- * euc_jp.c : ditto

- * intern.h : ditto

- * marshal.c : ditto

- * missing.h : ditto

- * numeric.c : ditto

- * object.c : ditto

- * oniguruma.h : ditto

- * process.c : ditto

- * random.c : ditto

- * rb/mklog.rb : ditto

- * regcomp.c : ditto

- * regenc.c : ditto

- * regenc.h : ditto

- * regerror.c : ditto

- * regexec.c : ditto

- * regint.h : ditto

- * regparse.c : ditto

- * regparse.h : ditto

- * rubyio.h : ditto

- * rubysig.h : ditto

- * signal.c : ditto

- * sprintf.c : ditto

- * string.c : ditto

- * struct.c : ditto

- * variable.c : ditto

- * version.c : ditto

-2006-02-12(Sun) 21:33:10 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c : fix to ruby's indent

- * bignum.c : ditto

- * blockinlining.c : ditto

- * call_cfunc.h : ditto

- * compar.c : ditto

- * compile.c : ditto

- * compile.h : ditto

- * defines.h : ditto

- * disasm.c : ditto

- * enumerator.c : ditto

- * euc_jp.c : ditto

- * eval_error.h : ditto

- * eval_intern.h : ditto

- * eval_jump.h : ditto

- * eval_load.c : ditto

- * eval_method.h : ditto

- * eval_proc.c : ditto

- * eval_safe.h : ditto

- * eval_thread.c : ditto

- * insnhelper.h : ditto

- * insns.def : ditto

- * intern.h : ditto

- * marshal.c : ditto

- * missing.h : ditto

- * numeric.c : ditto

- * object.c : ditto

- * oniguruma.h : ditto

- * opt_insn_unif.def : ditto

- * opt_operand.def : ditto

- * process.c : ditto

- * random.c : ditto

- * regcomp.c : ditto

- * regenc.c : ditto

- * regenc.h : ditto

- * regerror.c : ditto

- * regexec.c : ditto

- * regint.h : ditto

- * regparse.c : ditto

- * regparse.h : ditto

- * rubyio.h : ditto

- * rubysig.h : ditto

- * signal.c : ditto

- * sprintf.c : ditto

- * string.c : ditto

- * struct.c : ditto

- * thread.c : ditto

- * thread_pthread.h : ditto

- * thread_win32.h : ditto

- * variable.c : ditto

- * version.c : ditto

- * vm_dump.c : ditto

- * vm_evalbody.h : ditto

- * vm_macro.def : ditto

- * yarv_version.h : ditto

- * yarvcore.c : ditto

- * yarvcore.h : ditto

-2006-02-12(Sun) 15:53:21 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/abbrev.rb : added

- * lib/base64.rb : ditto

- * lib/cgi-lib.rb : ditto

- * lib/csv.rb : ditto

- * lib/date2.rb : ditto

- * lib/eregex.rb : ditto

- * lib/ipaddr.rb : ditto

- * lib/irb.rb : ditto

- * lib/irb/cmd/chws.rb : ditto

- * lib/irb/cmd/fork.rb : ditto

- * lib/irb/cmd/help.rb : ditto

- * lib/irb/cmd/load.rb : ditto

- * lib/irb/cmd/nop.rb : ditto

- * lib/irb/cmd/pushws.rb : ditto

- * lib/irb/cmd/subirb.rb : ditto

- * lib/irb/completion.rb : ditto

- * lib/irb/context.rb : ditto

- * lib/irb/ext/change-ws.rb : ditto

- * lib/irb/ext/history.rb : ditto

- * lib/irb/ext/loader.rb : ditto

- * lib/irb/ext/math-mode.rb : ditto

- * lib/irb/ext/multi-irb.rb : ditto

- * lib/irb/ext/save-history.rb : ditto

- * lib/irb/ext/tracer.rb : ditto

- * lib/irb/ext/use-loader.rb : ditto

- * lib/irb/ext/workspaces.rb : ditto

- * lib/irb/extend-command.rb : ditto

- * lib/irb/frame.rb : ditto

- * lib/irb/help.rb : ditto

- * lib/irb/init.rb : ditto

- * lib/irb/input-method.rb : ditto

- * lib/irb/lc/error.rb : ditto

- * lib/irb/lc/help-message : ditto

- * lib/irb/lc/ja/CVS/Entries : ditto

- * lib/irb/lc/ja/CVS/Repository : ditto

- * lib/irb/lc/ja/CVS/Root : ditto

- * lib/irb/lc/ja/error.rb : ditto

- * lib/irb/lc/ja/help-message : ditto

- * lib/irb/locale.rb : ditto

- * lib/irb/notifier.rb : ditto

- * lib/irb/output-method.rb : ditto

- * lib/irb/ruby-lex.rb : ditto

- * lib/irb/ruby-token.rb : ditto

- * lib/irb/slex.rb : ditto

- * lib/irb/version.rb : ditto

- * lib/irb/workspace.rb : ditto

- * lib/irb/ws-for-case-2.rb : ditto

- * lib/irb/xmp.rb : ditto

- * lib/jcode.rb : ditto

- * lib/logger.rb : ditto

- * lib/mailread.rb : ditto

- * lib/mathn.rb : ditto

- * lib/parsedate.rb : ditto

- * lib/pathname.rb : ditto

- * lib/ping.rb : ditto

- * lib/pstore.rb : ditto

- * lib/resolv-replace.rb : ditto

- * lib/resolv.rb : ditto

- * lib/rss.rb : ditto

- * lib/rss/0.9.rb : ditto

- * lib/rss/1.0.rb : ditto

- * lib/rss/2.0.rb : ditto

- * lib/rss/content.rb : ditto

- * lib/rss/converter.rb : ditto

- * lib/rss/dublincore.rb : ditto

- * lib/rss/image.rb : ditto

- * lib/rss/maker.rb : ditto

- * lib/rss/maker/0.9.rb : ditto

- * lib/rss/maker/1.0.rb : ditto

- * lib/rss/maker/2.0.rb : ditto

- * lib/rss/maker/base.rb : ditto

- * lib/rss/maker/content.rb : ditto

- * lib/rss/maker/dublincore.rb : ditto

- * lib/rss/maker/image.rb : ditto

- * lib/rss/maker/syndication.rb : ditto

- * lib/rss/maker/taxonomy.rb : ditto

- * lib/rss/maker/trackback.rb : ditto

- * lib/rss/parser.rb : ditto

- * lib/rss/rexmlparser.rb : ditto

- * lib/rss/rss.rb : ditto

- * lib/rss/syndication.rb : ditto

- * lib/rss/taxonomy.rb : ditto

- * lib/rss/trackback.rb : ditto

- * lib/rss/utils.rb : ditto

- * lib/rss/xml-stylesheet.rb : ditto

- * lib/rss/xmlparser.rb : ditto

- * lib/rss/xmlscanner.rb : ditto

- * lib/rubyunit.rb : ditto

- * lib/scanf.rb : ditto

- * lib/shell.rb : ditto

- * lib/singleton.rb : ditto

- * lib/tsort.rb : ditto

- * lib/weakref.rb : ditto

- * eval_jump.c : removed

-2006-02-12(Sun) 15:39:09 +0900 Koichi Sasada <ko1@atdot.net>

- * parse.y : fix to remove including env.h

- * yarvtest/test_exception.rb : fix syntax (add 'end')

-2006-02-12(Sun) 15:14:44 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : remove env.h dependency

- * compile.c, eval_intern.h : remove include env.h

- * ruby.h, gc.c, error.c : remove T_SCOPE, T_VARMAP

- * parse.y, eval.c : use rb_parse_in_eval() instead of ruby_in_eval

- * yarvcore.c, yarvcore.h : add a prase_in_eval member to yarv_thread_t

- * insns.def : add push value to throw instruction

- for stack consistency

- * yarvtest/test_exception.rb : add a test for above

- * test/ruby/test_gc.rb : fix typo

-2006-02-12(Sun) 05:05:02 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, eval_intern.h, eval_load.c, eval_proc.c, node.h,

- insnhelper.h, insns.def, vm.c, yarvcore.c, yarvcore.h :

- change cref data structure and unify ruby_class and ruby_cbase

- and some refoctoring

-2006-02-11(Sat) 23:41:11 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def (methoddef) : fix method declaration in method

- * thread.c : Thread.critical to show warning (no effect)

-2006-02-11(Sat) 20:20:18 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix [yarv-dev:831]

- * yarvtest/test_class.rb : add a test for above

-2006-02-11(Sat) 14:29:01 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/mklog.rb : use svk

- * error.c : remove newline

- * eval.c (rb_block_call) : added

- * eval_thread.c : remove some unused functions, comments

- * thread.c : add comments (move from eval_thread.c) and support Mutex

- * thread.c (rb_thread_select) : supported

- * thread_pthread.h (native_mutex_trylock) : added (macro)

- * thread_win32.h (native_mutex_trylock) : added

- * yarvcore.c : remove unused code

- * array.c : import ruby 1.9

- * compar.c : ditto

- * enumerator.c : ditto

- * ext/digest/digest.c : ditto

- * ext/digest/digest.h : ditto

- * ext/digest/sha2/sha2.c : ditto

- * ext/etc/etc.c : ditto

- * ext/win32ole/win32ole.c : ditto

- * intern.h : ditto

- * missing.h : ditto

- * missing/flock.c : ditto

- * missing/isinf.c : ditto

- * missing/vsnprintf.c : ditto

- * lib/cgi.rb : ditto

- * lib/complex.rb : ditto

- * lib/delegate.rb : ditto

- * lib/erb.rb : ditto

- * lib/fileutils.rb : ditto

- * lib/matrix.rb : ditto

- * lib/mkmf.rb : ditto

- * lib/optparse.rb : ditto

- * lib/ostruct.rb : ditto

- * lib/pp.rb : ditto

- * lib/timeout.rb : ditto

- * lib/tmpdir.rb : ditto

- * lib/test/unit/autorunner.rb : ditto

- * object.c : ditto

- * sample/test.rb : ditto

- * sprintf.c : ditto

- * test/ruby/test_whileuntil.rb : ditto

- * test/runner.rb : ditto

- * lib/net/.document : added

- * lib/net/ftp.rb : ditto

- * lib/net/http.rb : ditto

- * lib/net/https.rb : ditto

- * lib/net/imap.rb : ditto

- * lib/net/pop.rb : ditto

- * lib/net/protocol.rb : ditto

- * lib/net/smtp.rb : ditto

- * lib/net/telnet.rb : ditto

- * lib/open-uri.rb : ditto

-2006-02-10(Fri) 08:07:34 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def, yarvcore.h : support defined?(private_method) and

- defined?(protected_method) (separate DEFINE_METHOD / DEFINE_FUNC)

- * yarvtest/test_syntax.rb : add a test for above

- * compile.c (iseq_compile_each) : fix NODE_RETURN bug

- (double ensure invoke)

- * yarvtest/test_flow.rb : add a test for above

- * eval.c (get_errinfo) : fix to search $!

- * yarvtest/test_exception.rb : add tests for above

- * eval_safe.h : support $SAFE

- * ext/socket/socket.c : import ruby 1.9

- * gc.c (gc_mark_children) : fix making T_VALUE

- * test/ruby/test_gc.rb : use GC.stress

- * signal.c (sighandler) : send interrupt signal if thread blocked

- * test/ruby/test_proc.rb : remove assert false

- * test/ruby/test_readpartial.rb : change fail message

- * test/ruby/test_signal.rb : remove assert false

- * thread.c (thread_start_func_2) : set local_lfp/local_svar

- at thread creation

- * thread_pthread.h : export native_thread_interrupt

- * thread_win32.h : export native_thread_interrupt

- * version.h : import ruby 1.9

- * vm.c (lfp_svar), yarvcore.h : fix to use Thread local svar

- * yarvtest/test_thread.rb : add a test for above

- * win32/Makefile.sub : import ruby 1.9

- * win32/dir.h : ditto

- * win32/setup.mak : ditto

- * win32/win32.c : ditto

- * yarvtest/yarvtest.rb : fix to remove using ARGV

-2006-02-10(Fri) 01:04:58 +0900 Yukihiro Matsumoto <matz@ruby-lang.org>

- * gc.c (rb_gc_call_finalizer_at_exit): turn on during_gc while

- invoking finalizers.

- * gc.c (rb_gc_finalize_deferred): ditto.

-2006-02-08(Wed) 23:17:44 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_proc.rb: method names were wrongly duplicated.

-2006-02-08(Wed) 21:30:01 +0900 Minero Aoki <aamine@loveruby.net>

- * ext/nkf: added (imported from ruby CVS trunk HEAD).

- * ext/nkf/depend: new file (rev 1.5).

- * ext/nkf/extconf.rb: new file (rev 1.2).

- * ext/nkf/nkf.c: new file (rev 1.12).

- * ext/nkf/test.rb: new file (rev 1.7).

- * ext/nkf/nkf-utf8/nkf.c: new file (rev 1.17).

- * ext/nkf/nkf-utf8/config.h: new file (rev 1.4).

- * ext/nkf/nkf-utf8/utf8tbl.c: new file (rev 1.6).

- * ext/nkf/lib/kconv.rb: new file (rev 1.13).

- * test/nkf: added (imported from ruby CVS trunk HEAD).

- * test/nkf/test_kconv.rb: new file (rev 1.1).

- * test/nkf/test_nkf.rb: new file (rev 1.1).

-2006-02-08(Wed) 21:07:36 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/find.rb: new file (imported from ruby CVS trunk HEAD,

-2006-02-07(Tue) 17:58:18 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : support BEGIN{} and add preexe instruction

- * insns.def : fix getspecial/setspecial instructions

- to catch up svar change

- * test/ruby/test_system.rb : remove stopper

- * thread.c (rb_thread_fd_writable) : add a debug output

- * thread.c (rb_thread_wait_fd) : add a debug output

- * vm.c (lfp_svar) : refactoring and fix some problems

- * vm_dump.c (yarv_bug) : add branch

- * yarv.h : remove unused declarations

- * yarvcore.c (vm_free) : VM object should not free by GC

-2006-02-07(Tue) 14:42:25 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, eval_load.c : remove rb_thread_start_1()

- * eval.c : fix some prototypes and indents

- * eval_thread.c, thread.c : move some functions

- from eval_thread.c to thread.c

- * signal.c (sighandler) : add line braek in error message

- * yarvcore.c, yarvcore.h, thread.c : support ThreadGroup

- * ruby.h, gc.c, vm.c : make new basic type RValue and T_VALUE.

- RValue includes three values in itself. RValue is used as

-2006-02-06(Mon) 23:51:41 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_hash.rb: import many tests from rubicon.

-2006-02-04(Sat) 18:36:41 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_array.rb: import many tests from rubicon.

-2006-02-04(Sat) 17:47:44 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_signal.rb (test_exit_action): lib/timeout.rb is

- not implemented yet.

-2006-02-04(Sat) 17:42:31 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_readpartial.rb: lib/timeout.rb is not implemented

-2006-02-04(Sat) 16:22:38 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_pipe.rb: remove useless require.

- * test/ruby/test_signal.rb: turn off the test case which causes

- segmentation fault (tmp).

-2006-02-04(Sat) 08:19:50 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add dependency to yarvcore.h on signal.o

- * compile.c (iseq_compile_each) : fix [yarv-dev:795] problem

- (prohibit "break", "next" jump from eval)

- * eval.c : fix indent

- * eval_thread.c, thread.c : remove some functions and move to thread.c

- * insns.def, vm.c : fix [yarv-dev:799] and [yarv-dev:800]

- * yarvtest/test_class.rb : add a test for above

- * test/ruby/test_gc.rb : remove GC.debug_flag control

- * test/ruby/test_readpartial.rb : disable

- * test/ruby/test_signal.rb : disable

- * thread.c : fix thread_debug() and many bugs

- * thread.c (yarv_thread_s_new) : move living_threads setting

- * thread.c (yarv_thread_join) : fix

- * thread_pthread.h : add type native_thread_data_t (dummy)

- and support interrupt blocking thread

- * thread_pthread.h (native_thread_apply_priority) : added

- * thread_win32.h : add type native_thread_data_t (dummy)

- and support interrupt blocking thread

- * yarvcore.h : use win32 thread system on cygwin and fix

- some struct members

- * yarvtest/test_thread.rb : added

-2006-02-03(Fri) 00:08:09 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_string.rb: import many tests from rubicon.

-2006-02-02(Thu) 23:20:13 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/envutil.rb: new file (imported from ruby trunk HEAD).

- * test/ruby/marshaltestlib.rb: ditto.

- * test/ruby/test_array.rb: ditto.

- * test/ruby/test_beginendblock.rb: ditto.

- * test/ruby/test_clone.rb: ditto.

- * test/ruby/test_dir.rb: ditto.

- * test/ruby/test_env.rb: ditto.

- * test/ruby/test_file.rb: ditto.

- * test/ruby/test_float.rb: ditto.

- * test/ruby/test_fnmatch.rb: ditto.

- * test/ruby/test_hash.rb: ditto.

- * test/ruby/test_io.rb: ditto.

- * test/ruby/test_marshal.rb: ditto.

- * test/ruby/test_math.rb: ditto.

- * test/ruby/test_pack.rb: ditto.

- * test/ruby/test_path.rb: ditto.

- * test/ruby/test_pipe.rb: ditto.

- * test/ruby/test_rand.rb: ditto.

- * test/ruby/test_range.rb: ditto.

- * test/ruby/test_readpartial.rb: ditto.

- * test/ruby/test_regexp.rb: ditto.

- * test/ruby/test_settracefunc.rb: ditto.

- * test/ruby/test_signal.rb: ditto.

- * test/ruby/test_sprintf.rb: ditto.

- * test/ruby/test_string.rb: ditto.

- * test/ruby/test_stringchar.rb: ditto.

- * test/ruby/test_struct.rb: ditto.

- * test/ruby/test_symbol.rb: ditto.

- * test/ruby/test_system.rb: ditto.

- * test/ruby/test_time.rb: ditto.

- * test/ruby/ut_eof.rb: ditto.

-2006-02-02(Thu) 22:53:44 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_proc.rb: test [yarv-dev:777].

-2006-02-01(Wed) 03:51:39 +0900 Koichi Sasada <ko1@atdot.net>

- * gc.c : add GC.debug_flag= method

- * insns.def : support method definition in method

- * yarvtest/test_method.rb : add tests for above

-2006-01-29(Sun) 11:40:26 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_proc.c (proc_alloc) : fix [yarv-dev:777]

- * yarvtest/test_proc.rb : add a test for above

- * insns.def : fix [yarv-dev:782] and add YARV_CHECK_INTS()

- * yarvtest/test_class.rb : add a test for above

- * thread_win32.h : fix [yarv-dev-en:23]

- * vm.c (th_call0) : add YARV_CHECK_INTS()

-2006-01-09(Mon) 11:56:34 +0900 Minero Aoki <aamine@loveruby.net>

- * yarvcore.h: add prototype (remove warning).

- * vm.c (th_invoke_proc): make save variables volatile.

- * eval.c (eval): initialize local variables (remove warnings).

- * eval_thread.c (rb_exec_recursive): ditto.

- * yarvcore.c (thread_mark): ditto.

- * vm.c (th_invoke_proc): ditto.

- * eval.c: remove useless prototypes.

-2006-01-09(Mon) 10:25:12 +0900 Minero Aoki <aamine@loveruby.net>

- * eval_thread.c: rb_thread_join is required to build ruby on

- * compile.c: unify coding style.

- * yarvcore.c: ditto.

-2006-01-06(Fri) 09:21:34 +0900 Minero Aoki <aamine@loveruby.net>

- * vm.c: coding style change only.

-2006-01-04(Wed) 14:12:47 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c (ruby_init), eval_intern.h : use POP_TAG_INIT() at bootstrap

- * eval_thread.c : remove unused functions and comments

- * intern.h : expose rb_make_exception()

- * signal.c : support signal

- * thread.c (yarv_thread_execute_interrupts) : added

- * thread_pthread.h (thread_timer) : set interrupt_flag of

- current runnning threads

- * vm.c (th_invoke_proc) : jump with JUMP_TAG() if some exception

- * yarv.h : add yarv_set_current_running_thread_raw() for bootstrap

- * yarvcore.c : add yarv_segv() and segv() method for test

- * yarvcore.c (Init_yarvcore) : set yarv_thread_t#running_thread

- * yarvcore.h : fix yarv_thread_t members

-2006-01-03(Tue) 22:25:04 +0900 Koichi Sasada <ko1@atdot.net>

- * disasm.c (insn_operand_intern) : fix to add child iseq

- * eval.c, gc.c : remove obsolete static variables (ruby_scope,

- ruby_dyna_vars, ruby_frame)

- * eval.c (rb_mod_s_constants) : use ruby_cref()

- * eval.c (eval) : use th_restore_klass()

- * eval_proc.c (rb_f_binding) : use th_store_klass()

- * insns.def (concatarray) : fix insn ([expr, *nil] => [expr])

- * vm.c (th_set_env), insnhelper.h : remove macro

- * vm.c (eval_get_cvar_base) : use get_cref

- * vm.c (th_make_proc) : use th_store_klass()

- * vm_macro.def (macro_eval_invoke_func) : fix option args size

- * vm_macro.def (macro_eval_invoke_func) : raise stack overflow error

- * yarvcore.h : add yarv_stored_klass_t type

- * yarvcore.c : fix mark functions around yarv_stored_klass_t

-2006-01-01(Sun) 05:14:26 +0900 Minero Aoki <aamine@loveruby.net>

- * lib/benchmark.rb: new file (imported from original ruby, rev

-2006-01-01(Sun) 03:51:10 +0900 Minero Aoki <aamine@loveruby.net>

- * yarvcore.c: add prototype.

- * re.c: remove warning: long -> unsigned long.

- * debug.c: adjust coding style.

-2006-01-01(Sun) 03:43:33 +0900 Minero Aoki <aamine@loveruby.net>

- * variable.c: add prototype.

- * eval_load.c: ditto.

-2006-01-01(Sun) 02:41:21 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add address analyse to vtune rule

- * rb/vtlh.rb : added for above

- * rb/insns2vm.rb, template/vm.inc.tmpl : insert #line directive

- to reference above

- * vm_macro.def (macro_eval_invoke_cfunc) : fix indent

- * yarvtest/test_method.rb : fix indent, spacing

- and add a test for alias

-2005-12-31(Sat) 12:42:05 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add Intel VTune rule (make vtune)

- * eval.c, yarvcore.h : fix to remove yarv_thread_t#local_*

- * parse.y (top_local_init_gen) : fix a problem ([yarv-dev:765])

- * yarvtest/test_eval.rb : add a test for above

- * vm.c (thread_eval) :remove unused function

- * yarvcore.c (Init_yarvcore) : remove YARVCore::Thread::eval method

- * yarvcore.c (thread_eval) : remove unused function

-2005-12-31(Sat) 06:05:00 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c (eval_search_super_klass) : pass block to method missing

- * vm_macro.def (macro_eval_invoke_method) : ditto

- * yarvtest/test_method.rb : add a test for above

-2005-12-31(Sat) 03:11:14 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c (eval), eval_proc.c (rb_f_binding) : save klass, etc to

- binding and use it at eval

- * eval_intern.h : ditto

- * yarvtest/test_eval.rb : add tests for above

- * yarvcore.c (th_get_special_cref) : added

- * yarvcore.h : add a prototype of above

- * vm.c (th_get_cref) : refactoring

- * vm.c (eval_get_ev_const) : fix SEGV at A::B (A is not class/module)

- * yarvtest/test_bin.rb : add a test for above

- * rb/mklog.rb : use external diff command and show function name

-2005-12-30(Fri) 19:07:51 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, yarvcore.h, eval.c, eval_proc.c : support

- * yarvcore.c : support TOPLEVEL_BINDING

- * yarvtest/test_eval.rb : add tests for above

-2005-12-30(Fri) 13:12:28 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_eval.rb: more tests for

- module_eval/instance_eval.

-2005-12-30(Fri) 05:06:49 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add dependency (yarvcore.h) for gc.c

- * eval.c, eval_intern.h, eval_load.c, eval_method.h,

- insns.def, insnhelper.h, vm.c, yarvcore.c, yarvcore.h :

- re-write class reference

- * yarvtest/test_eval.rb : added

- * yarvtest/test_proc.rb :

-2005-12-29(Thu) 12:27:12 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.h :

- remvoe needless yarv_iseq_t#rewind_frame_size

-2005-12-29(Thu) 11:17:58 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add dependency to test-all rule

- * eval.c (rb_sourceline), vm.c (th_get_sourceline) :

- fix to skip process if iseq is ifunc

- * test/ruby/test_lambda.rb : assert(fail, ...) instead of assert_fail

- * test/ruby/test_proc.rb : ditto

- * vm_dump.c : fix stack dump (iseq name)

- * vm_macro.def : store proc (block proc) to cfp#proc for GC mark

- * yarvcore.c : mark above on thread_mark

- * eval.c (exec_under) : replace block#self ([yarv-dev:751])

-2005-12-29(Thu) 01:56:46 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : fix setting of Proc cref ([yarv-dev:741])

- * yarvcore.c : fix indent

-2005-12-29(Thu) 00:17:03 +0900 Koichi Sasada <ko1@atdot.net>

- * disasm.c : show (block) local variable simple (not as symbol)

- * gc.c : fix syntax error

-2005-12-28(Wed) 23:35:06 +0900 Koichi Sasada <ko1@atdot.net>

- * class.c (method_entry) : fixed for undefed method ([yarv-dev:743])

- * compile.c : fix errinfo dvar id (#$!)

- and fix NODE_ERRINFO compilation

- * eval_proc.c, yarvcore.c : support YARVCore::VM::Proc.new

- * insns.def : remove useless TODO comments

- * insns.def : fix to use strict array conversion on

- * insns.def : fix defined?(yield) ([yarv-dev:744])

- * yarvcore.h : change yarv_iseq_t layout

-2005-12-28(Wed) 16:49:55 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_eval.rb: add TODO comment.

- * test/ruby/test_iterator.rb: rename YARVCore::VM::Proc -> Proc

- * test/ruby/test_lambda.rb: use assert_fail.

- * test/ruby/test_proc.rb: ditto.

-2005-12-28(Wed) 16:28:35 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_clone.rb: removed (tmp).

- * test/ruby/test_eval.rb: define missing method Object#funcall

- * test/ruby/test_lambda.rb: turn off tests for "->".

- * test/ruby/test_proc.rb: turn off tests for |&b|.

- * test/ruby/test_proc.rb: turn off tests for $SAFE setter.

-2005-12-28(Wed) 15:31:46 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix calculation of stack_max

- * eval.c (rb_iter) : fix block/retry handling

- * yarvtest/test_flow.rb : add tests for above

- * insns.def : fix block passing on super (super(&nil))

- * vm_macro.def, insns.def : fix convert method of object to array

- * yarvtest/test_method.rb : fix a test for above

- * vm.c : fix backtrace generate algorithm

-2005-12-28(Wed) 10:36:45 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, compile.h : refactoring (remove self passing, etc)

- * disasm.c : support showing ID of method/dynamic local variables

- * rb/allload.rb : add verbose version (it's enable by $DEBUG)

- * template/insns.inc.tmpl, template/insns_info.inc.tmpl,

- template/minsns.inc.tmpl, template/opt_sc.inc.tmpl,

- template/optinsn.inc.tmpl, template/optunifs.inc.tmpl,

- template/vmtc.inc.tmpl : fix a comment

- * variable.c (mod_av_set) : fix to clear inline cache ([yarv-dev:720])

- * eval_method.h : fix to clear inline method cache

- * vm.c, rb/insns2vm.rb, template/insns_info.inc.tmpl, compile.c,

- insns.def, vm_evalbody.h, vm_macro.def :

- fix operands types (ulong -> num_t, ...)

- * vm_macro.def : fix to check SPECIAL_CONST_P() at splat array

- * yarvcore.c : fix to throw syntax error

- * yarvcore.h, eval.c, eval_error.h, eval_jump.h :

- add yarv_vm_t#exit_code to fix problem at cleanup ([yarv-dev:723])

- * insns.def : fix to invoke zsuper in method defined by define_method

- * yarvtest/test_class.rb : add tests for above

- * yarvtest/test_method.rb : fix comments

-2005-12-27(Tue) 01:52:07 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c, intern.h, insns.def : expose rb_ary_replace and use it

- * eval.c : fix to use SCOPE_* to NOEX_*

- * eval_intern.h : remove SCOPE_*

- and fix SCOPE_TEST() and SCOPE_SET(f)

- * eval_load.c : save and store klass and visibility

- at require and load

- * eval_method.h : fix undefed method node ([yarv-dev-en:8])

- * eval_proc.c : fix define_method ([yarv-dev:704])

- * insnhelper.h, vm.h : remove GET_VM_STATE_VERSION(),

- INC_VM_STATE_VERSION() and move these to vm.h

- * insns.def : supportintg visibility

- * node.h : remove NOEX_RECV

- * variable.c, vm.c : add rb_vm_change_state() and use it in

- * vm.c, insns.def, yarvcore.h, yarvcore.c : add eval_push_cref(),

- eval_pop_cref() and th_cref_init to manage current visibility

- * yarv.h : add a prototype of rb_vm_change_state()

- * yarvcore.h, insns.def : add defined_method_id and support

- super in define_method scope

- * yarvtest/test_class.rb : add tests for above

-2005-12-26(Mon) 20:44:38 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_basicinstructions.rb: new file.

-2005-12-26(Mon) 08:40:02 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c (eval_get_ev_const) : fix to skip nil

-2005-12-26(Mon) 08:27:15 +0900 Koichi Sasada <ko1@atdot.net>

- * insnhelper.h : fix GET_CVAR_EV_KLASS [yarv-dev:703]

-2005-12-26(Mon) 07:51:01 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : add emptstack insn for all NODE_RETURN

- and optimize it if it's not needed

- * yarvtest/test_flow.rb : add a test for above

-2005-12-26(Mon) 07:08:22 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, gc.c : add "gc_debug_flag" to debug gc

- * insns.def : add emptstack

- * compile.c, rb/insns2vm.rb, template/insns_info.inc.tmpl :

- change interface of insn_stack_increase

- * compile.c : fix return from ensure in method [yarv-dev:702]

- * yarvtest/test_flow.rb : add tests for above

-2005-12-26(Mon) 02:15:02 +0900 Minero Aoki <aamine@loveruby.net>

- * test/ruby/test_alias.rb: do not use unimplemented defined?.

-2005-12-26(Mon) 02:00:11 +0900 Minero Aoki <aamine@loveruby.net>

- * test/runner.rb: new file.

- * test/ruby/test_alias.rb: new file.

- * test/ruby/test_clone.rb: new file.

- * test/ruby/test_eval.rb: new file.

- * test/ruby/test_iterator.rb: new file.

- * test/ruby/test_lambda.rb: new file.

- * test/ruby/test_proc.rb: new file.

- * test/ruby/test_super.rb: new file.

- * test/ruby/test_assignment.rb: new file.

- * test/ruby/test_bignum.rb: new file.

- * test/ruby/test_call.rb: new file.

- * test/ruby/test_case.rb: new file.

- * test/ruby/test_condition.rb: new file.

- * test/ruby/test_const.rb: new file.

- * test/ruby/test_defined.rb: new file.

- * test/ruby/test_exception.rb: new file.

- * test/ruby/test_gc.rb: new file.

- * test/ruby/test_ifunless.rb: new file.

- * test/ruby/test_method.rb: new file.

- * test/ruby/test_trace.rb: new file.

- * test/ruby/test_variable.rb: new file.

- * test/ruby/test_whileuntil.rb: new file.

-2005-12-25(Sun) 07:40:08 +0900 Koichi Sasada <ko1@atdot.net>

- * blockinlining.c, compile.c : fix block inlining

- * rb/insns2vm.rb : fix to support tracing stack depth

- with operands unification

- * vm_dump.c : fix to print Qundef on stack dump

-2005-12-25(Sun) 01:45:55 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c, rb/insns2vm.rb, template/insns_info.inc.tmpl :

- trace stack depth at compile time

- and use it as cont_sp for exception handling

- * yarvtest/test_exception.rb : add tests for above

- * yarvtest/test_flow.rb : ditto

-2005-12-24(Sat) 19:34:04 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, compile.h : fix ADD_CATCH_ENTRY and add LABEL#sp

- * eval_jump.h : fix catch to remove illegal error

-2005-12-24(Sat) 09:05:23 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_method.h : change data structure for RClass#m_tbl

- * class.c, eval.c, eval_proc.c : fix for above changes

- * node.h, gc.c : change NODE_FBODY, NODE_METHOD members

- * insns.def : support private/protected visibility

- * vm_macro.def : ditto

- * thread.c : fix typo

- * thread_pthread.h : fix typo

- * thread_win32.h : fix typo

- * eval.c, yarvcore.h : add yarv_thread_t#method_missing_reason

- to pass method_missing reason and use it to build error message

- * compile.c : use ADD_CALL instead of ADD_SEND for

- NODE_X(D)STR, NODE_CONST (func)

-2005-12-22(Thu) 02:45:27 +0900 Koichi Sasada <ko1@atdot.net>

- * yarv_version.h, Changes : 0.3.3

-2005-12-20(Tue) 04:04:45 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix self::Const access

- * yarvtest/test_bin.rb : add a test for above

-2005-12-20(Tue) 01:52:52 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix to expand VALUES value

- * yarvtest/test_massign.rb : add a test for above

-2005-12-20(Tue) 01:32:35 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, insnhelper.h : fix cvar in singleton method/class

- * yarvtest/test_bin.rb : add tests for above

-2005-12-20(Tue) 01:03:34 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.h : support all defined?() syntax

- * compile.c : fix NODE_COLON2

- * yarvtest/test_bin.rb : add or fix tests for above

- * win32/* : update all

-2005-12-17(Sat) 10:46:08 +0900 Minero Aoki <aamine@loveruby.net>

- * vm_macro.def: fix printf type mismatch for LP64 system (again).

- * parse.y: introduce descriptive macro for special values of

-2005-12-17(Sat) 09:39:27 +0900 Minero Aoki <aamine@loveruby.net>

- * vm_macro.def (macro_eval_invoke_method): fix printf type mismatch

-2005-12-14(Wed) 03:49:40 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : change rescue/ensure iseq name

- * eval.c, intern.h : fix a prototype

- * insns.def, yarvcore.h : add trace_function

- * vm.c : fix deadly bug (illegal pointer cast)

- * vm_dump.c : remove unused local variables

- * vm_macro.def : add parameter size check

- * yarvtest/test_bin.rb : comment out 2 assertions

-2005-12-13(Tue) 03:55:27 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_proc.c : fix indent

- * insns.def : fix getspecial instruction to return nil

- * yarvtest/test_syntax.rb : add a test for above

- * lib/un.rb : added

- * template/*.tmpl : fix typo

-2005-12-13(Mon) 01:38:17 +0900 Minero Aoki <aamine@loveruby.net>

- * yarv.h: add prototypes.

- * intern.h: ditto.

- * thread_pthread.h: fix printf type mismatch for LP64 system

- * variable.c: ditto.

- * object.c: ditto.

- * process.c: ditto.

- * vm_dump.c: ditto.

- * disasm.c: ditto.

- * marshal.c: ditto.

- * eval_thread.c: ditto.

-2005-12-11(Sun) 22:00:34 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : call "inherited" method when a class is inherited

- * yarvcore.h : fix yarv_iseq_t field layout

- * common.mk : add dependence on yarvcore.h to eval*.o files

- * compile.c : fix NODE_POSTEXE logic

- * insnhelper.h : use GC_GUARDED_PTR_REF instead of magic number

- * eval_proc.c : fix indent

- * configure : re-autoconf

-2005-12-10(Sat) 03:57:20 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : fix blockinlining.o build rule

- * insns.def : remove logic for zsuper

- * template/optinsn.inc.tmpl :

- * vm.c : remove thread_yield_light_prepare, thread_yield_light_invoke

- * compile.c : support NODE_ZSUPER with optargs, restarg

- * yarvtest/test_class.rb : add tests for above

-2005-12-09(Fri) 01:13:37 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c, numeric.c, range.c : add prototype of

- block inlining function

- * blockinlining.c, vm_opts.h.base : add block inlining flag

- * common.mk, debug.h, debug.c : add debug_breakpoint() for gdb

- * compile.c : fix to use size_t on compile_data_alloc(),

- fix illegal cast, fix to set arg_simple at compiling block,

- * compile.c, vm.c : fix NODE_NEXT, NODE_BREAK logic

- * yarvtest/test_flow.rb : add a test for above

- * yarvcore.c, yarvcore.h, compile.c, eval.c : remove

- yarv_iseq_t#root_iseq and add yarv_iseq_t#local_iseq and fix

- to use this member field

- * eval_method.h : fix indent

- * gc.c : fix indent

- * insns.def, compile.c : remove "zsuper" instruction (use "super"

- instead). This is because NODE_ZSUPER represent with only "super"

- * yarvcore.c : add proc_arity

-2005-12-05(Mon) 03:58:30 +0900 Koichi Sasada <ko1@atdot.net>

- * array.c, blockinlining.c : support block inlining for Array#each

- * disasm.c : fix catch table format

- * insns.def : fix stack consistency error message

- * vm.c : fix to skip pushing value at "next"

- * yarvcore.h : move definision of

- "struct iseq_compile_data_ensure_node_stack" to compile.c

- * compile.c : fix ensure catch table creation

- * yarvtest/test_flow.rb : add tests for above

-2005-12-03(Sat) 22:27:08 +0900 Koichi Sasada <ko1@atdot.net>

- * blockinlining.c, compile.c, yarvcore.c, yarvcore.h,

- numeric.c, range.c : collect block inlining logic to blockinlining.c

-2005-12-03(Sat) 20:24:07 +0900 Koichi Sasada <ko1@atdot.net>

- * blockinlining.c, common.mk : add blockinlining.c

- * yarvcore.c, yarvcore.h, blockinlining.c, compile.c, compile.h,

- gc.c, node.h, numeric.c, range.c :

- support block inlining for Integer#times, Range#each

- * compile.c : fix to set block redo/next point at last,

- and fix NODE_OP_ASGN1

- * compile.c, vm.c : add specialized instruction "opt_le"

- * disasm.c : fix to show block, and to show catch type as string

- and change node_name logic

- * eval_thread.c : fix function type declaration

- * insns.def : add instruction "putundef", "opt_checkenv"

- to support block inlining and add stack check routine

- * lib/cgi.rb : add global variable $CGI_DONTINPUT

- * opt_operand.def : add some operand unification rules

- * rb/insns2vm.rb : fix operand unification logic for BLOCKISEQ

- * vm.c : fix exception handling routine (collect stack operations)

- * vm_macro.def : fix macro_eval_invoke_bmethod

- * yarvsubst.c : removed

- * yarvtest/test_syn.rb : rename to yarvtest/test_syntax.rb

- * yarvtest/yarvtest.rb : remove tempfile explicitly

-2005-11-30(Wed) 01:13:57 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add vm_opts.h rule

- * vm.c, insns.def : fix proc creation under class and block

-2005-11-29(Tue) 16:39:07 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, eval_proc.c, vm.c, vm_macro.def :

- support define_method and invoke NODE_BMETHOD method

-2005-11-29(Tue) 13:18:06 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : add iseq_add_mark_object, iseq_add_mark_object_compile_time

- and use it to mark objects on iseq

- * compile.h, compile.c : remove cast on NEW_CHILD_ISEQVAL, NEW_ISEQVAL

- * compile.c, disasm.c, insns.def, vm_macro.def, rb/insns2vm.rb :

- add BLOCKISEQ parameter type

- * gc.c : fix garbage_collect to return true if only allocate memory

- * vm.c : fix insertion order of proc/env

- * vm_evalbody.h : add typedef yarv_iseq_t *BLOCKISEQ

- * yarvcore.c, yarvcore.c : add idTimes

- * yarvcore.c : fix proc_mark, env_mark around iseq mark

-2005-11-28(Mon) 09:02:57 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def, vm_evalbody.h : support super

- with splat argument and block (and zsuper with block)

- * yarvtest/test_class.rb : add tests for above

- * compile.c, yarvcore.h, yarvcore.c, insns.def, time.c, string.c :

- * eval_method.h : fix indent

- * eval_thread.c : apply cast to vanish a warning

- * lib/tempfile.rb, lib/tmpdir.rb : added

- * vm.c : eval_method_missing added

- * vm_macro.def : refactoring

-2005-11-21(Mon) 21:21:33 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, compile.h, yarvcore.c : remove "iseqobj"

- variables and rename to "iseq"

-2005-11-21(Mon) 07:31:50 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix block parameter error

- * lib/optparse* : added

- * benchmark/bm_so_sieve.rb : fix parameter

-2005-11-21(Mon) 03:47:28 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : optimize condition in literal

- * thread_win32.h : fix win32 thread function prototype

-2005-11-20(Sun) 17:58:24 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix NODE_AND/OR bug

- * eval.c : support rb_frame_this_func()

-2005-11-20(Sun) 12:32:31 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.c, yarvcore.h : support NODE_OPT_N

- * compile.h : add macro ADD_CALL

- * debug.c : add debug_v() and change to use only printf

- * sample/test.rb :

- * vm.c : fix make_proc_from_block

-2005-11-19(Sat) 14:55:17 +0900 Koichi Sasada <ko1@atdot.net>

- * import ruby 1.9.0 (2005-11-18)

-2005-11-19(Sat) 06:08:37 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/test : added

-2005-11-19(Sat) 05:48:50 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : useless jump elimination (if/unless destination)

- * eval.c : rb_iter_break support,

- fix rb_iterate (clear errinfo if break)

- * eval_proc.c : support rb_node_arity (YARV_METHOD_NODE)

- * insns.def : change variable name

- * vm.c : fix th_invoke_yield and add th_iter_break()

- * vm_dump.c : fix yarv_bug()

- * yarvcore.c : fix proc_mark to check IFUNC node and add

- global ruby method SDR() for debug

- * yarvtest/test_syn.rb : add a test for all condition combination

-2005-11-15(Tue) 05:52:58 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/forwardable.rb : added

- * common.mk : remove "vm.o : CFLAGS += -fno-crossjumping" rule

- * compile.c, yarvcore.h, insns.def : add FCALL/VCALL flag

- * compile.c, insns.def : add onceinlinecache instruction

- * eval.c : support $!, $@, raise (== raise $!)

- * opt_operand.def : add some unification rule (send flags)

- * vm.c : fix return process

- * vm_macro.def : fix option prameters

- * yarvtest/test_method.rb : add tests for above

-2005-11-15(Tue) 00:42:49 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : support rb_frame_pop() and rb_frame_callee(),

- add rb_sourcefile(), rb_souceline(),

- * compile.c : support postposition while/until,

- fix block parameter index

- * yarvtest/test_syn.rb : add tests for above

- * yarvcore.c : fix env_mark

- * vm.h, yarvcore.h : move vm.h#cmethod_info to

- yarvcore.h#yarv_cmethod_info

- * vm.c : add th_get_sourceline()

- * eval_intern.h : fix PASS_PASSED_BLOCK()

- * eval_load.c : fix re-enter require (temporalily)

- * insns.def : permit re-open class when superclass is same

-2005-11-11(Fri) 01:20:15 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : add "allload" rule

- * compile.c, yarvcore.h, insns.def, vm_macro.def, disasm.c :

- change arg_rest, arg_block offset (1)

- * insns.def : add postexe instruction

- * insns.def, vm.c : support rest block parameter

- * yarvtest/test_block.rb : add tests for above

- * rb/allload.rb : get path from ARGV

- * vm_opts.h.base : set default off

-2005-11-01(Tue) 08:28:19 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/other-lang/eval.rb : fix path

- * lib/English.rb, lib/cgi.rb, lib/complex.rb, lib/delegate.rb :

-2005-11-01(Tue) 08:18:33 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : push and pop values after checkincludearray for

-2005-10-31(Mon) 15:37:09 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_app_mandelbrot.rb : added

- * benchmark/bm_app_factorial.rb : fixed parameter

- * benchmark/bm_so_count_words.rb, benchmark/run_rite.rb : use

- * common.mk : add "ext" rule, add some dependencies and add option

- to bench-each rule (renamed from bench-item)

- * compile.c : fix get_root_iseq_object (check iseq type),

- support splat case/when. support //o (regexp)

- * eval.c : support *_eval, fix rb_obj_call_init to pass block

- * eval_jump.h : support throw/catch

- * eval_load.c : save klass_nest_stack when require

- * eval_method.h : fix ruby_cbase()

- * insnhelper.h : GET_EV_KLASS checks toplevel or not

- * insns.def, yarvcore.c : fix singleton method definition and fix

- super class's method

- * lib/shellwords.rb : use String() instead of String.new()

- * vm.c : check class iseq or not when making Proc and

- add eval_search_super_klass function

- * vm.h : CMETHOD_INFO_P to yarvcore.h

- * vm_macro.def : splat if object type is T_ARRAY

- * vm_opts.h, vm_opts.h.base : rename to vm_opts.h.base

- insns2vm.rb will copy it to build directory

- * yarvcore.c : add Proc#[]

- * yarvcore.h : change INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE

- * yarvtest/test_* : invalidate splat non array code (like: "*1")

- * yarvtest/yarvtest.rb : use tempfile instead of popen

-2005-10-28(Fri) 09:11:53 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvtest/test_method.rb : fix test

-2005-10-28(Fri) 08:43:29 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run_rite.rb : add -I options to run benchmark

- * common.mk : pass options to some rules with RUNOPT

- and add -I options

- * compile.c : fix massign with constant

- * yarvtest/test_massign.rb : add tests for above

- * eval_load.c : fix load_wait()

- * eval_method.h : support ruby_cbase()

- * lib/*.rb : add or modify libraries to run on yarv

- * parse.y : change to ANSI C style

- * vm.c : fix making proc process under cfunc/ifunc environment

- * vm_macro.def : fix block pass

- * yarvtest/test_method.rb : add tests for above

- * yarvcore.c : add yarv_obj_is_proc()

- * eval.c : fix rb_obj_is_proc to use yarv_obj_is_proc()

-2005-10-27(Thu) 11:50:15 +0900 Koichi Sasada <ko1@atdot.net>

- * some files : import from ruby 1.9.0 (2005-10-12)

-2005-10-16(Sun) 14:50:02 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c, yarvcore.h, yarvcore.c : add insns "bitblt" and "answer"

-2005-10-11(Tue) 17:01:13 +0900 Koichi Sasada <ko1@atdot.net>

- * yarv_version.h, Changes : 0.3.2

-2005-10-11(Tue) 13:35:25 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : add YARV_CHECK_INTS()

- * thread.c, thread_pthread.h, thread_win32.h : kick timer thread

- when another thread kicked

- * vm.c : remove debug print

- * vm_opts.h : add OPT_CALL_THREADED_CODE

- * yarvtest/yarvtest.rb : remove "\r" from answer

-2005-10-07(Fri) 09:36:36 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : add member variable "interrupt_flag" to yarv_thread_t

-2005-10-05(Wed) 21:20:13 +0900 Koichi Sasada <ko1@atdot.net>

- * eva.c, eval_thread.c, ruby.h, eval_error.h, eval_jump.h,

- eval_load.c, thread.c, error.c, compile.h : remove ruby_errinfo

- * thread_win32.h, thread_pthread.h : set stack size to 4KB

- * vm.c : fix making env routine

- * vm_dump.c, vm.h : support frame type "EVAL" and fix magic number

- * yarvcore.c : fix some mark/free routine

-2005-10-05(Wed) 09:08:11 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, eval_intern.h, vm.c, eval_jump.h, yarvcore.h :

- re-define PUSH/POP/EXEC/JUMP_TAG to use thread local tag

- * inits.c, yarvcore.c : fix boostrap

-2005-10-03(Mon) 22:28:24 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix NODE_COLON2 bugs

- * compile.h : fix debug routine

- * disasm.c : add space between insn and operand

- * insns.def : add comment of classdef, singletonclassdef

- * vm.c, yarv.h : fix invoke_light routine

- * yarvcore.c : fix to mark each threads

-2005-10-02(Sun) 05:55:34 +0900 Koichi Sasada <ko1@atdot.net>

- * thread_pthread.h : add "system_working" global variable

-2005-10-02(Sun) 01:23:44 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c : add raw gets (for test), and fix indent

-2005-10-01(Sat) 23:06:21 +0900 Koichi Sasada <ko1@atdot.net>

- * thread_win32.h, common.mk : add thread_win32.h

- * thread.c : support _WIN32 thread

- * thread.c, thread_pthread.h : fix some interface

- * eval_thread.c : remove debug print

- * gc.c : fix stack region

- * win32/Makefile.sub : add -MD flag to LDFLAGS

- * yarvcore.c : fix mark and sweep debug print

- * yarvcore.h : fix VM#living_threads data type to st_table

-2005-10-01(Sat) 00:25:28 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c, yarvcore.h : rename GIL (Global Interpreter Lock) to

- GVL (Global VM Lock)

- * thread_pthread.h : fix pthread mutex initialize

-2005-09-30(Fri) 20:11:19 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c : support join with timeout

- * yarvcore.h : use GET_VM()

-2005-09-30(Fri) 14:59:29 +0900 Koichi Sasada <ko1@atdot.net>

- * thread.c, common.mk : add thread.c

- * thread.c, gc.c, eval_thread.c, yarvcore.c, yarvcore.h :

- support native thread (on pthread)

- * insns.def : add YARV_CHECK_INTS() check

- * yarv.h : add GET_VM() macro

-2005-09-29(Thu) 22:43:08 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_intern.h, eval_thread.c : move thread_status to eval_intern.h

- * yarvcore.c : fix thread/vm value

- * yarvcore.h : add some parameter to yarv_thread_t

-2005-09-29(Thu) 01:52:33 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.h : add line number on last end instruction

- * vm.c : fix line no detection

-2005-09-28(Wed) 00:02:10 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk, eval_load.c, eval.c, eval_intern.h : add eval_load.c

- * disasm.c : fix around block local variables

- * eval_proc.c : fix typo

-2005-09-27(Tue) 16:45:20 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : remove debug print

-2005-09-27(Tue) 16:41:47 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : support Kernel.local_variables

- * parse.y, yarvcore.c : move some functions

- (rb_(backref|lastline)_(get|set)) from parse.y to yarvcore.c

- * yarvcore.h : fix typo of YARV_PREVIOUS_CONTROL_FRAME

-2005-09-26(Mon) 18:51:29 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c, compile.c, parse.y, vm.c, yarvcore.h :

- eval() works with binding (Env)

- * vm.c : add th_set_eval_stack

- * yarvtest/test_syn.rb : remove an assert "defined?(local_var)"

-2005-09-25(Sun) 19:30:59 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_vm2_send.rb : added

- * common.mk : add rule "bench-item"

- * eval_intern.h : add PASS_PASSED_BLOCK()

- * eval_proc.c : support some functions

- * rb/mklog.rb : added

- * vm.c : fix prototype style and coding style

- * yarv.h : add some prototypes of functions

- * yarvcore.c, yarvcore.h, eval.c : yarv_thread_t#ifuncnode -> passed_block,

- and add yarv_proc_t#safe_level

-2005-09-25(Sun) 11:01:17 +0900 Koichi Sasada <ko1@atdot.net>

- * some files : import from ruby 1.9.0 (2005-09-25)

- * eval*, vm.c, vm_macro.def : remove frame, scope, ...

- * yarvcore.c : remove yarv_block_given_p()

- * yarvcore.h, insnhelper.h : move some macro from insnhelper.h to yarvcore.h

- to use these in eval.c

-2005-09-24(Sat) 15:51:42 +0900 Koichi Sasada <ko1@atdot.net>

- * eval* : remove dependency to ruby_dyna_vars and ruby_class

-2005-09-23(Fri) 20:39:14 +0900 Koichi Sasada <ko1@atdot.net>

- * eval_*.[ch] : split eval.c to some files

- * *.[ch] : import ruby 1.9.0 (2004-09-23)

- * parse.y : remove dependency to ruby_dyna_vars and ruby_scope

-2005-09-15(Thu) 16:51:06 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.h : fix "for" scope

- * yarvtest/test_block.rb : add tests for above

-2005-09-14(Wed) 06:11:43 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, vm_evalbody.h, vm.h, vm_dump.c,

- compile.c, yarvcore.c : use #ifdef insted of #if for recognize

- * vm_opts.h : fix default options

-2005-09-10(Sat) 14:10:08 +0900 Koichi Sasada <ko1@atdot.net>

- * vm_opts.h : added

- * yarvcore.h, rb/insns2vm.h : use vm_opts.h

-2005-09-10(Sat) 04:53:22 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, insns.def, compile.c : add DEFINED_YIELD

- * yarvtest/test_yield.rb : add test_1_ary_and_1_params

- * insns.def : fix splat and svalue

- * vm.c : fix to perform with proc with ifunc (incomplete)

- * sample/test.rb : added (comment out unsupported features)

- * common.mk : add rule "runtest"

-2005-09-09(Fri) 19:32:11 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c : add splatarray

- * yarvtest/test_massign.rb : add tests for above

-2005-08-31(Wed) 22:55:15 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c (yarvcore_eval_parsed): fix to return value

- * yarv_version.h, Changes : 0.3.1

-2005-08-20(Sat) 10:19:27 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/ir.rb : add some check

- * import today's ruby HEAD

-2005-08-18(Thu) 23:29:52 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : fix object file extension

- * rb/ir.rb : added (import ruby script)

- * rb/diff.rb : removed

- * import today's ruby HEAD

-2005-08-18(Thu) 12:59:38 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk : rule test -> test2, test1 -> test

- * compile.c : fix when clause bug and splat arugment

-2005-08-17(Wed) 05:22:31 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix block local parameter setting routine and support

- massign in block parameter initialze

- * yarvtest/test_yield.rb : add tests for above

- * insns.def, compile.c : support array concat (ex: "[x, *y]")

- * yarvtest/test_bin.rb : add tests for above

-2005-08-16(Tue) 19:51:19 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support nested massign

- * yarvtest/test_massign.rb : add tests for above

-2005-08-16(Tue) 10:25:29 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : support rb_yield_0 with 0 args

-2005-08-16(Tue) 09:09:21 +0900 Koichi Sasada <ko1@atdot.net>

- * lib/fileutils.rb : imported

- * insns.def : fix yield argument (same as last commit)

- * yarvtest/test_yield.rb : add tests for above

-2005-08-16(Tue) 08:29:47 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : fix to support rb_yield_0 with multiple values

- * common.mk : add parse, run1p ruelse

- * compile.c : support yield with ARGSCAT/SPLAT

- * vm.c, insns.def : fix yield arguments to do compatible behaviour

- * yarvtest/test_yield.rb : added for above

-2005-08-16(Tue) 06:00:17 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix to set klass_nest_stack on singleton

- * yarvtest/test_method.rb : add a test for above

-2005-08-16(Tue) 05:34:48 +0900 Koichi Sasada <ko1@atdot.net>

- * test1.rb : added. gdb and run1 rule run this script

- * compile.c : fix error handled variable access

- * yarvtest/test_exception.rb : add tests for above

-2005-08-16(Tue) 04:26:08 +0900 Koichi Sasada <ko1@atdot.net>

- * base ruby : ruby 1.9.0 (2005-08-15)

-2005-08-16(Tue) 03:54:17 +0900 Koichi Sasada <ko1@atdot.net>

- * common.mk, Makefile.in : move some rules to common.mk

- * rb/diff.rb : added

- * yarvtest/yarvtest.rb : fix to compare output last value

-2005-08-15(Mon) 18:27:58 +0900 Koichi Sasada <ko1@atdot.net>

-2005-08-15(Mon) 17:56:09 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : fix to add prototype

- * all files : propset svn:eol-style native

-2005-08-15(Mon) 10:48:53 +0900 Koichi Sasada <ko1@atdot.net>

- * eval.c : support rb_load

-2005-08-15(Mon) 09:42:01 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : define SDR()

- * vm_dump.c : stack_dump_raw() -> vm_stack_dump_raw()

- * yarvtest/yarvtest.rb : add rite test scheme

- * benchmark/run_rite.rb : added

- * yarvcore.c, inits.c : add Init_vm()

- * yarv.h : add some prototype declarations, GET_THREAD()

- * eval.c : remove unused functions

- * eval.c : support Kernel.eval, some schemes (same as evalc.patch)

-2005-08-15(Mon) 00:53:28 +0900 Koichi Sasada <ko1@atdot.net>

- * yarv_version.h : move configurations to yarvcore.h

- * yarvcore.c : remove VALUE yarv_get_current_running_thread() and

- add yarv_thread_t *yarv_get_current_running_thread(), ...

- * yarvcore.h : yarv_thread_t#vm -> vm_value

- * compile.c : fix "break from nested classes"

- * yarvext/extconf.rb : use have_func instead of defined?(YARV_PACHED)

- * depend : fix pass

- * eval.c : change to kick VM

- * version.c : fix to show yarv version

- * common.mk : fix dependent

- * inits.c : fix to kick Init_yarvcore

-2005-08-14(Sun) 02:05:15 +0900 Koichi Sasada <ko1@atdot.net>

- * README : add description

- * yarvext/depend : move to topdir/depend

-2005-08-14(Sun) 01:50:43 +0900 Koichi Sasada <ko1@atdot.net>

- * merge yarv to ruby (prepare)

- * make yarvext/ to build as extension

-2005-08-13(Sat) 09:36:26 +0900 Koichi Sasada <ko1@atdot.net>

- * evalc.patch, insns.def, compile.c : fix to support current

-2005-08-08(Mon) 19:13:02 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h, Changes : 0.2.2

-2005-08-08(Mon) 17:17:50 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.h, vm.c, insns.def, yarvcore.h, yarvcore.c :

- remove yarv_iseq_t#iseq_dt and add yarv_iseq_t#encoded.

- use yarv_iseq_t#encoded anytime

- * vm_evalbody.h, vm.h, extconf.rb, version.h :

- support call threaded code (incomplete)

-2005-08-01(Mon) 05:26:12 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : support yield with multiple values

- * compile.c : fix dynavars

- * yarvcore.h : fix to mark defined method

-2005-07-31(Sun) 23:27:24 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, vm.c, insns.def : fix search object path

- * compile.c : fix "for" statement

- * vm_macro.def : fix rest, opt arguments

-2005-07-31(Sun) 14:52:06 +0900 Koichi Sasada <ko1@atdot.net>

- * vm_macro.def : fix block parameter

- * compile.c : fix to unuse compile_data->in_ensure

- * insns.def : add orphan check when return

-2005-07-31(Sun) 03:25:05 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c, compile.c, yarvcore.h, insns.def :

- support jump from rescue/ensure/class/module

- * test/test_flow.rb : add tests for above fix

-2005-07-30(Sat) 04:44:33 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : struct iseq_compile_data_ensure_node_stack is added

- * compile.c : insert ensure clause before break/next/redo

- * vm.c : fix return/break handling

- * yarv.h, vm.c : fix lightweight yield

- * vm.c, insns.def, vm_macro.def : change arguments of th_set_env (add sp)

- * test/test_flow.rb : added

- * test/yarvtest.rb : add ae_flow

- * compile.c, vm_macro.def : add tail-call/tail-recursion optimization

-2005-07-29(Fri) 20:14:11 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : make_name_for_block and make_name_with_str

- * insns.def : fix if unmatched size arg size to yield

- * test/test_block.rb : add test for above fix

- * vm.c : add th_backtrace_each and fix backtrace notation

- * yarvcore.c : set top level iseq name to "<main>"

-2005-07-29(Fri) 13:20:19 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : fix yarv_iseq_t to pass VC (cl)

- * vm_dump.c : ditto

- * compile.h : ditto

- * insnhelper.h : ditto

- * vm_evalbody.h : include 'math.h'

- * insns.def, vm.c : raise error when yield without block

- * vm.c : implement thread_backtrace

- * vm.c, yarvsubst.c, yarv.h : implement thread_yield_light_prepare and

- thread_yield_light_invoke

- * yarvcore.c : Integer#times uses yarv specific version

-2005-07-28(Thu) 21:35:09 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : add another mark function for thread/stack

- * vm_evalbody.h : fix register allocation for x86_64

- * vm.h : use asm for tc on x86_64

-2005-07-28(Thu) 20:17:09 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : add mark/free message to debug gc

- * insnhelper.h, insns.def, vm_macro.def : remove and

- add new RESTORE_REGS

- * vm_evalbody.h : fix register allocation

-2005-07-28(Thu) 02:00:42 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c, etc : change VM stack structure. re-write all

- vm functions to do it

- * vm_macro.def : added

-2005-07-08(Fri) 01:36:49 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : don't use fmod on AMD64

-2005-07-08(Fri) 00:14:22 +0900 Koichi Sasada <ko1@atdot.net>

-2005-07-07(Thu) 23:54:37 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : 0.3.0

-2005-07-07(Thu) 23:52:03 +0900 Koichi Sasada <ko1@atdot.net>

- * 0.2.1 : released

-2005-07-07(Thu) 23:50:22 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : 0.2.1

-2005-07-07(Thu) 23:47:55 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb, extconf.rb : add --[enable|disable]-opt-unify-all-combination

- and --disable-opts

- * vm.h : DISPATCH_ARCH_DEPEND_WAY is only enabled on GCC 3.x

-2005-07-06(Wed) 13:20:27 +0900 Koichi Sasada <ko1@atdot.net>

- * depend, rb/eval.rb : add ITEMS option to benchmark rule

- * benchmark/* : changed

- * benchmark/other-lang/* : added

-2005-07-04(Mon) 04:02:15 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h. yarvcore.c : add idDIV, idMOD, idEq, idLength

- * compile.c, insns.def : add specialized insn for above method id

- * test/test_bin.rb : add tests for above

-2005-07-03(Sun) 20:31:09 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, yarvcore.h : remove cYarvThrowObject (unused)

- * yarvcore.c, yarvcore.h, insns.def :

- thread_object#stack_mark_poinetr

- * depend, rb/eval.rb : BOPT, TOPT -> OPT

-2005-07-03(Sun) 13:53:47 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, compile.h : INSN_OBJECT, LABEL_OBJECT -> INSN, LABEL,

- ISEQ_LINK_ELEMENT, ISEQ_LINK_ANCHOR -> LINK_ELEMENT, LINK_ANCHOR,

- * tmpl/optinsn.inc.tmpl : ditto

- * yarvcore.c, yarvcore.h : remove label_object, insn_object

- prepare_iseq_build, cleanup_iseq_build are added

- * insns.def : remove unused variable from send

-2005-07-02(Sat) 04:19:22 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : add GC protect for opt_aset

-2005-07-02(Sat) 03:49:17 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : add option -fno-reorder-blocks to vm.asm rule

- * insns.def : fix opt_aset bugs

- * test/test_bin.rb : add tests for aset, aref

-2005-07-02(Sat) 03:05:12 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb : fix output

- * vm_evalbody.h : add register for x86_64

- * rb/asm_parse.rb : fix to shor size and length

-2005-07-02(Sat) 02:56:31 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : move specialized instruction point (new_insn_send)

- * insns.def : add opt_aref, opt_aset

-2005-07-01(Fri) 11:04:11 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.h : fix to pass VALUE type to new_insn_body

- * insnhelper.h : add cast

- * compile.c : fix getdynamic argument (0 == Qfalse -> I2F(0))

-2005-06-30(Thu) 23:34:10 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/eval.rb : add and fix some rules

- * rb/insns2vm.rb : generate all

- * benchmark/run.rb : add -r (ruby only) option

-2005-06-30(Thu) 23:25:23 +0900 Koichi Sasada <ko1@atdot.net>

- * tmpl/vmtc.inc.tmpl : add const prefix

- * /rb/asm_parse.rb, extconf.rb : added and make assembler analised output

- * opt_operand.def : add send operands unification

- * insnhelper.h : add HEAP_CLASS_OF(obj)

- * insns.def : fix opt_plus, opt_ltlt

- * vm_evalbody.h : move _tag

- * benchmark/run.rb : fix file select

-2005-06-30(Thu) 06:07:04 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : add collect-usage-analysis option

- * opt_operand.def, opt_insn_unif.def : add some rules

-2005-06-29(Wed) 23:28:44 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, extconf.rb, vm.h, compile.c :

- DISPATCH_DIRECT_THREADED_CODE, DISPATCH_THREADED_CODE

- -> OPT_DIRECT_THREADED_CODE, OPT_INDIRECT_THREADED_CODE.

- if at least one of then is defined, OPT_THREADED_CODE is defined

- * benchmark/* : fix name and parameters

- * rb/eval.rb : added for YARV evaluation

-2005-06-29(Wed) 16:16:52 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb : fix output format

- * call_cfunc.inc -> call_cfunc.h

- * vm.h : add sign by asm statement

-2005-06-28(Tue) 22:28:40 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : fix method search

-2005-06-28(Tue) 22:26:34 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : fix options

-2005-06-28(Tue) 21:50:58 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb : fix output format

-2005-06-28(Tue) 21:34:54 +0900 Koichi Sasada <ko1@atdot.net>

- * depend : add option TOPT to test rules

- * benchmark/run.rb : fix output format

-2005-06-28(Tue) 21:15:54 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix opt_case_dispatch instruction

- * benchmark/run.rb : output all usertimes when exit benchmark

-2005-06-28(Tue) 20:35:55 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb, compile.c, tmpl/optinsn.inc.tmpl, vm.c :

- change extconf options

-2005-06-28(Tue) 13:20:59 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb : add -y, --yarv-only option

- * depend : add BOPT to tbench rule

-2005-06-27(Mon) 23:31:12 +0900 Koichi Sasada <ko1@atdot.net>

- * depend : add gdb rule

- * vm.h : use inline assembler for x86 (to support gcc 3.4.x)

-2005-06-27(Mon) 20:04:10 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, compile.c, disasm.c : remove unused variables

- * vm.h, insnhelper.h, debug.h : fix to reduce warning

- * vm.c, vm_dump.c : move VM state dump (debug) functions to vm_dump.c

- * depend : adde reconf rule

- * vm_evalbody.inc : rename to vm_evalbody.h

-2005-06-27(Mon) 16:50:31 +0900 Koichi Sasada <ko1@atdot.net>

- * insns2vm.rb : fix generating unif insn

- * compile.c : add useless pop/swap insn elimination with stack caching

- * depend : remove compiled.o dependency

-2005-06-26(Sun) 14:06:22 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb : use tmpfile instead of popen

- * rb/insns2vm.rb : fix generating insn unification logic

- * opt_insn_unif.def : add some unification rules

- * compile.c : add verify_list function and fix unification logic

-2005-06-22(Wed) 12:58:26 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c, insns.def, compile.c : add mult optimization

- * test/test_bin.rb : add test_fact

-2005-06-21(Tue) 22:34:07 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, compile.[ch], tmpl/optinsn.inc.tmpl, rb/insns2vm.rb :

- change data structure (don't use Ruby's array to represent a

- instruction sequence)

- * disasm.c : add separator

-2005-06-14(Tue) 07:48:58 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support "for" statement

- * test/test_block.rb : add test for above

- * yarvcore.[ch] : add global id idEach

-2005-06-08(Wed) 22:30:44 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : add if/unless(L1) jump (L2) :L1 => unless/if(L2)

- optimize (condition reversal) and fix typo

-2005-06-07(Tue) 08:29:41 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : fix to remove compiler warning

- * version.h : 0.2.1

-2005-06-07(Tue) 08:16:22 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : iseq_link_element changed to double linked list

- * disasm.c : support dump struct iseq_link_element

- * compile.c : use double linked list instead of array

- for intermediate representation

-2005-06-06(Mon) 15:38:44 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c : add link structure to insn and label object

- * compile.h, compile.c : remove some variables in function top scope

- of iseq_compile_each and some optimization (now working)

-2005-06-04(Sat) 16:12:59 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix previous commit

-2005-06-04(Sat) 15:56:21 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix stack caching (after jump state)

-2005-06-04(Sat) 09:12:13 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix some point for previous commit

-2005-06-04(Sat) 07:31:21 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : optimize case/when statement

- (dispatch on constant time)

- * yarvcore.h, disasm.c, rb/insns2vm.rb : fixed for above

- * test/test_syn.rb : add test for above

-2005-06-04(Sat) 03:41:29 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c : add some temporary variable test

- (it'll be vanished)

- * compile.c : NODE_CASE optimize (use topn instead of dup/swap)

-2005-06-03(Fri) 00:54:38 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : apply flow optimization for while/until statement

-2005-03-04(Fri) 19:34:32 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb : fix category (comment)

- * depend : remove space betweeen target name and colon

-2005-03-04(Fri) 15:55:51 +0900 Koichi Sasada <ko1@atdot.net>

- * tmpl/yarvarch.ja : fix typo

-2005-03-04(Fri) 13:30:19 +0900 Koichi Sasada <ko1@atdot.net>

- * depend : add a rule for jitcompile.o

- * vm.h : fix a macro argument

- * version.h : 0.2.0

-2005-03-03(Thu) 08:35:14 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : remove vm_evalbody.inc call_cfunc.inc from clean target

-2005-03-03(Thu) 00:54:15 +0900 Koichi Sasada <ko1@atdot.net>

- * tmpl/insns.inc.tmpl : fixed typo

- * insns.def : store th->pc to current pc

-2005-03-03(Thu) 00:31:47 +0900 Koichi Sasada <ko1@atdot.net>

- * tmpl/yarvarch.ja, doc/yarv.rb : write current architecture of yarv

-2005-03-01(Tue) 13:50:04 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c (yarvcore_eval_parsed) : added

- (separeted from yarvcore_eval)

- * yarvcore.c, compile.c : iseq_translate_direct_threaded_code

- is moved to compile.c

- * depend : add rule for yasmdata.rb

- * rb/yasm.rb : support top-level and method-level assemble

-2005-02-26(Sat) 08:09:57 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb, compile.c, vm.h : change type long to OFFSET

- * tmpl/yasmdata.rb.tmpl : added

- * rb/insns2vm.rb : add yasmdata_rb method

- * rb/yasm.rb : fix some interface (incomplete)

- * compile.c : iseq_setup added

- * yarvcore.c : YARVCore::InstructionSequence::Instruction#make added

-2005-02-24(Thu) 07:45:37 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/yasm.rb : added

-2005-02-24(Thu) 01:13:33 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : remove useless statements

-2005-02-24(Thu) 00:46:44 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb (InsnInfo) : add @is_sc attr and remove

- * compile.c : fix NODE_CASE/NODE_WHEN bug (cond at 'when'

- must not be popped)

- * compile.c : support NODE_OP_ASGN1 to &&= and ||=

- * test/test_bin.rb : add tests for above

-2005-02-23(Wed) 09:17:01 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c, yarvcore.c : thread_svar added and fix svar location

-2005-02-21(Mon) 08:38:02 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h : make type "struct iseq_compile_data"

- * yarvcore.h : iseq_object#insn_info_ary to iseq_object#insn_info_tbl

-2005-02-21(Mon) 05:24:01 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c (compile_string) : remove null check of node

-2005-02-19(Sat) 03:52:45 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : 0.1.1

-2005-02-18(Fri) 20:57:18 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c : add idLTLT, idMethodMissing

- * compile.c : suopport lval (or others) block parameter

- * test/test_block.rb : add tests for above

- * insns.def (send) : support method_missing

- * test/test_method.rb : add tests for above

- * insns.def : opt_ltlt and

-2005-02-18(Fri) 08:54:40 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/runc.rb : added

- * benchmark/contrib/pentomino.rb : added opt_ltlt

- and Float, String plus specialization

-2005-02-18(Fri) 07:49:42 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : remove debug print

- * rb/aotcompile.rb : skip if yarvcore.so is not created

-2005-02-18(Fri) 06:46:13 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix block passing

- and block argument

-2005-02-18(Fri) 05:52:41 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : thread_get_ev_const, thread_get_ev_defined is added

- (separated from insns.def)

- * insnhelper.h : GET_EV_KLASS(klass) is added

- (separated from insns.def)

- * yarvcore.h, insns.def, compile.c : support defined? expression (limited)

- * test/test_syn.rb : tests for above is added

- * compile.c, insns.def : support block passed method dispatch

- * test/test_method.rb : tests for above is added

- * compile.h : CALL_ARGS_SPLAT is removed

-2005-02-16(Wed) 13:32:37 +0900 Koichi Sasada <ko1@atdot.net>

- * disasm.c : fix ID to String method

- * compile.c : NODE_SUPER, NODE_ZSUPER check 'poped'

- and NODE_RETURN check outer type

- and NODE_DREGX_ONCE supported (temporarily)

- * test/test_syn.rb : add a test

- * test/test_jump.rb : add a test

-2005-02-16(Wed) 06:07:41 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.[hc] : use Symbol instead of Fixnum to represent ID

- * rb/insns2vm.rb : add attr_reader :insns, :insn_map

- * vm.h, rb/insns2vm.rb : END_INSN have one arg

- * jitcompile.c : jit compiler framework (experimental)

- * rb/aotcompile.rb : refactoring

- * compiled.c : add constant pool

- * vm_evalbody.inc, call_cfunc.inc, vm.c : separeted from vm.c

- * insns.def : fix return val

- * depend : add rules for compiled.o

-2005-02-14(Mon) 13:09:01 +0900 Koichi Sasada <ko1@atdot.net>

- * insnhelper.h, yarvcore.h: move YARV_METHOD_NODE to yarvcore.h

- * yarvcore.h : add 2 members jit_compiled and iseq_orig

- to struct iseq_object

- * yarvcore.c : add yarv_jitcompile and global function jitcompile

- * insns.def : insn opt_call_native_compiled added

- * jitcompile.c : added

-2005-02-12(Sat) 05:38:51 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def (putstring) : fixed to duplicate string object

- * rb/insns2vm.rb, tmpl/optunifs.inc.tmpl, compile.c : support

- instructions unification (aka super instruction)

- * opt_insn_unif.def : added for above

- * benchmark/bm_unif1.rb : added to measure efficiency of unification

- * depend : fixed for above

- * extconf.rb : add option --(enable|disalbe)-opt-insns-unification

-2005-02-11(Fri) 12:14:39 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, vm.c, insns.def : permit to access svar from

- * test/test_method.rb : add tests for above

-2005-02-09(Wed) 19:31:06 +0900 Koichi Sasada <ko1@atdot.net>

- * ite.rb : added (ruby -rite [script file])

-2005-02-09(Wed) 02:25:43 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.[hc] : add member compile_data (hash) to iseq_object

- * compile.c, yarvcore.h : check label is already set

- * compile.c, extconf.rb : support __goto__ and __label__ statement

-2005-01-25(Tue) 12:49:27 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_block.rb : add break test to test_times

-2005-01-25(Tue) 03:34:04 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : check ruby version if yarv patch is applied or not

- * evalc.patch : fixed for rb_call_super and above check

-2005-01-25(Tue) 03:21:48 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb : refactoring (mainly, make InsnsDef::InsnInfo

- to represent each instruction information)

- * depend, rb/makedocs.rb : fixed for above

- * yarvcore.c (thread_call_super) : added

- * vm.c (thread_call_super) : added

- * vm.h : add struct cmethod_info

- * insns.def, vm.c : use cmethod_info to represent C method info

- * insns.def : use iseq_object#klass_nest_stack

- to search super/zsuper's class

- * prosym.rb : removed

- * ToDo : write todo things on wiki

-2005-01-18(Tue) 23:44:47 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb : check ENV['RUBY'] to use ruby binary

-2005-01-10(Mon) 08:44:40 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : 0.1.0

-2005-01-09(Sun) 22:01:29 +0900 Koichi Sasada <ko1@atdot.net>

- * repository : svn propset svn:eol-style native *.c *.h tmpl/*.tmpl

-2005-01-09(Sun) 21:48:38 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : FREE_UNLESS_NULL, MARK_UNLESS_NULL macros are added

- * yarvcore.c : some insn/label methods are added

- * yarvcore.h : add structure menber "insns_ary" to iseq_object

- * vm.c, insns.def (thread_eval_body) : return values with throw

- * prosym.rb : added

- * insns.def : add YARV_AOT_COMPILED and some procedure

- * depend : add compiled.c

- * compiled.c : added to build compiled Ruby program (C source)

- * rb/aotcompile.rb : AOT compiler

- * aotct.rb, rb/aotctest.rb : test and benchmark AOT compiler

- * rb/allload.rb : added

-2005-01-09(Sun) 08:30:38 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c (yarv_yield_values) : added

- * vm.c (thread_call0) : change interface. substitute rb_call0 in

- * yarvcore.c (yarv_call0) : fix for above

- * yarvcore.c (yarv_call0_cfunc) : removed

- * yarvcore.c : change passing items for yarv_setup

- * evalc.patch : fix for above

- * benchmark/bm_lists.rb : fix (unsupport block passing)

- * benchmark/run.rb : use full path to ruby

- * insns.def (yield): raise error if argc > expected argc

-2005-01-08(Sat) 16:07:48 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : add descrioptions

- * compile.c : fix bugs (getinlinecache operands)

- * yarvcore.c : initial value of yarvGlobalStateVersion

-2005-01-08(Sat) 14:39:04 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, vm.c, evalc.patch : support making backtrace

- (incompatible with current ruby interpreter)

-2005-01-08(Sat) 11:25:46 +0900 Koichi Sasada <ko1@atdot.net>

- * evalc.patch : commit for previous commit change

- * yarvcore.h, compile.c, insns.def : MC to IC (inline cache),

- and changed to using IC by set/getinlinecache

-2005-01-08(Sat) 10:04:33 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : add global variable sym[IC]FUNC

- * yarvcore.c (yarv_iterate, yarv_call0_cfunc) : added

- (each called from rb_iterate, rb_call0 with NODE_CFUNC)

- * vm.c (stack_dump_raw) : fixed to prints more detail

- * vm.c (stack_dump_th, stack_dump_thobj) : added to

- dumps thread_object states (for VALUE, struct pointer)

- * vm.c (thread_dump_regs) : added

- * vm.c (thread_call0, thread_call0_cfunc, thread_invoke_yield,

- thread_invoke_yield_cfunc), insns.def (yield, send) :

- fixed, added to support IFUNC

- * vm.c, yarvcore.c, insns.def : change type purpose

- thread_object#block_ptr (it holds IFUNC block information,

- so this type was changed to 'NODE *')

- * vm.c (stack_dump_each) : fixed for above

- * test/test_block.rb (test_ifunc) : test for above

- * vm.c (get_block_objec, thread_make_env_object) : fixed bugs

- * test/test_bin.rb (test_xstr) : remove `ls` test

-2005-01-06(Thu) 21:35:18 +0900 Koichi Sasada <ko1@atdot.net>

- * yarv : trying to support NODE_IFUNC (rb_iterate)

-2005-01-05(Wed) 06:50:42 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, insns.def, disasm.c, rb/insns2vm.rb, compile.[ch] :

- support inline method cache

- * extconf.rb : add -*-inline-method-cache (default: enable)

- * test/test_method.rb : add a test for above

- * benchmark/bm_poly_method.rb : added

- * yarvcore.c : add option string

-2005-01-04(Tue) 17:15:41 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c : add compile_array and duparray insn

- to optimize only literal array creation

- * benchmark/bm_array.rb : added

-2005-01-04(Tue) 10:02:40 +0900 Koichi Sasada <ko1@atdot.net>

- * README : fix version

-2005-01-04(Tue) 09:57:25 +0900 Koichi Sasada <ko1@atdot.net>

- * ToDo : reflect current status

-2005-01-04(Tue) 09:43:54 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_VALUES, NODE_ARGSCAT, NODE_SPLAT

- * test/test_massign.rb : add tests for above

- * benchmark/bm_swap.rb : added

-2005-01-04(Tue) 06:25:45 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.h : COMPILE_ERROR break contol (instead of return)

- * compile.c : support NODE_MASGN

- * insns.def : change expandarray for massign and add topn insn

- * test/test_massign.rb : added

-2005-01-03(Mon) 21:20:28 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : store block when create proc

- * test/test_proc.rb : add a test for above change

- * yarvcore.c : add global function "once"

-2005-01-02(Sun) 00:40:08 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_super.rb : fix bug (remove infinite loop)

-2005-01-01(Sat) 23:45:49 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_z?super.rb : added

-2005-01-01(Sat) 23:37:38 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bmx_so_object.rb : rename to benchmark/bm_so_object.rb

-2005-01-01(Sat) 23:19:02 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_OP_ASGN2, NODE_OP_ASGN_AND, NODE_OP_ASGN_OR,

- NODE_SUPER, NODE_ZSUPER, NODE_MATCH

- * insns.def : support super, zsuper (currently, super can't

- handle with block)

- * test/test_bin.rb : add test for op_asgin2, op_assgin_and/or

- * test/test_class.rb : add test for super, zsuper

-2005-01-01(Sat) 20:39:29 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_MATCH

- * yarvcore.c : fix yarv_svar bug (fix condition boundary)

- * insnhelper.h : save cfp/lfp/dfp vars to thread_object (th)

-2005-01-01(Sat) 20:03:10 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : 0.0.1

- * yarvcore.h : add idIntern declaration

- * insns.def : add getspecial, setspecial.

- implement getclassvariable, setclassvariable.

- store lfp before reg match (opt_regexpmatch1)

- * compile.c : support ditto, flipflop

- * yarvcore.c : support svar

- * test/test_syn.rb : add test for flipflop

- * test/test_bin.rb : add test for dsym, cvar, backref

-2005-01-01(Sat) 09:09:32 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : add getspecial insn

- * compile.c : support NODE_NTH_REF, NODE_BACK_REF

-2005-01-01(Sat) 06:53:38 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c : support alias, undef

- * test/test_method.rb : test for above

- * rb/insns2vm.rb : fix enbug

-2005-01-01(Sat) 06:00:32 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_jump.rb : add test (next with value)

- * yarvcore.h, yarvcore.c, compile.c, compile.h :

- raise compile error exception instead of rb_bug

- * yarvcore.c, evalc.patch : support "require"

- * test.rb : restore $" after evaluation with ruby

- * rb/insns2vm.rb : remove unnecesary each

-2004-12-17(Fri) 18:56:38 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix newhash

-2004-12-15(Wed) 13:29:27 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : add version string

- * compile.c : fix rescure clause bug

-2004-12-14(Tue) 22:46:30 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : add reput insn

- * vm.h : show stack cache registers when stack dump

- * rb/insns2vm.rb, compile.c : fix stack caching bugs

-2004-12-14(Tue) 00:51:58 +0900 Koichi Sasada <ko1@atdot.net>

- * insns2vm.rb, compile.c, tmpl/opt_sc.inc.tmpl : fix bugs

- * rb/mixc-asm.rb : added

-2004-12-14(Tue) 00:17:02 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c, compile.c : fix SC bugs

- (SC state management)

- * extconf.rb : add option -[enable|disable]-opt-stack-caching

- * insns2vm.rb : accept CPPFLAGS options

- * vm.c : support restrore register for pc

-2004-12-13(Mon) 16:53:42 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb : add macro INSN_IS_SC()

-2004-12-11(Sat) 10:51:44 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, compile.c : support singleton method definition

- * test/test_method.rb : add test for above

-2004-12-11(Sat) 03:17:54 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/*.rb : modify

- * extconf.rb : add $cleanfiles

-2004-12-08(Wed) 13:01:38 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : change to disable stack caching

-2004-12-07(Tue) 19:37:13 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.rb : add default after

- * insns.def : fix to work on stack caching

-2004-12-07(Tue) 15:07:13 +0900 Koichi Sasada <ko1@atdot.net>

- * depend : add some dependency to *.inc files

- * vm.c : add "register" and asm("regname") descriptor

- * rb/insns2vm.rb, compile.c : add stack caching support

- * tmpl/opt_sc.inc.tmpl : added to above change

- * rb/makedocs.rb : fix file path

- * extconf.rb : fix option selection

-2004-12-06(Mon) 11:20:11 +0900 Koichi Sasada <ko1@atdot.net>

- * extconf.rb : add vm.asm target if compiler is gcc

-2004-12-06(Mon) 09:56:24 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.h : rename method_frame's member block to block_ptr

- * extconf.rb : add "-fno-crossjumping" option when compiler

- * opt_operand.def : add unification insn send

- * rb/insns2vm.rb : define symbol instead of declare const

- variable (for more optmize on VC)

- * insns.def : move enter point in send

-2004-12-06(Mon) 04:53:51 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, opt_operand.def, rb/insns2vm.rb, depend :

- support operand unification

-2004-12-05(Sun) 03:16:10 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c, insns.def : speed up throw/catch scheme

-2004-12-05(Sun) 01:47:05 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : fix catch handler bugs

- * test/test_jump.rb : test_complex_jump added

-2004-12-03(Fri) 20:39:05 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/contrib/mcq.rb : added

- (from URABE Syouhei)

-2004-12-03(Fri) 20:35:28 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : support break in rb_yield block

-2004-12-03(Fri) 14:26:35 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support block local variable in current

- ruby specification (patche from Kent Sibilev)

- * insns.def : support attr_* (patch from Kent Sibilev)

-2004-12-02(Thu) 21:04:27 +0900 Koichi Sasada <ko1@atdot.net>

- * opt_operand.def : added

-2004-12-02(Thu) 13:20:41 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c, vm.h, vm.c, insns.def, insnhelper.h, yarvutil.rb :

- add usage analisys framework

- * disasm.c : insn_operand_intern to separate function

- * benchmark/run.rb : run each benchmark on another process

-2004-12-01(Wed) 10:26:49 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : yield check block is given

- * benchmark/bm_lists.rb : rename to bmx_lists.rb

- (because it's not work ... bug?)

- * insns.def : opt_* support other type calc

-2004-11-30(Tue) 16:14:54 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_so_array.rb : added

- * benchmark/bm_so_matrix.rb : added

-2004-11-30(Tue) 14:11:30 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/getrev.rb : added

- * yarvcore.c : add YARVCore::REV, YARVCore::DATE constant

-2004-11-30(Tue) 13:05:42 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_OP_ASGN1 (incomplete)

- * insns.def : add dupn

-2004-11-30(Tue) 08:52:01 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : 0.0.0.f

-2004-11-30(Tue) 08:43:59 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_class.rb : add test_initialize and test_to_s

- * yarvsubst.c : use rb_funcall instead of yarv_funcall

- * evalc.patch : fix ruby's patch

- * benchmark/bm_so_*.rb : change naming rule. "bm_so_*" from

- * depend : tbench target item is ITEM env val (default: bmx_temp)

- * vm.c : show raw address if environment is in heap at dumping stack trace

- * vm.c : thread_call0 added

- * vm.c : fix thread_yield_light_invoke

- * yarv.h, yarvcore.c : remove yarv_funcall

-2004-11-29(Mon) 11:37:08 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test/test_proc.rb : add test test_nestproc

- * yarvsubst.c : comment out yarv_Array_each

- * insns.def : restore lfp/dfp after call_cfunc

- * vm.c : fix stack dump routine

- * vm.c : impliment thread_funcall (temporarily)

- * yarv.h : add IS_YARV_WORKING(), SET_YARV_START(), SET_YARV_STOP()

- * yarvcore.c : remove check with yarv_in_work

- * evalc.patch : added

-2004-11-27(Sat) 00:19:52 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.c : free -> ruby_xfree

-2004-11-26(Fri) 02:11:11 +0900 Koichi Sasada <ko1@atdot.net>

-2004-11-22(Mon) 11:19:48 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/bm_ackermann.rb, bm_proc.rb, bm_simpleiter.rb,

- bm_so_exception.rb, bm_wc.rb, wc.input added

-2004-11-22(Mon) 02:31:56 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_proc.rb : add some test

- * yarvcore.c, vm.c : support yield in C method (as rb_yield)

- * vm.c (thread_yield_light_(prepare|invoke)) : support lightweight

- * yarvcore.c, yarv.h : support yarv_is_working, yarv_block_given_p,

- yarv_yield, yarv_funcall (only dummy function)

- * vm.c : thread_eval_body changed return value

- * yarvsubst.c : added and add yarv_Integer_times, yarv_Array_each

- * yarvcore.h : block_ptr is added to struct thread_object

- * insns.def : pass block when C method call

- * insnhelper.h : add GET_ISEQOBJ(cfp) macro

-2004-11-21(Sun) 07:25:49 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c : support Proc#call

- * test/test_proc.rb : added

-2004-11-19(Fri) 18:04:10 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def, vm.c : support creating Proc object

-2004-11-15(Mon) 14:19:27 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def (send) : use clear_local_size to specify

- clear local table vars.

- * insns.def : block represent data shares lfp, dfp with frame data

-2004-11-13(Sat) 18:19:41 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, insns.def : add VM_CALL_ARGS_SPLAT_BIT and

- VM_CALL_ARGS_BLOCKARG_BIT

- * compile.c, compile.h : add ADD_SEND, ADD_SEND_R

-2004-11-10(Wed) 08:26:25 +0900 Koichi Sasada <ko1@atdot.net>

- * add "vm_" prefix to (block_object, proc_object, env_object)

-2004-11-03(Wed) 15:52:14 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c, disasm.c, compile.c, insns.def, vm.c :

- fix to move x86_64 (illegal cast, etc)

-2004-11-01(Mon) 04:45:54 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, compile.c, debug.c, version.h :

- redesgin gc debug scheme (GC_CHECK())

- * yarvcore.c : mark iseqobj->current_block on GC

- * insns.def, compile.c : last "throw" in ensure/rescue block

- use operand throwobj and before this insn, use "getdynamic 0, 1"

- * benchmark/bm_temp.rb : move to benchmark bmx_temp.rb

- * depend : change some targets

-2004-10-25(Mon) 19:57:58 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : push exception iseq to iseqobj->iseq_mark_ary

-2004-10-10(Sun) 16:25:03 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : remove $_, $' area from method local frame

- and provide that's special method local variables pointer(LFP[-1])

- * disasm.c : change environment showing format

- * yarvcore.(h|c) : add YarvProc, YarvEnv

- * yarvcore.h : add arg_block field to iseq_object

- and init -1 as default value

-2004-09-30(Thu) 19:50:48 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : support passing splat argument

- * compile.c, insns.def : support rest argument

- * compile.c, insns.def : support optional argument initializer

- * test/test_method.rb : add tests for above

-2004-09-29(Wed) 10:50:03 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix rescue clause popped

- * benchmark/bm_random.rb : move to benchmark/bmx_random.rb

-2004-09-29(Wed) 01:25:35 +0900 Koichi Sasada <ko1@atdot.net>

- * many many files: change stack frame design

-2004-09-16(Thu) 08:51:37 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.h : support 'return' from method

-2004-09-13(Mon) 21:56:40 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support inline cache constant access

- on NODE_COLON2, NODE_COLON3

- * depend : add 'vtest' rule(verbose test)

-2004-09-13(Mon) 10:58:44 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, yarvcore.h : support redo/next/break in

-2004-09-13(Mon) 08:50:19 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_jump.rb : added(correctly)

- * benchamark/bm_(ensure|rescue|simplereturn).rb added

-2004-09-12(Sun) 23:30:20 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_jump.rb : added

- * insns.def, compile.c : add 'putnil' insn

- * compile.c : use '===' when rescue check

- * insns.def : remove 'rescuecheck' insn

- * compile.c : support retry in begin/rescue clause

-2004-09-08(Wed) 12:34:04 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvcore.h, yarvcore.c : add idThrow*

- * insns.def, compile.c, vm.c : support retry, break,

- next, redo, return(imcomplete)

-2004-09-03(Fri) 13:40:08 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : add nop after rescue body

- * insns.def, vm.c : support stack rewind when thrown

-2004-09-01(Wed) 17:31:01 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_exception.rb : added

-2004-09-01(Wed) 13:15:14 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.c, insns.def : implementing exception handling

-2004-09-01(Wed) 00:18:54 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : add 'throw' insn

- * compile.c : support 'rescue' and 'ensure' clause

- * yarvcore.c, yarvcore.h : add 'catch_table' to iseq_struct

-2004-08-30(Mon) 19:06:12 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.h : NEW_ISEQOBJ don't pass self as parent

- * compile.c : use NEW_CHILD_ISEQOBJ explicitly

-2004-08-29(Sun) 21:09:55 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : trying to implement rescue/ensure

- * insns.def : fix yield bug(lfp, dfp link)

-2004-08-28(Sat) 13:52:15 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix dvar bug

- * test/test_block.rb : add test

- * insns.def, insnhelper.h : remove unused source code

-2004-08-28(Sat) 08:51:26 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_DASGN

- * test/test_block.rb : add test

-2004-08-28(Sat) 08:13:04 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : support access to instance variable

- * test/test_class.rb : add test of instance variable

- * benchmark/bm_block.rb : added

-2004-08-28(Sat) 07:48:43 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_block.rb : fix block parameter name

-2004-08-28(Sat) 07:27:52 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c, insns.def : support method call with block

- and yield and add some functions

- * compile.c, insns.def : support dynavars accessor

- * test/test_block.rb : added

- * vm.c : fix block parameter stack dump

-2004-08-27(Fri) 23:56:47 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c(iseq_compile) : remove parameter iseqtype

- (this information can access via self)

-2004-08-27(Fri) 17:13:35 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_bin.rb : add test(absolute path constant)

- * yarvcore.h, compile.c(iseq_compile) : change parameter

- * insns.def(classdef) : fix bug

-2004-08-27(Fri) 04:53:13 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : support setconstant, getconstant, classdef,

- * vm.h : fix debug levels and so on

- * vm.h : foo_WORD -> foo_WC

- * test/test_class.rb : added

-2004-08-25(Wed) 17:51:50 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix getconstant/setconstant/classdef

-2004-08-25(Wed) 14:27:10 +0900 Koichi Sasada <ko1@atdot.net>

- * debug.[ch] : added

- * compile.c, disasm.c : use debug interface

- * compile.c : support some nodes

- * compile.c, rb/insns2vm.rb : remove TS_CPATH

- * insns.def : modify classdef/moduledef/singletonclassdef

-2004-08-18(Wed) 20:16:45 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix case/when statement with empty else clause

- * insns.def : enable compile

- * yarvcore.h : add class search path scheme

- * test/test_syn.rb : add switch/case test case

- * tmpl/yarvarch.ja : update documents

-2004-05-22(Sat) 01:30:44 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvutil.rb : add eval_in_wrap

- * test/test_*.rb : change to use eval_in_wrap

-2004-05-20(Thu) 02:50:32 +0900 Koichi Sasada <ko1@atdot.net>

- * support global variables

- * benchmark/bm_*.rb : add some benchmarks

- * compile.c : support NODE_ATTRASGN

- * compile.c : add debugi(...)

-2004-05-19(Wed) 23:19:38 +0900 Koichi Sasada <ko1@atdot.net>

- * test/test_method.rb : added

-2004-05-19(Wed) 22:56:09 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : fix typo

- * benchmark/run.rb : sort benchmark order by filename

- * extconf.rb : use --enable/disable-xxx

- * version.h : ditto(don't touch to change yarv options)

-2004-05-19(Wed) 21:18:55 +0900 Koichi Sasada <ko1@atdot.net>

- * yarvutil.rb : added

- * test.rb, test/*, benchmark/run.rb : use yarvutil.rb

- * version.h : USE_OPTIMIZED_REGEXP_MATCH added

- * yarvcore.h : add idEqTilde

- * yarvcore.c(yarvcore_parse, yarvcore_eval) : require file and line

- * test/test_bin.rb : add regexp test

- * benchmark/bm_regexp.rb : added

-2004-05-19(Wed) 13:57:31 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : add compile_dstr(self, node)

- * compile.c : support NODE_MATCH2, NODE_MATCH3, NODE_DXSTR

- * insns.def : add toregexp

-2004-05-18(Tue) 10:12:20 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_XDSTR

- * test/test_bin.rb : add test for above change

-2004-05-18(Tue) 09:46:33 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def(send) : store regs before call_cfunc

-2004-05-18(Tue) 08:55:17 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : support NODE_DSTR, NODE_EVSTR

- * compile.c : support NODE_XSTR

- * insns.def : add tostring operation

- * rb/makedocs.rb : fix directory path

- * depend : add tbench rule

- * yarvcore.h : add 'exten ID idBackquote'

-2004-05-18(Tue) 00:09:48 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h : add USE_OPTIMIZED_BASIC_OPERATION

- * yarvcore.h(struct thread_object) : add 'VALUE stat_insn_usage'

-2004-05-17(Mon) 11:28:55 +0900 Koichi Sasada <ko1@atdot.net>

- * version.h, insns.def, yarvcore.c : add FAKE_INLINE_METHOD_CACHE

-2004-05-17(Mon) 09:05:53 +0900 Koichi Sasada <ko1@atdot.net>

- * compile.c : fix generating opt_* insn process

-2004-05-17(Mon) 08:58:49 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/(bm_tarai.rb, bm_fib.rb) : added

-2004-05-17(Mon) 08:20:12 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/(bm_tak.rb, bm_reccount.rb) : added

- * insns.def : test method cache(incomplete)

- * insns.def : add expandarray insn

- * yarvcore.c(iseq_init) : add parameter 'parent'

-2004-05-17(Mon) 01:49:48 +0900 Koichi Sasada <ko1@atdot.net>

- * benchmark/run.rb, bm_factorial.rb, bm_whileloop.rb : added

- * insns.def(send) : set id to ruby_frame->orig_func

- * check behavior on mswin32 and cygwin

- * insns.def(send) : check stack overflow

-2004-05-16(Sun) 08:00:55 +0900 Koichi Sasada <ko1@atdot.net>

- * change frame structure(debugging)

-2004-05-14(Fri) 15:06:02 +0900 Koichi Sasada <ko1@atdot.net>

- * insns2vm.rb : support file name arguments

-2004-05-14(Fri) 04:33:09 +0900 Koichi Sasada <ko1@atdot.net>

- * insns.def : support (easy) constant

-2004-05-12(Wed) 01:51:48 +0900 Koichi Sasada <ko1@atdot.net>

- * rb/insns2vm.b : set directory prefix

- * disasm.c : fix bug

-2004-05-12(Wed) 00:00:17 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.h, compiler.h, version.h : move *DEBUG defs to version.h

-2004-05-11(Tue) 23:00:11 +0900 Koichi Sasada <ko1@atdot.net>

- * vm.h, version.h, yarvcore.h : move gcc ver check to version.h

- and include version.h from yarvcore.h

-2004-05-11(Tue) 19:16:26 +0900 Koichi Sasada <ko1@atdot.net>

- * 0.0.0.d : imported

-add-log-time-format: (lambda ()

- (let* ((time (current-time))

- (diff (+ (cadr time) 32400))

- (lo (% diff 65536))

- (hi (+ (car time) (/ diff 65536))))

- (format-time-string "%Y-%m-%d(%a) %H:%M:%S +900" (list hi lo) t)))

-indent-tabs-mode: t

-This document is a list of user visible feature changes made between

-releases except for bug fixes.

-Note that each entry is kept so brief that no reason behind or

-reference information is supplied with. For a full list of changes

-with all sufficient information, see the ChangeLog file.

-== Changes since the 1.8.6 release

-=== Configuration changes

- Some C compiler flags may be added by default depending on your

- environment. Specify optflags=.. and warnflags=.. as necessary to

-* vendor_ruby directory

- A new library directory named `vendor_ruby' is introduced in

- addition to `site_ruby'. The idea is to separate libraries

- installed by the package system (`vendor') from manually (`site')

- installed libraries preventing the former from getting overwritten

- by the latter, while preserving the user option to override vendor

- libraries with site libraries. (`site_ruby' takes precedence over

- If you are a package maintainer, make each library package configure

- the library passing the `--vendor' option to `extconf.rb' so that

- the library files will get installed under `vendor_ruby'.

- You can change the directory locations using configure options such

- as `--with-sitedir=DIR' and `--with-vendordir=DIR'.

-=== Global constants

- * RUBY_DESCRIPTION

-=== Library updates (outstanding ones only)

- Take an optional argument that determines the level of recursion

- Handle recursive data properly.

- Use a given block if no argument is given.

- * Array#each_index

- * Array#reverse_each

- Return an enumerator if no block is given.

- Note that #map and #collect still return an array unlike Ruby 1.9

- to keep compatibility.

- Take an optional argument specifying the number of elements to

- * Array#combination

- * Array#drop_while

- * Array#permutation

- * Array#take_while

- Return an enumerator if no block is given.

- * Enumerable::Enumerator

- New class for various enumeration defined by the enumerator library.

- * Enumerable#each_slice

- * Enumerable#each_cons

- New methods for various enumeration defined by the enumerator library.

- * Enumerable#count

- * Enumerable#cycle

- * Enumerable#drop_while

- * Enumerable#find_index

- * Enumerable#first

- * Enumerable#group_by

- * Enumerable#max_by

- * Enumerable#min_by

- * Enumerable#minmax

- * Enumerable#minmax_by

- * Enumerable#none?

- * Enumerable#take_while

- * Enumerable#find_all

- * Enumerable#partition

- * Enumerable#reject

- * Enumerable#select

- * Enumerable#sort_by

- Return an enumerator if no block is given.

- Note that #map and #collect still return an array unlike Ruby 1.9

- to keep compatibility.

- * Enumerable#inject

- Accepts a binary operator instead of a block.

- * Enumerable#reduce

- New alias to #inject.

- Handle recursive data properly.

- Return an enumerator if no block is given.

- * UnboundMethod#name

- * UnboundMethod#owner

- * Module#class_exec

- * Module#module_exec

- Return an enumerator if no block is given.

- * Object#instance_exec

- * ObjectSpace.each_object

- Return an enumerator if no block is given.

- * Process.exec implemented.

- Return an enumerator if no block is given.

- * Regexp.union accepts an array of patterns.

- New method, returning the size in bytes. (alias length and size)

- * String#each_char

- * String#partition

- * String#rpartition

- * String#start_with?

- * String#end_with?

- New methods. These are $KCODE aware unlike #index, #rindex and

- * String#each_byte

- * String#each_line

- * String#gsub(pattern)

- Return an enumerator if no block is given.

- An optional second argument is added to specify if the last value

- should be included.

- New exception class that causes Kernel#loop to stop iteration when

- * Struct#each_pair

- Return an enumerator if no block is given.

- New global function that returns the name of the current method as

- * Enumerator is now a built-in module. The #next and #rewind

- methods are implemented using the "generator" library. Use with

- care and be aware of the performance loss.

- IPAddr objects are now comparable and enumerable having these

- methods. This also means that it is possible to have a Range

- object between two IPAddr objects.

- A new method to create a Range object for the (network) address.

- * Type coercion support

- These methods now accept a string or an integer instead of an

- IPAddr object as the argument.

- * Support SSL/TLS.

- * OpenSSL::PKey::EC

- * OpenSSL::PKey::EC::Group

- * OpenSSL::PKey::EC::Point

- * OpenSSL::PKey::PKCS5

- * OpenSSL::SSL::Session

- * Various new methods (see documentation).

- * Remove redundant module namespace in Cipher, Digest, PKCS7, PKCS12.

- Compatibility classes are provided which will be removed in Ruby 1.9.

- * Add methods for escaping shell-unsafe characters:

- * Shellwords.escape

- * String#shellescape

- * Add shorthand methods:

- * Shellwords.split (alias shellwords)

- * String#shellsplit

- * StringIO#getbyte

- * StringIO#readbyte

- New methods. (aliases for compatibility with 1.9)

- * StringIO#each_char

- * StringIO#each_line

- * StringIO#each_byte

- Return an enumerator if no block is given.

- * Tempfile.open and Tempfile.new now accept a suffix for the

- temporary file to be created. To specify a suffix, pass an array

- of [basename, suffix] as the first argument.

- Tempfile.open(['image', 'jpg']) { |tempfile| ... }

- * added LDAPS scheme.

- * Change for RFC3986:

- * URI('ftp://example.com/foo').path #=> 'foo'

- * URI('ftp://example.com/%2Ffoo').path #=> '/foo'

- * URI::FTP.build([nil, 'example.com', nil, '/foo', 'i').to_s #=> 'ftp://example.com/%2Ffoo;type=i'

- * URI('http://a/b/c/d;p?q').merge('?y') == URI('http://a/b/c/d;p?y')

- * URI('http://a/b/c/d;p?q').merge('/./g') == URI('http://a/g')

- * URI('http://a/b/c/d;p?q').merge('/../g') == URI('http://a/g')

- * URI('http://a/b/c/d;p?q').merge('../../../g') == URI('http://a/g')

- * URI('http://a/b/c/d;p?q').merge('../../../../g') == URI('http://a/g')

- * Fix image module URI

- * ITunes module support

- * Slash module support

- * content:encoded with RSS 2.0 support

-=== Interpreter Implementation

-* passing a block to a Proc [experimental]

- This implementation in current shape is known to be buggy/broken,

- especially with nested block invocation. Take this as an

- experimental feature.

- On non-SystemStackError exception, full stack trace is shown.

-=== Compatibility issues (excluding feature bug fixes)

-* String#slice! had some unintentional bugs and they have been fixed

- because either they disagreed with documentation or their respective

- behavior of #slice. Unfortunately, this causes some

- incompatibilities in the following (somewhat rare) cases.

- * #slice! no longer expands the array when an out-of-boundary value

- a.slice!(4,0) #=> nil

- a #=> [1,2,nil,nil]

- a.slice!(4,0) #=> nil

- * #slice! no longer raises an exception but returns nil when a

- negative length or out-of-boundary negative position is given.

- a.slice!(1,-1) #=> (raises IndexError)

- a.slice!(-5,1) #=> (raises IndexError)

- a.slice!(1,-1) #=> nil

- a.slice!(-5,1) #=> nil

-* String#to_i, String#hex and String#oct no longer accept a sequence

- of underscores (`__') as part of a number.

- '1__0'.to_i #=> 10

- '1__0'.to_i(2) #=> 2 # 0b10

- '1__0'.oct #=> 8 # 010

- '1__0'.hex #=> 16 # 0x10

- '1__0'.to_i(2) #=> 1

- The old behavior was inconsistent with Ruby syntax and considered as

- '##.##.##' (where each '#' is a digit) is now taken as 'YY.MM.DD'

- instead of 'MM.DD.YY'. While the change may confuse you, you can

- always use Date.strptime() when you know what you are dealing

- * StringIO#each_byte

- The return value changed from nil to self. This is what the

- document says and the same as each_line() does.

- * The file name format has changed. No dots are included by default

- in temporary file names any more. See above for how to specify a

- * See above for details.

-== Changes since the 1.8.5 release

-=== New platforms/build tools support

-=== Global constants

- New constant since 1.8.5-p1.

-=== Library updates (outstanding ones only)

- * New method: Kernel#instance_variable_defined?

- * New method: Module#class_variable_defined?

- * New feature: Dir::glob() can now take an array of glob patterns.

- * Updated based on date2 4.0.3.

- * New internal APIs for C and Ruby.

- * Support for autoloading.

- # autoloads digest/md5

- md = Digest::MD5.digest("string")

- * New digest class methods: file

- * New digest instance methods: clone, reset, new, inspect,

- digest_length (alias size or length), block_length()

- * New library: digest/bubblebabble

- * New function: Digest(name)

- * New option for FileUtils.cp_r(): :remove_destination

- * Updated based on nkf as of 2007-01-28.

- * Replaced with much faster mutex implementation in C. The former

- implementation, which is slow but considered to be stable, is

- available with a configure option `--disable-fastthread'.

- * Updated Tile extension support based on Tile 0.7.8.

- * Support --without-X11 configure option for non-X11 versions of

- Tcl/Tk (e.g. Tcl/Tk Aqua).

- * New sample script: irbtkw.rbw -- IRB on Ruby/Tk. It has no trouble

- about STDIN blocking on Windows.

- * New method: WEBrick::Cookie.parse_set_cookies()

-=== Compatibility issues (excluding feature bug fixes)

- * String#intern now raises SecurityError when $SAFE level is greater

- * Time#to_date and Time#to_datetime are added as private methods.

- They cause name conflict error in ActiveSupport 1.4.1 and prior,

- which comes with Rails 1.2.2 and prior. Updating ActiveSupport

- and/or Rails to the latest versions fixes the problem.

- * The constructor does no longer take an initial string to feed.

- The following examples show how to migrate:

- md = Digest::MD5.new("string")

- # After (works with any version)

- md = Digest::MD5.new.update("string")

- hd = Digest::MD5.new("string").hexdigest

- # After (works with any version)

- hd = Digest::MD5.hexdigest("string")

- Automatic detection between binary digest values and hexadecimal

- digest values has been dropped. It is always assumed that a

- hexadecimal digest value is given for comparison.

- Digest objects are compared by the resulting digest values, not

- by the exact vector states.

- * A minor implementation change breaks Rake <=0.7.1.

- Updating Rake to 0.7.2 or higher fixes the problem.

- * Tk::X_Scrollable (Y_Scrollable) is renamed to Tk::XScrollable

- (YScrollable). Tk::X_Scrollable (Y_Scrollable) is still available,

- but it is an alias name.

-This document is a list of user visible feature changes made between

-releases except for bug fixes.

-Note that each entry is kept so brief that no reason behind or

-reference information is supplied with. For a full list of changes

-with all sufficient information, see the ChangeLog file.

-== Changes since the 1.8.7 release

-See doc/NEWS-1.8.7 for changes between 1.8.6 and 1.8.7.

-=== Compatibility issues

- * New syntax and semantics

- o Block arguments are always local

- o New semantics for block arguments

- o defined? and local variables

- o Parser expects that your source code has only valid byte

- sequence in some character encoding. Use magic comments

- to tell the parser which encoding you use.

- o New semantics for constant definition in instance_eval

- or in module_eval.

- * Deprecated syntax

- o colon (:) instead of "then" in if/unless or case expression.

- o retry in a loop or an iterator.

-* builtin classes and objects

- * Kernel and Object

- o Kernel#methods and #singleton_methods used to return an

- array of strings but now they return an array of symbols.

- * Class and Module

- o Module#attr works as Module#attr_reader by default.

- Optional boolean argument is obsolete.

- o Module#instance_methods, #private_instance_methods and

- #public_instance_methods used to return an array of

- strings but now they return an array of symbols.

- o Extra subclassing check when binding UnboundMethods

- o Exceptions are equal to each other if they belong to

- the same class and have the same message and backtrace.

- o SystemStackError used to be a subclass of StandardError

- but not it is a direct subclass of Exception.

- o SecurityError: ditto

- o Removed Exception#to_str [Ruby2]

- * Enumerable and Enumerator

- o Enumerable::Enumerator, compatibility alias of Enumerator,

- o Enumerable#{map,collect} called without a block returns

- o Even more builtin and bundled libraries have been made to

- return an enumerator when called without a block.

- o Array#nitems was removed (use count {|i| !i.nil?})

- o Array#choice was removed (use sample)

- o Array#[m,n] = nil places nil in the array.

- o Hash#to_s is equivalent to Hash#inspect

- o Semantics for Hash#each and Hash#each_pair

- o Hash#select returns a hash

- o Hash#key is the new name for #index which has been

- o Hash preserves order. It enumerates its elements in the

- order in which the keys are inserted.

- o Most of the changes in Hash apply to hash like interfaces

- such as ENV and *DBM.

- o Many methods used to act byte-wise but now some of those act

- character-wise. You can use alternate byte-wise methods.

- o Kernel#open takes "t" for newline conversion

- o Kernel#open takes encoding specified

- o IO automatically converts byte sequence from a character

- encodings into another if specified.

- o StringIO#readpartial

- o IO#close_on_exec= and IO#close_on_exec?

- o Limit input in IO#gets, IO#readline, IO#readlines,

- IO#each_line, IO#lines, IO.foreach, IO.readlines,

- StringIO#gets, StringIO#readline, StringIO#each,

- StringIO#readlines

- o IO#ungetc, StringIO#ungetc

- o IO#ungetbyte, StringIO#ungetbyte

- o IO#internal_encoding, IO#external_encoding,

- o IO.pipe takes encoding option

- o Directive %u behaves like %d for negative values in

- printf-style formatting.

- * File and Dir operations

- o #to_path is called as necessary in File.path, File.chmod,

- File.lchmod, File.chown, File.lchown, File.utime,

- File.unlink, etc..

- o File.world_readable?

- o File.world_writable?

- o Dir.[], Dir.glob

- o File::Stat#world_readable?

- o File::Stat#world_writable?

- o No longer an Enumerable: use each_line/lines for line

- oriented operation

- o Encoding-awareness

- o Character-wise semantics in many methods instead of

- o String#[]: Indexing a String with an integer returns a

- single character String instead of an integer.

- o String#[]=: No longer takes an integer as right

- side value. Note that "str[i] = ?c" because of

- the following change.

- o ?c is evaluated to a single character string

- instead of an integer.

- o Encoding-awareness

- o Regexp matches only with strings which is encoded in a

- compatible character encoding to the regexp's.

- o Regexp#kcode is removed. use Regexp#encoding.

- * Symbols: restriction on literal symbols

- o Numeric#div always rounds as Integer#div has done.

- o Numeric#fdiv: ditto.

- o Integer(nil) raises TypeError

- o Fixnum#id2name removed

- o Fixnum#to_sym removed

- o New format in Time#to_s

- o Timezone information preserved on Marshal.dump/load

- * $SAFE and bound methods

- o New trusted/untrusted model in addition to

- tainted/untainted model.

- o $= (global flag for case-sensitiveness on string matching)

- o Kernel#getc, #gsub, #sub

- o Kernel#callcc and Continuation now become 'continuation'

- o Removed Array and Hash #indices, #indexes

- o Process::Status#to_int

- o Precision is removed. Don't cry, it will be redesigned

- and come back in future version.

- o Symbol#to_int and Symbol#to_i

- o $KCODE is no longer effective. Use Encoding related

- features of each class.

- o VERSION and friends

-* bundled libraries

- o No longer has #to_str nor #=~.

- o Time.parse and Date.parse interprets slashed numerical dates

- o If Readline uses libedit, Readline::HISTORY[0] returns the

- first of the history.

- o Complex#image: use Complex#imag

- o All SSL-related class methods in Net::SMTP

- o Prime#cache, Prime#primes, Prime#primes_so_far

- o mailread library: use tmail gem.

- o cgi-lib library: use cgi.

- o date2 library: use date.

- o finalize library: use ObjectSpace.define_finalizer if you

- really need a finalizer. really?

- o ftools library: use fileutils.

- o generator library: use Enumerator.

- o importenv library and Env library

- o jcode library: use multilingualization support of String

- o parsedate library

- o readbytes library

- o getopts library and parsearg library: use optparse or

- o soap, wsdl and xsd libraries: use soap4r gem.

- o Win32API library: use dl.

- o dl library: Reimplemented and API changed. use the new

- version of dl or ffi gem.

- o rubyunit library and runit library: use minitest or

- test/unit. Or use anything you love through RubyGems.

- o test/unit is reimplemented on top of minitest. This is

- not fully compatible with the original.

-=== Language core changes

- * New syntax and semantics

- o Magic comments to declare in which encoding your source

- o New literal hash syntax and new syntax for hash style

- o New syntax for lambdas

- o .() and calling Procs without #call/#[]

- o Block in block arguments

- o Block local variables

- o Mandatory arguments after optional arguments allowed

- o Multiple splats allowed

- o #[] can take splatted arguments, hash style arguments

- o New directives in printf-style formatted strings (%).

- o Newlines allowed before ternary colon operator (:) and

- method call dot operator (.)

- o Negative operators such as !, != and !~ are now

- o Encoding.default_external and default_internal

- o __ENCODING__: New pseudo variable to hold the current

-=== Library updates

-* builtin classes and objects

- * Kernel and Object

- o Object#=~ returns nil instead of false by default.

- o Kernel#define_singleton_method

- o Kernel#load can load a library from the highest versions

- of gems by default.

- * Class and Module

- o Module#const_defined?, #const_get and #method_defined?

- take an optional parameter.

- o #class_variable_{set,get} are public.

- o Class of singleton classes

- o All of those are always defined. Errno::EXXX will be

- defined as an alias to Errno::NOERROR if your platform

- does not have one.

- * Blocks and Procs

- o Arity of blocks without arguments

- o proc is now a synonym of Proc.new

- o Passing blocks to #[]

- * Fiber: coroutines/micro-threads

- o Thread.critical and Thread.critical= removed

- o Thread#exit!, Thread#kill! and Thread#terminate! removed.

- * Enumerable and Enumerator

- o Enumerator#enum_cons and Enumerator#enum_slice are

- removed. Use #each_cons and #each_slice without a block.

- o Enumerable#each_with_index can take optional arguments

- and passes them to #each.

- o Enumerable#each_with_object

- o Enumerator#with_object

- o Enumerator.new { ... }

- o Array#delete returns a deleted element rather than a given

- o Array#to_s is equivalent to Array#inspect

- o Array.try_convert

- o Array#pack('m0') complies with RFC 4648.

- o preserving item insertion order

- o Hash#default_proc=

- o Hash#_compare_by_identity and Hash#compare_by_identity?

- o Hash.try_convert

- o Range#include? iterates over elements and compares the

- given value with each element unless the range is numeric.

- Use Range#cover? for the old behavior, i.e. comparison

- with boundary values.

- o Range#min, Range#max

- * File and Dir operations

- o String#getbyte, String#setbyte

- o String#chars and String#each_char act as character-wise.

- o String#codepoints, String#each_codepoint

- o String#unpack with a block

- o String.try_convert

- o String#force_encoding, String#encode and String#encode!

- o String#ascii_only?

- o String#valid_encoding?

- o Zero-length symbols allowed

- o Symbol methods similar to those in String

- o Regexp#=== matches symbols

- o Regexp.try_convert

- o Regexp#fixed_encoding?

- o Regexp#named_captures

- o MatchData#regexp

- * Encoding::Converter

- o supports conversion between many encodings

- o Numeric#upto, #downto, #times, #step

- o Numeric#real?, Complex#real?

- o Numeric#magnitude

- * Rational / Complex

- o They are in the core library now

- o Math#log takes an optional argument.

- o Math#cbrt, Math#lgamma, Math#gamma

- o Time.times removed. Use Process.times.

- o Time#tv_nsec and Time#nsec

- * Misc. new methods

- o RUBY_ENGINE to distinguish between Ruby processor implementation

- o ObjectSpace.count_objects

- o Method#hash, Proc#hash

- o Method#source_location, UnboundMethod#source_location and

- Proc#source_location

- o Elements in $LOAD_PATH and $LOADED_FEATURES are expanded

-* bundled libraries

- o Package management system for Ruby.

- o Integrated with Ruby's library loader.

- o Ruby make. A simple ruby build program with capabilities

- o Our new testing library which is faster, cleaner and easier

- to read than the old test/unit.

- o You can introduce the old test/unit as testunit gem through

- RubyGems if you want.

- o Complex number version of Math

- o Extracted from Mathn and improved. You can easily enumerate

- o Prime.new is obsolete. Use its class methods.

- o Ruby script parser

- o Readline.vi_editing_mode?

- o Readline.emacs_editing_mode?

- o Readline::HISTORY.clear

- o TkXXX widget classes are removed and redefined as aliases of

- o Updated to version 2.2.2. See:

- http://rubyforge.org/frs/shownotes.php?group_id=627&release_id=26434

- o JSON (JavaScript Object Notation) encoder/decoder

-* commandline options

- * --enable-gems, --disable-gems

- * --enable-rubyopt, --disable-rubyopt

- * long options are allowed in RUBYOPT environment variable.

-=== Implementation changes

- * Object Compaction - Object, Array, String, Hash, Struct, Class,

- * st_table compaction (inlining small tables)

- * Ruby codes are compiled into opcodes before executed.

-* Platform supports

- o No longer supports djgpp, bcc32, human68k, MacOS 9 or earlier,

- VMS nor Windows CE.

-# etc.rd - -*- mode: rd; coding: us-ascii -*- created at: Fri Jul 14 00:47:15 JST 1995

-The module to retrieve information from running OS. All operations

-defined in this module are module functions, so that you can include

-Etc module into your class.

- returns login name of the user. It this fails, try getpwuid().

- searches in /etc/passwd file (or equivalent database), and

- returns password entry for the user. The return value is an

- passwd structure, which has members described below.

- name # user name(string)

- passwd # encrypted password(string)

- uid # user ID(integer)

- gid # group ID(integer)

- gecos # gecos field(string)

- dir # home directory(string)

- shell # login shell(string)

- # members below are optional

- change # password change time(integer)

- quota # quota value(integer)

- age # password age(integer)

- class # user access class(string)

- comment # comment(string)

- expire # account expiration time(integer)

- See getpwnam(3) for detail.

---- getpwuid([uid])

- returns passwd entry for the specified user id. If uid is

- ommitted, use the value from getuid(). See getpwuid(3) for

- searches in /etc/group file (or equivalent database), and

- returns group entry for the group id. The return value is an

- group structure, which has members described below.

- name # group name(string)

- passwd # group password(string)

- gid # group ID(integer)

- mem # array of the group member names

- See getgrgid(3) for detail.

- returns the group entry for the specified name. The return

- value is the group structure. See getgrnam(3) for detail.

- iterates over all group entries.

- iterates over all passwd entries.

-# etc.rd.ja - -*- mode: rd; coding: euc-jp; -*- created at: Fri Jul 14 00:47:15 JST 1995

-= Etc(�⥸�塼��)

-�¹Ԥ��Ƥ��OS��ξ��뤿��Υ⥸�塼�롥��饹�˥��󥯥롼��

-��ƻȤ��Ȥ�Ǥ��롥

- ��ʬ��login̾��֤��줬��Ԥ��getpwuid()��Ѥ��

- /etc/passwd�ե��(��뤤��DBM�ե��NIS�ǡ��١��)��

- ��name��̾��passwd��ȥ��֤��ͤ�passwd��¤

- �Τǰʲ��Υ��Ф��ġ�

- name # �桼��̾(ʸ��)

- passwd # �ѥ����(ʸ��)

- uid # �桼��ID(��)

- gid # ��롼��ID(��)

- gecos # gecos�ե��(ʸ��)

- dir # �ۡ��ǥ��쥯�ȥ�(ʸ��)

- shell # ��󥷥��(ʸ��)

- # �ʹߤΥ��Фϥ��ƥ�ˤ�äƤ��󶡤��ʤ��

- change # �ѥ����ѹ��(��)

- quota # ��(��)

- age # ��(��)

- class # �桼��饹(ʸ��)

- comment # ��(ʸ��)

- expire # ��ͭ��(��)

- �ܺ٤�getpwnam(3)�򻲾ȤΤ��ȡ�

---- getpwuid([uid])

- uid��桼��ID�Ȥ��passwd��ȥ��֤��ͤ�getpwnam()��

- Ʊ�ͤǤ��롥��ά��ˤ�getuid()��ͤ��Ѥ��롥�ܺ٤�

- getpwuid(3)�򻲾ȤΤ��ȡ�

- /etc/group�ե��(��뤤�ϡ�getpwnam��)�򸡺��gid�򥰥롼

- ��ID�Ȥ��륰�롼�ץ��ȥ��֤��ͤ�group��¤�Τǰʲ��

- ��Ф��ġ�

- name # ��롼��̾(ʸ��)

- passwd # ��롼�פΥѥ����(ʸ��)

- gid # ��롼��ID(��)

- mem # ��롼�ץ��̾��

- �ܺ٤�getgrgid(3)�򻲾ȤΤ��ȡ�

- name�Ȥ��̾��Υ��롼�ץ��ȥ��֤��ͤ�getgrgid()��Ʊ

- �ͤǤ��롥�ܺ٤�getgrnam(3)�򻲾ȡ�

- ��ƤΥ��롼�ץ��ȥ��˥��뤿��Υ��ƥ졼��

- ��Ƥ�passwd��ȥ��˥��뤿��Υ��ƥ졼��

- $Release Version: 0.9.5 $

- by Keiju ISHITSUKA(keiju@ruby-lang.org)

- :PROMPT_N => nil, # ��³�ԤΥץ��ץ�

-PROMPT_I, PROMPT_N, PROMPT_S, PROMPT_C��, �ե��ޥåȤ��ꤷ�ޤ�.

- :PROMPT_N => "%N(%m):%03n:%i> ",

-pty extension version 0.3 by A.ito

-This extension module adds ruby a functionality to execute an

-arbitrary command through pseudo tty (pty).

-Follow the instruction below.

- then Makefile is generated.

-(3) Do make; make install.

-This extension module defines a module named PTY, which contains

-following module fungtions:

- This function reserves a pty, executes command over the pty

- and returns an array. The return value is an array with three

- elements. The first element in the array is for reading and the

- second for writing. The third element is the process ID of the

- child process. If this function is called with an iterator block,

- the array is passed to the block as block parameters, and the

- function itself returns nil.

- When the child process is suspended or finished, an exception is

- raised. If this function is called with an iterator block,

- exception is raised only within the block. Child process

- monitor is terminated on block exit.

- These functions are obsolete in this version of pty.

- Allocates a pty (pseudo-terminal).

- It returns an array which contains an IO object and a File object.

- The former is the master of the pty.

- The latter is the slave of the pty.

- If a block is given, it yields the array instead of return.

- The value of the block is returned.

- master_io and slave_file is closed when return if they are not closed.

- PTY.check(pid[, raise=false])

- checks the status of the child process specified by pid, and

- returns nil if the process is still alive and active.

- Otherwise, returns Process::Status about the process if raise is

- false, or PTY::ChildExited exception is raised.

-This software may be redistributed freely for this purpose, in full

-or in part, provided that this entire copyright notice is included

-on any copies of this software and applications and derivations thereof.

-This software is provided on an "as is" basis, without warranty of any

-kind, either expressed or implied, as to any matter including, but not

-limited to warranty of fitness of purpose, or merchantability, or

-results obtained from use of this software.

-Please feel free to send E-mail to

- aito@ei5sun.yz.yamagata-u.ac.jp

-for any bug report, opinion, contribution, etc.

-pty ��ĥ�⥸�塼�� version 0.3 by A.ito

-��γ�ĥ�⥸�塼��ϡ��tty (pty) ��̤��Ŭ��ʥ��ޥ�ɤ�

-�¹Ԥ��뵡ǽ�� ruby ��󶡤��ޤ��

-2. ��󥹥ȡ��

-��Τ褦�ˤ��ƥ��󥹥ȡ��뤷�Ƥ��

-(1) ruby extconf.rb

- ��¹Ԥ�� Makefile ��ޤ��

-(2) make; make install ��¹Ԥ��Ƥ��

-3. ��Ǥ��뤫

-��γ�ĥ�⥸�塼��ϡ�PTY �Ȥ��⥸�塼��ޤ��

-�ˤϡ��Τ褦�ʥ⥸�塼��ؿ��ޤޤ�Ƥ��ޤ��

- ��δؿ��ϡ��tty��ݤ��ꤵ�줿��ޥ�ɤ򤽤β��tty

- �θ��Ǽ¹Ԥ��֤��ޤ��ͤ�3�Ĥ��Ǥ��ʤ�

- ��Ǥ��ǽ��Ǥϲ��tty��ɤ߽Ф��IO��֥��ȡ�

- 2��ܤϽ񤭤��ि��IO��֥��ȡ�3��ܤϻҥץ��Υץ�

- ��ID�Ǥ��δؿ��ƥ졼��Ȥ��ƸƤФ줿��硤��

- ��Ǥϥ֥��å��ѥ�᡼��Ȥ��Ϥ��졤�ؿ��Τ�nil��֤��ޤ��

- �ҥץ��λ��ߤ��ˤϡ��㳰��ȯ��ޤ��δ�

- ��֥��å��ѥ�᡼��դ��ǸƤФ줿��ˤϡ��Υ֥��å��

- �Τ��㳰��ȯ��ޤ��ҥץ��˥��Ƥ��륹��åɤϥ֥��

- ��ȴ��Ȥ��˽�λ��ޤ��

- �ѻ�ͽ��Ǥ��

- ��tty��ݤ��ޥ��¦��б��IO��֥��Ȥȥ��졼��¦��

- �б��File��֥��Ȥ��֤��ޤ��֥��å��դ��ǸƤӽФ�

- �줿��ϡ��Ǥϥ֥��å��ѥ�᡼��Ȥ��Ϥ��졤�֥��

- ��֤��줿��̤��֤��ޤ��ޤ��Υޥ��IO�ȥ��졼��File

- �ϡ��֥��å��ȴ��Ȥ��˥��ѤߤǤʤ��Х��ޤ��

- PTY.check(pid[, raise=false])

- pid�ǻ��ꤵ�줿�ҥץ��ξ��֤��å��¹��Ǥ��nil��

- �֤��ޤ��λ��Ƥ��뤫��ߤ��Ƥ��硢��Ǥ��С�

- �б��Process::Status��֥��Ȥ��֤��ޤ��Ǥ��

- PTY::ChildExited�㳰��ȯ��ޤ��

-4. ��ѤˤĤ��

-��ƣ��§����ͭ��ޤ��

-��ץ��ޤ��ϥɥ��Ȥ˸��ɽ��Ѥ��줺��

-ɽ��Ƥ��˸¤ꡤï�Ǥ⡤��Υ��եȥ��̵��

-��Ԥ�̵�Ǥ��ѡ��ۡ��ѤǤ��ޤ��Ū�ϸ��ꤵ��Ƥ��ޤ�

-��Υץ��ѡ��ۤ��¾��Υץ��˴ط��԰٤ˤ�

-�ä��ʤ�»��Ф��Ƥ⡤��Ԥϰ��Ǥ��餤�ޤ��

-�Х��ݡ��Ȥϴ��ޤ��ޤ��

- aito@ei5sun.yz.yamagata-u.ac.jp

-�ޤ��Żҥ᡼��ǥХ��ݡ��Ȥ��꤯��

-* Fixed EXEEXT for JRuby on windows.

-* Minor fixes to the RDoc generation (removed dependency on darkfish

- and removed inline source option).

-* Better support for the system command on Windows.

-* Preserve case when locating rakefiles (patch from James

-* Better support for windows paths in the test task (patch from Simon

-* Windows system dir search order is now: HOME, HOMEDRIVE + HOMEPATH,

- APPDATA, USERPROFILE (patch from Luis Lavena)

-* MingGW is now recognized as a windows platform. (patch from Luis

-* Numerous fixes to the windows test suite (patch from Luis Lavena).

-* Improved Rakefile case insensitivity testing (patch from Luis

-* Fixed stray ARGV option problem that was interfering with

- Test::Unit::Runner.

-* Fixed default verbose mode (was accidently changed to false).

-* Removed reference to manage_gem to fix the warning produced by the

-* Enhanced the system directory detection in windows. We now check

- HOMEDRIVE/HOMEPATH and USERPROFILE if APPDATA isn't found. (Patch

- supplied by James Tucker). Rake no long aborts if it can't find the

-* Added fix to handle ruby installations in directories with spaces in

-* Fixed bug in package task so that it will include the subdir

- directory in the package for testing. (Bug found by Adam Majer)

-* Added ENV var to rakefile to prevent OS X from including extended

- attribute junk in a tar file. (Bug found by Adam Majer)

-* Fixed filename dependency order bug in test_inspect_pending and

- test_to_s_pending. (Bug found by Adam Majer)

-* Fixed check for file utils options to make them immune to the

- symbol/string differences. (Patch supplied by Edwin Pratomo)

-* Fixed bug with rules involving multiple source (Patch supplied by

- Emanuel Inderm�hle)

-* Switched from getoptlong to optparse (patches supplied by Edwin

-* The -T option will now attempt to dynamically sense the size of the

- terminal. RAKE_COLUMNS will override any dynamic sensing.

-* FileList#clone and FileList#dup have better sematics w.r.t. taint

-* Added ability clear prerequisites, and/or actions from an existing

-* Added the ability to reenable a task to be invoked a second time.

-* Changed RDoc test task to have no default template. This makes it

- easier for the tempate to pick up the template from the environment.

-* Changed from using Mutex to Monitor. Evidently Mutex causes thread

- join errors when Ruby is compiled with -disable-pthreads. (Patch

- supplied by Ittay Dror)

-* Fixed bug in makefile parser that had problems with extra spaces in

- file task names. (Patch supplied by Ittay Dror)

-* Added a performance patch for reading large makefile dependency

- files. (Patch supplied by Ittay Dror)

-* Default values for task arguments can easily be specified with the

- :with_defaults method. (Idea for default argument merging supplied

- by (Adam Q. Salter)

-* The -T output will only self-truncate if the output is a tty.

- However, if RAKE_COLUMNS is explicitly set, it will be honored in

- any case. (Patch provided by Gavin Stark).

-* Numerous fixes for running under windows. A big thanks to Bheeshmar

- Redheendran for spending a good part of the afternoon at the

- Lonestar Ruby Conference to help me work out these issues.

-* Removed requires on parsedate.rb (in Ftptools)

-* Removed ftools from rake.rb. Made it options in sys.rb

-* Added task parameters (e.g. "rake build[version7]")

-* Made task parameters passable to prerequisites.

-* Comments are limited to 80 columns or so (suggested by Jamis Buck).

-* Added -D to display full comments (suggested by Jamis Buck).

-* The rake program will set the status value used in any explicit

- exit(n) calls. (patch provided by Stephen Touset)

-* Fixed error in functional tests that were not including session (and

- silently skipping the functionl tests.

-* Removed --usage and make -h the same as -H.

-* Make a prettier inspect for tasks.

-* Added existing and existing! methods to FileList

-* FileLists now claim to be Arrays (via is_a?) to get better support

- from the FileUtil module.

-* Added init and top_level for custom rake applications.

-* Error messages are now send to stderr rather than stdout (from

- Payton Quackenbush).

-* Better error handling on invalid command line arguments (from Payton

-* Added rcov task and updated unit testing for better code coverage.

-* Fixed some bugs where the application object was going to the global

- appliation instead of using its own data.

-* Added square and curly bracket patterns to FileList#include (Tilman

-* Added plain filename support to rule dependents (suggested by Nobu

-* Added pathmap support to rule dependents.

-* Added a 'tasks' method to a namespace to get a list of tasks

- associated with the namespace.

-* Fixed the method name leak from FileUtils (bug found by Glenn

-* Added rake_extension to handle detection of extension collisions.

-* Added test for noop, bad_option and verbose flags to sh command.

-* Removed dependency on internal fu_xxx functions from FileUtils.

-* Added a 'shame' task to the Rakefile.

-* Added tar_command and zip_command options to the Package task.

-* Added a description to the gem task in GemPackageTask.

-* Fixed a bug when rules have multiple prerequisites (patch by Joel

-* Added a protected 'require "rubygems"' to test/test_application to

- unbreak cruisecontrol.rb.

-* Added the handful of RakeFileUtils to the private method as well.

-* Added block based exclusion.

-* The clean task will no longer delete 'core' if it is a directory.

-* Removed rake_dup. Now we just simply rescue a bad dup.

-* Refactored the FileList reject logic to remove duplication.

-* Removed if __FILE__ at the end of the rake.rb file.

-* Added optional filter parameter to the --tasks command line option.

-* Added flatten to allow rule transform procs to return lists of

- prereqs (Joel VanderWerf provided patch).

-* Added pathmap to String and FileList.

-* The -r option will now load .rake files (but a straight require

- doesn't yet). NOTE: This is experimental ... it may be

-* The -f option without a value will disable the search for a

- Rakefile. The assumption is that the -r files are adequate.

-* Fixed the safe_ln function to fall back to cp in more error

-* Added Rake.original_dir to return the original starting directory of

- the rake application.

-* Added safe_ln support for openAFS (from Ludvig Omholt).

-* Added --trace reminder on short exception messages (David Heinemeier

- Hansson suggestion).

-* Added multitask declaration that executes prerequisites in

- parallel. (Doug Young providied an initial implementation).

-* Fixed missing_const hack to be compatible with Rails. (Jamis Buck

- supplied test case).

-* Made the RDoc task default to internal (in-process) RDoc formatting.

- The old behavior is still available by setting the +external+ flag

-* Rakefiles are now loaded with the expanded path to prevent

- accidental polution from the Ruby load path.

-* The +namespace+ command now returns a NameSpace object that can be

- used to lookup tasks defined in that namespace. This allows for

- better anonymous namespace behavior.

-* Task objects my now be used in prerequisite lists directly.

-* Rebuilt 0.6.0 gem without signing.

-* Fixed file creation bug in the unit tests (caused infinite loop on

-* Fixed bug where session based functional tests were run under

-* Fixed bug in directory tasks so that updating a directory will not

- retrigger file tasks depending on the directory (see

- FileCreationTask and EarlyTime).

-* Added egrep to FileList

-* ruby command now runs same ruby version as rake.

-* Added investigation to task object. (suggested by Martin Fowler)

-* Added ruby_opts to the test task to allow arbitrary ruby options to

- be passed to the test script. (Greg Fast)

-* Fixed the test loader to ignore options. (Greg Fast)

-* Moved Task, FileTask, FileCreationTask and RakeApp into the Rake

- module namespace. Old style namespace behavior can be invoked via

- the --classic-namespace option. (requested by Kelly Felkins).

-* GemTask is now sensitive to the gem platform (Masao Mutoh).

-* A non-existing file prerequisite will no longer cause an exception

- (Philipp Neubeck).

-* Multiple prerequisites on Rake rules now allowed (initial patch

- supplied by Stuart Jansen).

-* Added double quotes to the test runner.

-* Added .svn to default ignore list.

-* Updated FileList#include to support nested arrays and filelists.

-* Added support for importing Rakefile and other dependencies.

-* Fixed bug so that now rules can chain off of existing tasks as well

- as existing files.

-* Fixed verbose flag bug in the testing task. Shortened some failure

-* Make FileUtils methods private at the top level module to avoid

- accidental method leaking into other objects.

-* Added test loader option to test task. "testrb" is no longer the

- default test loader. It is now eating syntax errors that should

- halt the unit tests.

-* Revamped FileList so that it works more like and array (addressed

- flatten bug). Added many tests around file list.

-* Added +ext+ method to both String and FileList.

-* Fixed documentation that was lacking the Rake module name (Tilman

-* Added tar.gz and tar.bz2 support to package task (Tilman Sauerbeck).

-* Recursive rules are now supported (Tilman Sauerbeck).

-* Added warning option for the Test Task (requested by Eric Hodel).

-* The jamis rdoc template is only used if it exists.

-* Added fix for Ruby 1.8.2 test/unit and rails problem.

-* Added contributed rake man file (Jani Monoses).

-* Added Brian Candler's fix for problems in --trace and --dry-run

-* Fixed a bug that prevented the TESTOPTS flag from working with the

- revised for 1.8.2 test task.

-* Updated the docs on --trace to indicate that it also enables a full

- backtrace on errors.

-* Modified the TestTask to workaround the Ruby 1.8.2 change in

- autoexecuting unit tests.

-* Fixed the dry-run flag so it is operating again.

-* Multiple arguments to sh and ruby commands will not be interpreted

- by the shell (patch provided by Jonathan Paisley).

-* Added --silent (-s) to suppress the (in directory) rake message.

-* Changed the "don't know how to rake" message (finally)

-* Changes references to a literal "Rakefile" to reference the global

- variable $rakefile (which contains the actual name of the rakefile).

-* Added block support to the "sh" command, allowing users to take

- special actions on the result of the system call. E.g.

- sh "shell_command" do |ok, res|

- puts "Program returned #{res.exitstatus}" if ! ok

-* Switched to Jamis Buck's RDoc template.

-* Removed autorequire from Rake's gem spec. This prevents the Rake

- libraries from loading while using rails.

-* Added support for .rb versions of Rakefile.

-* Removed \\\n's from test task.

-* Fixed Ruby 1.9 compatibility issue with FileList.

-* Fixed problem in FileList that caused Ruby 1.9 to go into infinite

- recursion. Since to_a was removed from Object, it does not need to

- added back into the list of methods to rewrite in FileList. (Thanks

- to Kent Sibilev for pointing this out).

-* Removed test version of ln in FileUtils that prevented safe_ln from

-* Upgraded comments in TestTask.

-* FileList to_s and inspect now automatically resolve pending changes.

-* FileList#exclude properly returns the FileList.

-* Fixed initialization problem with @comment.

-* Now using multi -r technique in TestTask. Switch Rakefile back to

- using the built-in test task macros because the rake runtime is no

-* Added 'TEST=filename' and 'TESTOPTS=options' to the Test Task

-* Allow a +test_files+ attribute in test tasks. This allows more

- flexibility in specifying test files.

-* Fixed Comment leakage.

-* Added safe_ln that falls back to a copy if a file link is not supported.

-* Package builder now uses safe_ln.

-* Task comments are now additive, combined with "/".

-* Works with (soon to be released) rubygems 0.6.2 (or 0.7.0)

-* FileList now uses deferred loading. The file system is not searched

- until the first call that needs the file names.

-* VAR=VALUE options are now accepted on the command line and are

- treated like environment variables. The values may be tested in a

- Rakefile by referencing ENV['VAR'].

-* File.mtime is now used (instead of File.new().mtime).

-* Removed some hidden dependencies on rubygems. Tests now will test

- gems only if they are installed.

-* Removed Sys from some example files. I believe that is that last

- reference to Sys outside of the contrib area.

-* Updated all copyright notices to include 2004.

-* GEM Installation now works with the application stub.

-* FileLists now automatically ignore CVS, .bak, !

-* GEM Installation now works.

-* Added title to Rake's rdocs

-* Contrib packages are no longer included in the documentation.

-* Removed default for the '--main' option

-* Fixed rendering of the rdoc options

-* Fixed clean/clobber confusion with rerdoc

-* 'title' attribute added

-Package Task Library Issues

-* Version (or explicit :noversion) is required.

-* +package_file+ attribute is now writable

-* Dropped bang version of exclude. Now using ant-like include/exclude semantics.

-* Enabled the "yield self" idiom in FileList#initialize.

-This version contains numerous changes as the RubyConf.new(2003)

-presentation was being prepared. The changes include:

-* The monolithic rubyapp task library is in the process of being

- dropped in favor of lighter weight task libraries.

-* Added "desc" for task descriptions.

-* -T will now display tasks with descriptions.

-* -P will display tasks and prerequisites.

-* Dropped the Sys module in favor of the 1.8.x FileUtils module. Sys

- is still supported in the contrib area.

-* Moved to RubyForge

-* Switched to standard ruby app builder.

-* Added no_match option to file matcher.

-* Fixed indir, which neglected to actually change directories.

-* Added rake module for a help target

-* Added 'for_files' to Sys

-* Added a $rakefile constant

-* Added test for selecting proper rule with multiple targets.

-= RAKE -- Ruby Make

-Supporting Rake version: 0.8.6

-This package contains Rake, a simple ruby build program with

-capabilities similar to make.

-Rake has the following features:

-* Rakefiles (rake's version of Makefiles) are completely defined in

- standard Ruby syntax. No XML files to edit. No quirky Makefile

- syntax to worry about (is that a tab or a space?)

-* Users can specify tasks with prerequisites.

-* Rake supports rule patterns to synthesize implicit tasks.

-* Flexible FileLists that act like arrays but know about manipulating

- file names and paths.

-* A library of prepackaged tasks to make building rakefiles easier. For example,

- tasks for building tarballs, gems and RDoc output are provided.

-* Supports parallel execution of tasks.

-=== Gem Installation

-Download and install rake with the following.

-=== Normal Installation

-You can download the source tarball of the latest version of Rake from

-* http://rubyforge.org/project/showfiles.php?group_id=50

-Extract the tarball and run

-from its distribution directory.

-First, you must write a "Rakefile" file which contains the build rules. Here's

- task :default => [:test]

- ruby "test/unittest.rb"

-This Rakefile has two tasks:

-* A task named "test", which - upon invocation - will run a unit test file in

-* A task named "default". This task does nothing by itself, but it has exactly

- one dependency, namely the "test" task. Invoking the "default" task will

- cause Rake to invoke the "test" task as well.

-Running the "rake" command without any options will cause it to run the

-"default" task in the Rakefile:

- (in /home/some_user/Projects/rake)

- ruby test/unittest.rb

- ....unit test output here...

-Type "rake --help" for all available options.

-=== More Information

-* For details on Rake's command-line invocation, read

- doc/command_line_usage.rdoc[http://rake.rubyforge.org/files/doc/command_line_usage_rdoc.html]

-* For details on writing Rakefiles, see

- doc/rakefile.rdoc[http://rake.rubyforge.org/files/doc/rakefile_rdoc.html].

-* For the original announcement of Rake, see

- doc/rational.rdoc[http://rake.rubyforge.org/files/doc/rational_rdoc.html].

-* For a glossary of terms, see

- doc/glossary.rdoc[http://rake.rubyforge.org/files/doc/glossary_rdoc.html].

-=== Source Repository

-Rake is currently hosted at github. The github web page is

-http://github.com/jimweirich/rake. The public git clone URL is

-* git://github.com/jimweirich/rake.git

-=== Running the Rake Test Suite

-If you wish to run the unit and functional tests that come with Rake:

-* Install the 'session' gem in order to run the functional tests.

-* CD into the top project directory of rake.

-* Type one of the following:

- rake # If you have a version of rake installed

- ruby -Ilib bin/rake # If you do not have a version of rake installed.

-=== Issues and Bug Reports

-Bugs, features requests and other issues can be logged at

-* http://onestepback.org/redmine/projects/show/rake

-You will need an account to before you can post issues. Register at

-http://onestepback.org/redmine/account/register. Or you can send me

-an email (at jim dot weirich at gmail dot com)

-== Online Resources

-=== Rake References

-* Rake Documentation Home: http://docs.rubyrake.org

-* Rake Project Page: http://rubyforge.org/projects/rake

-* Rake API Documents: http://rake.rubyforge.org

-* Rake Source Code Repo: http://github.com/jimweirich/rake

-* Rake Git Repo Clone URL: git://github.com/jimweirich/rake.git

-=== Presentations and Articles about Rake

-* Jim Weirich's 2003 RubyConf presentation: http://onestepback.org/articles/buildingwithrake/

-* Martin Fowler's article on Rake: http://martinfowler.com/articles/rake.html

-== Other Make Reinvisionings ...

-Rake is a late entry in the make replacement field. Here are links to

-other projects with similar (and not so similar) goals.

-* http://directory.fsf.org/bras.html -- Bras, one of earliest

- implementations of "make in a scripting language".

-* http://www.a-a-p.org -- Make in Python

-* http://www.aromatic.com/tools/jam.txt -- JAM, Java Automated Make

-* http://ant.apache.org -- The Ant project

-* http://ppt.perl.org/commands/make/index.html -- Make from the Perl

- Power Tools implementation.

-* http://search.cpan.org/search?query=PerlBuildSystem -- The Perl Build System

-* http://make.rubyforge.org -- Rant, another Ruby make tool.

-[Ryan Dlugosz] For the initial conversation that sparked Rake.

-[nobu.nokada@softhome.net] For the initial patch for rule support.

-[Tilman Sauerbeck <tilman@code-monkey.de>] For the recursive rule patch.

-Rake is available under an MIT-style license.

-:include: MIT-LICENSE

-The Rake homepage is http://rake.rubyforge.org. You can find the Rake

-RubyForge page at http://rubyforge.org/projects/rake.

-Feel free to submit commits or feature requests. If you send a patch,

-remember to update the corresponding unit tests. If fact, I prefer

-new feature to be submitted in the form of new unit tests.

-For other information, feel free to ask on the ruby-talk mailing list

-(which is mirrored to comp.lang.ruby) or contact

-jim dot weirich at gmail.com.

-Author:: Jim Weirich <jim.weirich@gmail.com>

-Requires:: Ruby 1.8.0 or later

- Released under an MIT-style license. See the LICENSE file

- included in the distribution.

-This software is provided "as is" and without any express or

-implied warranties, including, without limitation, the implied

-warranties of merchantibility and fitness for a particular

-= Rake Command Line Usage

-Rake is invoked from the command line using:

- % rake [options ...] [VAR=VALUE] [targets ...]

-[<tt>name=value</tt>]

- Set the environment variable name to value

- during the execution of the rake command. You can access

- the value by using ENV['name'].

-[<tt>--classic-namespace</tt> (-n)]

- Import the Task, FileTask, and FileCreateTask into the top-level

- scope to be compatible with older versions of Rake. Alternatively

- you can include the line <code>require

- 'rake/classic_namespace'</code> in your Rakefile to get the

-[<tt>--describe</tt> _pattern_ (-D)]

- Describe the tasks (matching optional PATTERN), then exit.

-[<tt>--dry-run</tt> (-n)]

- Do a dry run. Print the tasks invoked and executed, but do not

- actually execute any of the actions.

-[<tt>--execute</tt> _code_ (-e)]

- Execute some Ruby code and exit.

-[<tt>--execute-print</tt> _code_ (-p)]

- Execute some Ruby code, print the result, and exit.

-[<tt>--execute-continue</tt> _code_ (-p)]

- Execute some Ruby code, then continue with normal task processing.

-[<tt>--help</tt> (-H)]

- Display some help text and exit.

-[<tt>--libdir</tt> _directory_ (-I)]

- Add _directory_ to the list of directories searched for require.

-[<tt>--nosearch</tt> (-N)]

- Do not search for a Rakefile in parent directories.

-[<tt>--prereqs</tt> (-P)]

- Display a list of all tasks and their immediate prerequisites.

-[<tt>--quiet</tt> (-q)]

- Do not echo commands from FileUtils.

-[<tt>--rakefile</tt> _filename_ (-f)]

- Use _filename_ as the name of the rakefile. The default rakefile

- names are +rakefile+ and +Rakefile+ (with +rakefile+ taking

- precedence). If the rakefile is not found in the current

- directory, +rake+ will search parent directories for a match. The

- directory where the Rakefile is found will become the current

- directory for the actions executed in the Rakefile.

-[<tt>--rakelibdir</tt> _rakelibdir_ (-R)]

- Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')

-[<tt>--require</tt> _name_ (-r)]

- Require _name_ before executing the Rakefile.

- Trace the rules resolution.

-[<tt>--silent (-s)</tt>]

- Like --quiet, but also suppresses the 'in directory' announcement.

-[<tt>--system</tt> (-g)]

- Use the system wide (global) rakefiles. The project Rakefile is

- ignored. By default, the system wide rakefiles are used only if no

- project Rakefile is found. On Unix-like system, the system wide

- rake files are located in $HOME/.rake. On a windows system they

- are stored in $APPDATA/Rake.

-[<tt>--no-system</tt> (-G)]

- Use the project level Rakefile, ignoring the system-wide (global)

-[<tt>--tasks</tt> (-T)]

- Display a list of the major tasks and their comments. Comments

- are defined using the "desc" command.

-[<tt>--trace</tt> (-t)]

- Turn on invoke/execute tracing. Also enable full backtrace on

-[<tt>--usage</tt> (-h)]

- Display a usage message and exit.

-[<tt>--verbose</tt> (-v)]

- Echo the Sys commands to standard output.

-[<tt>--version</tt> (-V)]

- Display the program version and exit.

-In addition, any command line option of the form

-VAR=VALUE will be added to the environment hash

-<tt>ENV</tt> and may be tested in the Rakefile.

-# Example Rakefile -*- ruby -*-

-task :default => [:main]

-file "a.o" => ["a.c"] do |t|

- src = t.name.sub(/\.o$/, '.c')

- sh "gcc #{src} -c -o #{t.name}"

-file "b.o" => ["b.c"] do |t|

- src = t.name.sub(/\.o$/, '.c')

- sh "gcc #{src} -c -o #{t.name}"

-file "main.o" => ["main.c"] do |t|

- src = t.name.sub(/\.o$/, '.c')

- sh "gcc #{src} -c -o #{t.name}"

-OBJFILES = ["a.o", "b.o", "main.o"]

-task :obj => OBJFILES

-file "main" => OBJFILES do |t|

- sh "gcc -o #{t.name} main.o a.o b.o"

- rm_f FileList['*.o']

- Dir['*~'].each { |fn| rm_f fn }

-task :clobber => [:clean] do

-task :run => ["main"] do

-# Example Rakefile -*- ruby -*-

-# Using the power of Ruby

-task :default => [:main]

-def ext(fn, newext)

- fn.sub(/\.[^.]+$/, newext)

-SRCFILES = Dir['*.c']

-OBJFILES = SRCFILES.collect { |fn| ext(fn,".o") }

-OBJFILES.each do |objfile|

- srcfile = ext(objfile, ".c")

- file objfile => [srcfile] do |t|

- sh "gcc #{srcfile} -c -o #{t.name}"

-file "main" => OBJFILES do |t|

- sh "gcc -o #{t.name} main.o a.o b.o"

- rm_f FileList['*.o']

- Dir['*~'].each { |fn| rm_f fn }

-task :clobber => [:clean] do

-task :run => ["main"] do

- printf ("In function a\n");

- printf ("In function b\n");

- Code to be executed in order to perform a task. Actions in a

- rakefile are specified in a code block (usually delimited by

- When a task is executed, all of its actions are performed, in

- the order they were defined. Note that unlike

- <tt>invoke</tt>, <tt>execute</tt> always executes the actions

- (without invoking or executing the prerequisites).

-[file task (FileTask)]

- A file task is a task whose purpose is to create a file

- (which has the same name as the task). When invoked, a file

- task will only execute if one or more of the following

- conditions are true.

- 1. The associated file does not exist.

- 2. A prerequisite has a later time stamp than the existing file.

- Because normal Tasks always have the current time as

- timestamp, a FileTask that has a normal Task prerequisite

- will always execute.

- When a task is invoked, first we check to see if it has been

- invoked before. if it has been, then nothing else is done.

- If this is the first time its been invoked, then we invoke

- each of its prerequisites. Finally, we check to see if we

- need to execute the actions of this task by calling

- <tt>needed?</tt>. Finally, if the task is needed, we execute

- NOTE: Currently prerequisites are invoked even if the task is

- not needed. This may change in the future.

-[prerequisites]

- Every task has a set (possiblity empty) of prerequisites. A

- prerequisite P to Task T is itself a task that must be invoked

- A rule is a recipe for synthesizing a task when no task is

- explicitly defined. Rules generally synthesize file tasks.

-[task (Task)]

- Basic unit of work in a rakefile. A task has a name, a set of

- prerequisites and a list of actions to be performed.

-FONTS = "\"Bitstream Vera Sans\", Verdana, Arial, Helvetica, sans-serif"

- text-decoration: none;

- text-decoration: underline;

- font-family: %fonts%;

- margin-bottom: 0.5em;

- margin-bottom: 1em;

- padding-left: 2em;

- font-weight: bold;

- border: 1px dotted black;

- padding-left: 1em;

- padding-right: 1em;

- text-align: center;

- font-weight: bold;

- font-family: monospace;

-.file-title-prefix {

- font-weight: bold;

- border: 1px solid black;

- background: transparent;

-h1 a, h2 a, .sectiontitle a, .banner a {

-h1 a:hover, h2 a:hover, .sectiontitle a:hover, .banner a:hover {

- border: 1px dotted black;

- margin: 0.5em 2em 0.5em 2em;

- font-style: italic;

- font-weight: bold;

- margin-right: 1em;

- margin-bottom: 1em;

- border: 1px dotted black;

- font-family: monospace;

- border-bottom: 1px dashed black;

- margin-bottom: 0.3em;

- padding-bottom: 0.1em;

-.method .description, .method .sourcecode {

-.description p, .sourcecode p {

- margin-bottom: 0.5em;

-.method .sourcecode p.source-link {

- margin-top: 0.5em;

- margin-top: 0.3em;

- font-style: italic;

- border: 1px solid black;

- font-size: x-large;

- font-weight: bold;

- padding: 0.5em 1em 0.5em 1em;

- border: 1px solid black;

- font-weight: bold;

- padding: 0.2em 1em 0.2em 1em;

- border: 1px dashed black;

-.sourcecode > pre {

- border: 1px dotted black;

-XHTML_PREAMBLE = %{<?xml version="1.0" encoding="%charset%"?>

- PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

-HEADER = XHTML_PREAMBLE + <<ENDHEADER

- <title>%title%</title>

- <meta http-equiv="Content-Type" content="text/html; charset=%charset%" />

- <link rel="stylesheet" href="%style_url%" type="text/css" media="screen" />

- <script language="JavaScript" type="text/javascript">

- function toggleSource( id )

- if( document.getElementById )

- elem = document.getElementById( id )

- link = document.getElementById( "l_" + id )

- else if ( document.all )

- elem = eval( "document.all." + id )

- link = eval( "document.all.l_" + id )

- if( elem.style.display == "block" )

- elem.style.display = "none"

- link.innerHTML = "show source"

- elem.style.display = "block"

- link.innerHTML = "hide source"

- function openCode( url )

- window.open( url, "SOURCE_CODE", "width=400,height=400,scrollbars=yes" )

-<table border='0' cellpadding='0' cellspacing='0' width="100%" class='banner'>

- <table width="100%" border='0' cellpadding='0' cellspacing='0'><tr>

- <td class="file-title" colspan="2">File %short_name%</td>

- <td align="right">

- <table border='0' cellspacing="0" cellpadding="2">

-  (<a href="%cvsurl%">CVS</a>)

- <td>Modified:</td>

- <td>%dtm_modified%</td>

-###################################################################

-CLASS_PAGE = <<HTML

-<table width="100%" border='0' cellpadding='0' cellspacing='0' class='banner'><tr>

- <td class="file-title">%classmod% %full_name%</td>

- <td align="right">

- <table cellspacing=0 cellpadding=2>

-HREF:full_path_url:full_path:

- (<a href="%cvsurl%">CVS</a>)

- <a href="%par_url%">

-###################################################################

-METHOD_LIST = <<HTML

- <div id="content">

- <table cellpadding='0' cellspacing='0' border='0' width="100%"><tr><td align="center">

- </td></tr></table>

- <div class="description">%description%</div>

- <div class="sectiontitle">Required Files</div>

- <li>HREF:aref:name:</li>

- <div class="sectiontitle">Contents</div>

- <li><a href="#%href%">%secname%</a></li>

- <div class="sectiontitle">Methods</div>

- <li>HREF:aref:name:</li>

-<div class="sectiontitle">Included Modules</div>

- <li>HREF:aref:name:</li>

-<div class="sectiontitle"><a nem="%secsequence%">%sectitle%</a></div>

-<div class="description">

- <div class="sectiontitle">Classes and Modules</div>

- <div class="sectiontitle">Constants</div>

- <table border='0' cellpadding='5'>

- <td class="attr-name">%name%</td>

- <td class="attr-value">%value%</td>

- <td colspan="2" class="attr-desc">%desc%</td>

- <div class="sectiontitle">Attributes</div>

- <table border='0' cellpadding='5'>

- <td class='attr-rw'>

- <td class='attr-name'>%name%</td>

- <td class='attr-desc'>%a_desc%</td>

-<div class="sectiontitle">%type% %category% methods</div>

-<div class="method">

- <div class="title">

- <a name="%aref%"></a>%callseq%

- <a name="%aref%"></a>%name%%params%

-[ <a href="javascript:openCode('%codeurl%')">source</a> ]

- <div class="description">

- This method is also aliased as

- <a href="%aref%">%name%</a>

-<div class="sourcecode">

- [ <a href="javascript:toggleSource('%aref%_source')" id="l_%aref%_source">show source</a> ]

- <div id="%aref%_source" class="dyn-source">

-FOOTER = <<ENDFOOTER

-BODY = HEADER + <<ENDBODY

- !INCLUDE!

- <div id="bodyContent">

-########################## Source code ##########################

-SRC_PAGE = XHTML_PREAMBLE + <<HTML

-<head><title>%title%</title>

-<meta http-equiv="Content-Type" content="text/html; charset=%charset%">

-.ruby-comment { color: green; font-style: italic }

-.ruby-constant { color: #4433aa; font-weight: bold; }

-.ruby-identifier { color: #222222; }

-.ruby-ivar { color: #2233dd; }

-.ruby-keyword { color: #3333FF; font-weight: bold }

-.ruby-node { color: #777777; }

-.ruby-operator { color: #111111; }

-.ruby-regexp { color: #662222; }

-.ruby-value { color: #662222; font-style: italic }

- .kw { color: #3333FF; font-weight: bold }

- .cmt { color: green; font-style: italic }

- .str { color: #662222; font-style: italic }

- .re { color: #662222; }

-<body bgcolor="white">

-########################## Index ################################

-FR_INDEX_BODY = <<HTML

-FILE_INDEX = XHTML_PREAMBLE + <<HTML

-<meta http-equiv="Content-Type" content="text/html; charset=%charset%">

- background-color: #EEE;

- font-family: #{FONTS};

- font-weight: bold;

- text-align: center;

- margin: 0.25em 1em 0 1em;

- font-size: x-small;

- text-decoration: none;

- white-space: nowrap;

- text-decoration: underline;

-<base target="docwin">

-<div class="banner">%list_title%</div>

-<div class="entries">

-<a href="%href%">%name%</a>

-CLASS_INDEX = FILE_INDEX

-METHOD_INDEX = FILE_INDEX

-INDEX = XHTML_PREAMBLE + <<HTML

-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

- <title>%title%</title>

- <meta http-equiv="Content-Type" content="text/html; charset=%charset%">

-<frameset cols="20%,*">

- <frameset rows="15%,35%,50%">

- <frame src="fr_file_index.html" title="Files" name="Files" />

- <frame src="fr_class_index.html" name="Classes" />

- <frame src="fr_method_index.html" name="Methods" />

- <frame src="%initial_page%" name="docwin">

-ENDIF:inline_source

-IFNOT:inline_source

- <frameset rows="80%,20%">

- <frame src="%initial_page%" name="docwin">

- <frame src="blank.html" name="source">

-ENDIF:inline_source

- <body bgcolor="white">

- Click <a href="html/index.html">here</a> for a non-frames

- version of this page.

-= Original Prototype Rake

-This is the original 100 line prototype rake program.

- #!/usr/bin/env ruby

- attr_reader :prerequisites

- def initialize(task_name)

- @prerequisites = []

- def enhance(deps=nil, &block)

- @prerequisites |= deps if deps

- @actions << block if block_given?

- @prerequisites.each { |n| Task[n].invoke }

- execute if needed?

- return if @triggered

- @actions.collect { |act| result = act.call(self) }.last

- TASKS[intern(task_name)] or fail "Don't know how to rake #{task_name}"

- def define_task(args, &block)

- fail "Too Many Target Names: #{args.keys.join(' ')}" if args.size > 1

- fail "No Task Name Given" if args.size < 1

- task_name = args.keys[0]

- deps = args[task_name]

- deps = deps.collect {|d| intern(d) }

- get(task_name).enhance(deps, &block)

- def get(task_name)

- name = intern(task_name)

- TASKS[name] ||= self.new(name)

- def intern(task_name)

- (Symbol === task_name) ? task_name : task_name.intern

- class FileTask < Task

- return true unless File.exist?(name)

- latest_prereq = @prerequisites.collect{|n| Task[n].timestamp}.max

- return false if latest_prereq.nil?

- timestamp < latest_prereq

- File.new(name.to_s).mtime

- def task(args, &block)

- Task.define_task(args, &block)

- def file(args, &block)

- FileTask.define_task(args, &block)

- system(cmd) or fail "Command Failed: [#{cmd}]"

- while ! File.exist?("Rakefile")

- fail "No Rakefile found" if Dir.pwd == here

- puts "(in #{Dir.pwd})"

- ARGV.push("default") if ARGV.size == 0

- ARGV.each { |task_name| Task[task_name].invoke }

- rescue Exception => ex

- puts "rake aborted ... #{ex.message}"

- puts ex.backtrace.find {|str| str =~ /Rakefile/ } || ""

- if __FILE__ == $0 then

-= Rakefile Format (as of version 0.8.3)

-First of all, there is no special format for a Rakefile. A Rakefile

-contains executable Ruby code. Anything legal in a ruby script is

-allowed in a Rakefile.

-Now that we understand there is no special syntax in a Rakefile, there

-are some conventions that are used in a Rakefile that are a little

-unusual in a typical Ruby program. Since a Rakefile is tailored to

-specifying tasks and actions, the idioms used in a Rakefile are

-designed to support that.

-So, what goes into a Rakefile?

-Tasks are the main unit of work in a Rakefile. Tasks have a name

-(usually given as a symbol or a string), a list of prerequisites (more

-symbols or strings) and a list of actions (given as a block).

-A task is declared by using the +task+ method. +task+ takes a single

-parameter that is the name of the task.

-=== Tasks with Prerequisites

-Any prerequisites are given as a list (inclosed in square brackets)

-following the name and an arrow (=>).

- task :name => [:prereq1, :prereq2]

-NOTE: Although this syntax looks a little funky, it is legal

-Ruby. We are constructing a hash where the key is :name and the value

-for that key is the list of prerequisites. It is equivalent to the

- hash[:name] = [:prereq1, :prereq2]

-=== Tasks with Actions

-Actions are defined by passing a block to the +task+ method. Any Ruby

-code can be placed in the block. The block may reference the task

-object via the block paramter..

- task :name => [:prereq1, :prereq2] do |t|

- # actions (may reference t)

-=== Multiple Definitions

-A task may be specified more than once. Each specification adds its

-prerequisites and actions to the existing definition. This allows one

-part of a rakefile to specify the actions and a different rakefile

-(perhaps separately generated) to specify the dependencies.

-For example, the following is equivalent to the single task

-specification given above.

- task :name => [:prereq1]

- task :name => [:prereq2]

-Some tasks are designed to create a file from one or more other files.

-Tasks that generate these files may be skipped if the file already

-exists. File tasks are used to specify file creation tasks.

-File tasks are declared using the +file+ method (instead of the +task+

-method). In addition, file tasks are usually named with a string

-rather than a symbol.

-The following file task creates a executable program (named +prog+)

-given two object files name <tt>a.o</tt> and <tt>b.o</tt>. The tasks

-for creating <tt>a.o</tt> and <tt>b.o</tt> are not shown.

- file "prog" => ["a.o", "b.o"] do |t|

- sh "cc -o #{t.name} #{t.prerequisites.join(' ')}"

-It is common to need to create directories upon demand. The

-+directory+ convenience method is a short-hand for creating a FileTask

-that creates the directory. For example, the following declaration

- directory "testdata/examples/doc"

-is equivalent to ...

- file "testdata" do |t| mkdir t.name end

- file "testdata/examples" do |t| mkdir t.name end

- file "testdata/examples/doc" do |t| mkdir t.name end

-The +directory+ method does not accept prerequisites or actions, but

-both prerequisites and actions can be added later. For example ...

- directory "testdata"

- file "testdata" => ["otherdata"]

- file "testdata" do

- cp Dir["standard_data/*.data"], "testdata"

-== Tasks with Parallel Prerequisites

-Rake allows parallel execution of prerequisites using the following syntax:

- multitask :copy_files => [:copy_src, :copy_doc, :copy_bin] do

- puts "All Copies Complete"

-In this example, +copy_files+ is a normal rake task. Its actions are

-executed whereever all of its prerequisites are done. The big

-difference is that the prerequisites (+copy_src+, +copy_bin+ and

-+copy_doc+) are executed in parallel. Each of the prerequisites are

-run in their own Ruby thread, possibly allowing faster overall runtime.

-=== Secondary Prerequisites

-If any of the primary prerequites of a multitask have common secondary

-prerequisites, all of the primary/parallel prerequisites will wait

-until the common prerequisites have been run.

-For example, if the <tt>copy_xxx</tt> tasks have the

-following prerequisites:

- task :copy_src => [:prep_for_copy]

- task :copy_bin => [:prep_for_copy]

- task :copy_doc => [:prep_for_copy]

-Then the +prep_for_copy+ task is run before starting all the copies in

-parallel. Once +prep_for_copy+ is complete, +copy_src+, +copy_bin+,

-and +copy_doc+ are all run in parallel. Note that +prep_for_copy+ is

-run only once, even though it is referenced in multiple threads.

-The Rake internal data structures are thread-safe with respect

-to the multitask parallel execution, so there is no need for the user

-to do extra synchronization for Rake's benefit. However, if there are

-user data structures shared between the parallel prerequisites, the

-user must do whatever is necessary to prevent race conditions.

-== Tasks with Arguments

-Prior to version 0.8.0, rake was only able to handle command line

-arguments of the form NAME=VALUE that were passed into Rake via the

-ENV hash. Many folks had asked for some kind of simple command line

-arguments, perhaps using "--" to separate regular task names from

-argument values on the command line. The problem is that there was no

-easy way to associate positional arguments on the command line with

-different tasks. Suppose both tasks :a and :b expect a command line

-argument: does the first value go with :a? What if :b is run first?

-Should it then get the first command line argument.

-Rake 0.8.0 solves this problem by explicitly passing values directly

-to the tasks that need them. For example, if I had a release task

-that required a version number, I could say:

- rake release[0.8.2]

-And the string "0.8.2" will be passed to the :release task. Multiple

-arguments can be passed by separating them with a comma, for example:

- rake name[john,doe]

-Just a few words of caution. The rake task name and its arguments

-need to be a single command line argument to rake. This generally

-means no spaces. If spaces are needed, then the entire rake +

-argument string should be quoted. Something like this:

- rake "name[billy bob, smith]"

-(Quoting rules vary between operating systems and shells, so make sure

-you consult the proper docs for your OS/shell).

-=== Tasks that Expect Parameters

-Parameters are only given to tasks that are setup to expect them. In

-order to handle named parameters, the task declaration syntax for

-tasks has been extended slightly.

-For example, a task that needs a first name and last name might be

- task :name, [:first_name, :last_name]

-The first argument is still the name of the task (:name in this case).

-The next to argumements are the names of the parameters expected by

-:name in an array (:first_name and :last_name in the example).

-To access the values of the paramters, the block defining the task

-behaviour can now accept a second parameter:

- task :name, [:first_name, :last_name] do |t, args|

- puts "First name is #{args.first_name}"

- puts "Last name is #{args.last_name}"

-The first argument of the block "t" is always bound to the current

-task object. The second argument "args" is an open-struct like object

-that allows access to the task arguments. Extra command line

-arguments to a task are ignored. Missing command line arguments are

-given the nil value.

-If you wish to specify default values for the arguments, you can use

-the with_defaults method in the task body. Here is the above example

-where we specify default values for the first and last names:

- task :name, [:first_name, :last_name] do |t, args|

- args.with_defaults(:first_name => "John", :last_name => "Dough")

- puts "First name is #{args.first_name}"

- puts "Last name is #{args.last_name}"

-=== Tasks that Expect Parameters and Have Prerequisites

-Tasks that use parameters have a slightly different format for

-prerequisites. Use the arrow notation to indicate the prerequisites

-for tasks with arguments. For example:

- task :name, [:first_name, :last_name] => [:pre_name] do |t, args|

- args.with_defaults(:first_name => "John", :last_name => "Dough")

- puts "First name is #{args.first_name}"

- puts "Last name is #{args.last_name}"

-=== Deprecated Task Parameters Format

-There is an older format for declaring task parameters that omitted

-the task argument array and used the :needs keyword to introduce the

-dependencies. That format is still supported for compatibility, but

-is not recommended for use.

-== Accessing Task Programatically

-Sometimes it is useful to manipulate tasks programatically in a

-Rakefile. To find a task object, use the <tt>:[]</tt> operator on the

-<tt>Rake::Task</tt>.

-=== Programmatic Task Example

-For example, the following Rakefile defines two tasks. The :doit task

-simply prints a simple "DONE" message. The :dont class will lookup

-the doit class and remove (clear) all of its prerequisites and

- Rake::Task[:doit].clear

-Running this example:

- (in /Users/jim/working/git/rake/x)

-The ability to programmatically manipulate tasks gives rake very

-powerful meta-programming capabilities w.r.t. task execution, but

-should be used with cation.

-When a file is named as a prerequisite, but does not have a file task

-defined for it, Rake will attempt to synthesize a task by looking at a

-list of rules supplied in the Rakefile.

-Suppose we were trying to invoke task "mycode.o", but no task is

-defined for it. But the rakefile has a rule that look like this ...

- rule '.o' => ['.c'] do |t|

- sh "cc #{t.source} -c -o #{t.name}"

-This rule will synthesize any task that ends in ".o". It has a

-prerequisite a source file with an extension of ".c" must exist. If

-Rake is able to find a file named "mycode.c", it will automatically

-create a task that builds "mycode.o" from "mycode.c".

-If the file "mycode.c" does not exist, rake will attempt

-to recursively synthesize a rule for it.

-When a task is synthesized from a rule, the +source+ attribute of the

-task is set to the matching source file. This allows us to write

-rules with actions that reference the source file.

-Any regular expression may be used as the rule pattern. Additionally,

-a proc may be used to calculate the name of the source file. This

-allows for complex patterns and sources.

-The following rule is equivalent to the example above.

- proc {|task_name| task_name.sub(/\.[^.]+$/, '.c') }

- sh "cc #{t.source} -c -o #{t.name}"

-NOTE: Because of a _quirk_ in Ruby syntax, parenthesis are

-required on *rule* when the first argument is a regular expression.

-The following rule might be used for Java files ...

- proc { |tn| tn.sub(/\.class$/, '.java').sub(/^classes\//, 'src/') }

- java_compile(t.source, t.name)

-NOTE: +java_compile+ is a hypothetical method that invokes the

-== Importing Dependencies

-Any ruby file (including other rakefiles) can be included with a

-standard Ruby +require+ command. The rules and declarations in the

-required file are just added to the definitions already accumulated.

-Because the files are loaded _before_ the rake targets are evaluated,

-the loaded files must be "ready to go" when the rake command is

-invoked. This make generated dependency files difficult to use. By

-the time rake gets around to updating the dependencies file, it is too

-The +import+ command addresses this by specifying a file to be loaded

-_after_ the main rakefile is loaded, but _before_ any targets on the

-command line are specified. In addition, if the file name matches an

-explicit task, that task is invoked before loading the file. This

-allows dependency files to be generated and used in a single rake

-command invocation.

- require 'rake/loaders/makefile'

- file ".depends.mf" => [SRC_LIST] do |t|

- sh "makedepend -f- -- #{CFLAGS} -- #{t.prerequisites} > #{t.name}"

- import ".depends.mf"

-If ".depends" does not exist, or is out of date w.r.t. the source

-files, a new ".depends" file is generated using +makedepend+ before

-Standard Ruby comments (beginning with "#") can be used anywhere it is

-legal in Ruby source code, including comments for tasks and rules.

-However, if you wish a task to be described using the "-T" switch,

-then you need to use the +desc+ command to describe the task.

- desc "Create a distribution package"

- task :package => [ ... ] do ... end

-The "-T" switch (or "--tasks" if you like to spell things out) will

-display a list of tasks that have a defined comment. If you use

-+desc+ to describe your major tasks, you have a semi-automatic way of

-generating a summary of your Rake file.

- (in /home/.../rake)

- rake clean # Remove any temporary products.

- rake clobber # Remove any generated file.

- rake clobber_rdoc # Remove rdoc products

- rake contrib_test # Run tests for contrib_test

- rake default # Default Task

- rake install # Install the application

- rake lines # Count lines in the main rake file

- rake rdoc # Build the rdoc HTML Files

- rake rerdoc # Force a rebuild of the RDOC files

- rake test # Run tests

- rake testall # Run all test targets

-Only tasks with descriptions will be displayed with the "-T" switch.

-Use "-P" (or "--prereqs") to get a list of all tasks and their

-As projects grow (and along with it, the number of tasks), it is

-common for task names to begin to clash. For example, if you might

-have a main program and a set of sample programs built by a single

-Rakefile. By placing the tasks related to the main program in one

-namespace, and the tasks for building the sample programs in a

-different namespace, the task names will not will not interfer with

- # Build the main program

- namespace "samples" do

- # Build the sample programs

- task :build => ["main:build", "samples:build"]

-Referencing a task in a separate namespace can be achieved by

-prefixing the task name with the namespace and a colon

-(e.g. "main:build" refers to the :build task in the +main+ namespace).

-Nested namespaces are supported, so

-Note that the name given in the +task+ command is always the unadorned

-task name without any namespace prefixes. The +task+ command always

-defines a task in the current namespace.

-File task names are not scoped by the namespace command. Since the

-name of a file task is the name of an actual file in the file system,

-it makes little sense to include file task names in name space.

-Directory tasks (created by the +directory+ command) are a type of

-file task and are also not affected by namespaces.

-=== Name Resolution

-When looking up a task name, rake will start with the current

-namespace and attempt to find the name there. If it fails to find a

-name in the current namespace, it will search the parent namespaces

-until a match is found (or an error occurs if there is no match).

-The "rake" namespace is a special implicit namespace that refers to

-the toplevel names.

-If a task name begins with a "^" character, the name resolution will

-start in the parent namespace. Multiple "^" characters are allowed.

-Here is an example file with multiple :run tasks and how various names

-resolve in different locations.

- namespace "one" do

- namespace "two" do

- # :run => "one:two:run"

- # "two:run" => "one:two:run"

- # "one:two:run" => "one:two:run"

- # "one:run" => "one:run"

- # "^run" => "one:run"

- # "^^run" => "rake:run" (the top level task)

- # "rake:run" => "rake:run" (the top level task)

- # :run => "one:run"

- # "two:run" => "one:two:run"

- # "^run" => "rake:run"

- # :run => "rake:run"

- # "one:run" => "one:run"

- # "one:two:run" => "one:two:run"

-FileLists are the way Rake manages lists of files. You can treat a

-FileList as an array of strings for the most part, but FileLists

-support some additional operations.

-=== Creating a FileList

-Creating a file list is easy. Just give it the list of file names:

- fl = FileList['file1.rb', file2.rb']

-Or give it a glob pattern:

- fl = FileList['*.rb']

-=== do/end verses { }

-Blocks may be specified with either a +do+/+end+ pair, or with curly

-braces in Ruby. We _strongly_ recommend using +do+/+end+ to specify the

-actions for tasks and rules. Because the rakefile idiom tends to

-leave off parenthesis on the task/file/rule methods, unusual

-ambiguities can arise when using curly braces.

-For example, suppose that the method +object_files+ returns a list of

-object files in a project. Now we use +object_files+ as the

-prerequistes in a rule specified with actions in curly braces.

- file "prog" => object_files {

- # Actions are expected here (but it doesn't work)!

-Because curly braces have a higher precedence than +do+/+end+, the

-block is associated with the +object_files+ method rather than the

-This is the proper way to specify the task ...

- file "prog" => object_files do

-* README -- Main documentation for Rake.

-Ok, let me state from the beginning that I never intended to write this

-code. I'm not convinced it is useful, and I'm not convinced anyone

-would even be interested in it. All I can say is that Why's onion truck

-must by been passing through the Ohio valley.

-What am I talking about? ... A Ruby version of Make.

-See, I can sense you cringing already, and I agree. The world certainly

-doesn't need yet another reworking of the "make" program. I mean, we

-already have "ant". Isn't that enough?

-It started yesterday. I was helping a coworker fix a problem in one of

-the Makefiles we use in our project. Not a particularly tough problem,

-but during the course of the conversation I began lamenting some of the

-shortcomings of make. In particular, in one of my makefiles I wanted to

-determine the name of a file dynamically and had to resort to some

-simple scripting (in Ruby) to make it work. "Wouldn't it be nice if you

-could just use Ruby inside a Makefile" I said.

-My coworker (a recent convert to Ruby) agreed, but wondered what it

-would look like. So I sketched the following on the whiteboard...

- "What if you could specify the make tasks in Ruby, like this ..."

- java_compile(...args, etc ...)

- "The task function would register "build" as a target to be made,

- and the block would be the action executed whenever the build

- system determined that it was time to do the build target."

-We agreed that would be cool, but writing make from scratch would be WAY

-too much work. And that was the end of that!

-... Except I couldn't get the thought out of my head. What exactly

-would be needed to make the about syntax work as a make file? Hmmm, you

-would need to register the tasks, you need some way of specifying

-dependencies between tasks, and some way of kicking off the process.

-Hey! What if we did ... and fifteen minutes later I had a working

-prototype of Ruby make, complete with dependencies and actions.

-I showed the code to my coworker and we had a good laugh. It was just

-about a page worth of code that reproduced an amazing amount of the

-functionality of make. We were both truely stunned with the power of

-But it didn't do everything make did. In particular, it didn't have

-timestamp based file dependencies (where a file is rebuilt if any of its

-prerequisite files have a later timestamp). Obviously THAT would be a

-pain to add and so Ruby Make would remain an interesting experiment.

-... Except as I walked back to my desk, I started thinking about what

-file based dependecies would really need. Rats! I was hooked again,

-and by adding a new class and two new methods, file/timestamp

-dependencies were implemented.

-Ok, now I was really hooked. Last night (during CSI!) I massaged the

-code and cleaned it up a bit. The result is a bare-bones replacement

-for make in exactly 100 lines of code.

-For the curious, you can see it at ...

-* doc/proto_rake.rdoc

-Oh, about the name. When I wrote the example Ruby Make task on my

-whiteboard, my coworker exclaimed "Oh! I have the perfect name: Rake ...

-Get it? Ruby-Make. Rake!" He said he envisioned the tasks as leaves

-and Rake would clean them up ... or something like that. Anyways, the

-Some quick examples ...

-A simple task to delete backup files ...

- Dir['*~'].each {|fn| rm fn rescue nil}

-Note that task names are symbols (they are slightly easier to type

-than quoted strings ... but you may use quoted string if you would

-rather). Rake makes the methods of the FileUtils module directly

-available, so we take advantage of the <tt>rm</tt> command. Also note

-the use of "rescue nil" to trap and ignore errors in the <tt>rm</tt>

-To run it, just type "rake clean". Rake will automatically find a

-Rakefile in the current directory (or above!) and will invoke the

-targets named on the command line. If there are no targets explicitly

-named, rake will invoke the task "default".

-Here's another task with dependencies ...

- task :clobber => [:clean] do

-Task :clobber depends upon task :clean, so :clean will be run before

-:clobber is executed.

-Files are specified by using the "file" command. It is similar to the

-task command, except that the task name represents a file, and the task

-will be run only if the file doesn't exist, or if its modification time

-is earlier than any of its prerequisites.

-Here is a file based dependency that will compile "hello.cc" to

- file "hello.o" => ["hello.cc"] do |t|

- srcfile = t.name.sub(/\.o$/, ".cc")

- sh %{g++ #{srcfile} -c -o #{t.name}}

-I normally specify file tasks with string (rather than symbols). Some

-file names can't be represented by symbols. Plus it makes the

-distinction between them more clear to the casual reader.

-Currently writing a task for each and every file in the project would be

-tedious at best. I envision a set of libraries to make this job

-easier. For instance, perhaps something like this ...

- require 'rake/ctools'

- Dir['*.c'].each do |fn|

-where "c_source_file" will create all the tasks need to compile all the

-C source files in a directory. Any number of useful libraries could be

-That's it. There's no documentation (other than whats in this

-message). Does this sound interesting to anyone? If so, I'll continue

-to clean it up and write it up and publish it on RAA. Otherwise, I'll

-leave it as an interesting excerise and a tribute to the power of Ruby.

-Why /might/ rake be interesting to Ruby programmers. I don't know,

-* No weird make syntax (only weird Ruby syntax :-)

-* No need to edit or read XML (a la ant)

-* Platform independent build scripts.

-* Will run anywhere Ruby exists, so no need to have "make" installed.

- If you stay away from the "sys" command and use things like

- 'ftools', you can have a perfectly platform independent

- build script. Also rake is only 100 lines of code, so it can

- easily be packaged along with the rest of your code.

-So ... Sorry for the long rambling message. Like I said, I never

-intended to write this code at all.

-= Rake 0.8.7 Released

-Rake version 0.8.5 introduced greatly improved support for executing

-commands on Windows. The "sh" command now has the same semantics on

-Windows that it has on Unix based platforms.

-Rake version 0.8.6 includes minor fixes the the RDoc generation.

-Rake version 0.8.7 includes a minor fix for JRuby running on windows.

-=== New Features / Enhancements in Version 0.8.5

-* Improved implementation of the Rake system command for Windows.

- (patch from James M. Lawrence/quix)

-* Support for Ruby 1.9's improved system command. (patch from James

-* Rake now includes the configured extension when invoking an

- executable (Config::CONFIG['EXEEXT])

-=== Bug Fixes in Version 0.8.5

-* Environment variable keys are now correctly cased (it matters in

- some implementations).

-Rake is a build tool similar to the make program in many ways. But

-instead of cryptic make recipes, Rake uses standard Ruby code to

-declare tasks and dependencies. You have the full power of a modern

-scripting language built right into your build tool.

-The easiest way to get and install rake is via RubyGems ...

- gem install rake (you may need root/admin privileges)

-Otherwise, you can get it from the more traditional places:

-Home Page:: http://rake.rubyforge.org/

-Download:: http://rubyforge.org/project/showfiles.php?group_id=50

-GitHub:: git://github.com/jimweirich/rake.git

-As usual, it was input from users that drove a alot of these changes. The

-following people either contributed patches, made suggestions or made

-otherwise helpful comments. Thanks to ...

-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-

-Regular expressions (regexps) are patterns which describe the

-contents of a string. They're used for testing whether a string contains a

-given pattern, or extracting the portions that match. They are created

-with the <tt>/</tt>pat<tt>/</tt> and

-<tt>%r{</tt>pat<tt>}</tt> literals or the <tt>Regexp.new</tt>

-A regexp is usually delimited with forward slashes (<tt>/</tt>). For

- /hay/ =~ 'haystack' #=> 0

- /y/.match('haystack') #=> #<MatchData "y">

-If a string contains the pattern it is said to match. A literal

-string matches itself.

- # 'haystack' does not contain the pattern 'needle', so doesn't match.

- /needle/.match('haystack') #=> nil

- # 'haystack' does contain the pattern 'hay', so it matches

- /hay/.match('haystack') #=> #<MatchData "hay">

-Specifically, <tt>/st/</tt> requires that the string contains the letter

-_s_ followed by the letter _t_, so it matches _haystack_, also.

-== Metacharacters and Escapes

-The following are metacharacters <tt>(</tt>, <tt>)</tt>,

-<tt>[</tt>, <tt>]</tt>, <tt>{</tt>, <tt>}</tt>, <tt>.</tt>, <tt>?</tt>,

-<tt>+</tt>, <tt>*</tt>. They have a specific meaning when appearing in a

-pattern. To match them literally they must be backslash-escaped. To match

-a backslash literally backslash-escape that: <tt>\\\\\\</tt>.

- /1 \+ 2 = 3\?/.match('Does 1 + 2 = 3?') #=> #<MatchData "1 + 2 = 3?">

-Patterns behave like double-quoted strings so can contain the same

- /\s\u{6771 4eac 90fd}/.match("Go to 東京都")

- #=> #<MatchData " 東京都">

-Arbitrary Ruby expressions can be embedded into patterns with the

-<tt>#{...}</tt> construct.

- place = "東京都"

- /#{place}/.match("Go to 東京都")

- #=> #<MatchData "東京都">

-== Character Classes

-A character class is delimited with square brackets (<tt>[</tt>,

-<tt>]</tt>) and lists characters that may appear at that point in the

-match. <tt>/[ab]/</tt> means _a_ or _b_, as opposed to <tt>/ab/</tt> which

-means _a_ followed by _b_.

- /W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

-Within a character class the hyphen (<tt>-</tt>) is a metacharacter

-denoting an inclusive range of characters. <tt>[abcd]</tt> is equivalent

-to <tt>[a-d]</tt>. A range can be followed by another range, so

-<tt>[abcdwxyz]</tt> is equivalent to <tt>[a-dw-z]</tt>. The order in which

-ranges or individual characters appear inside a character class is

- /[0-9a-f]/.match('9f') #=> #<MatchData "9">

- /[9f]/.match('9f') #=> #<MatchData "9">

-If the first character of a character class is a caret (<tt>^</tt>) the

-class is inverted: it matches any character _except_ those named.

- /[^a-eg-z]/.match('f') #=> #<MatchData "f">

-A character class may contain another character class. By itself this

-isn't useful because <tt>[a-z[0-9]]</tt> describes the same set as

-<tt>[a-z0-9]</tt>. However, character classes also support the <tt>&&</tt>

-operator which performs set intersection on its arguments. The two can be

-combined as follows:

- /[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))

- # This is equivalent to:

-The following metacharacters also behave like character classes:

-* <tt>/./</tt> - Any character except a newline.

-* <tt>/./m</tt> - Any character (the +m+ modifier enables multiline mode)

-* <tt>/\w/</tt> - A word character (<tt>[a-zA-Z0-9_]</tt>)

-* <tt>/\W/</tt> - A non-word character (<tt>[^a-zA-Z0-9_]</tt>)

-* <tt>/\d/</tt> - A digit character (<tt>[0-9]</tt>)

-* <tt>/\D/</tt> - A non-digit character (<tt>[^0-9]</tt>)

-* <tt>/\h/</tt> - A hexdigit character (<tt>[0-9a-fA-F]</tt>)

-* <tt>/\H/</tt> - A non-hexdigit character (<tt>[^0-9a-fA-F]</tt>)

-* <tt>/\s/</tt> - A whitespace character: <tt>/[ \t\r\n\f]/</tt>

-* <tt>/\S/</tt> - A non-whitespace character: <tt>/[^ \t\r\n\f]/</tt>

-POSIX bracket expressions are also similar to character classes.

-They provide a portable alternative to the above, with the added benefit

-that they encompass non-ASCII characters. For instance, <tt>/\d/</tt>

-matches only the ASCII decimal digits (0-9); whereas <tt>/[[:digit:]]/</tt>

-matches any character in the Unicode _Nd_ category.

-* <tt>/[[:alnum:]]/</tt> - Alphabetic and numeric character

-* <tt>/[[:alpha:]]/</tt> - Alphabetic character

-* <tt>/[[:blank:]]/</tt> - Space or tab

-* <tt>/[[:cntrl:]]/</tt> - Control character

-* <tt>/[[:digit:]]/</tt> - Digit

-* <tt>/[[:graph:]]/</tt> - Non-blank character (excludes spaces, control

- characters, and similar)

-* <tt>/[[:lower:]]/</tt> - Lowercase alphabetical character

-* <tt>/[[:print:]]/</tt> - Like [:graph:], but includes the space character

-* <tt>/[[:punct:]]/</tt> - Punctuation character

-* <tt>/[[:space:]]/</tt> - Whitespace character (<tt>[:blank:]</tt>, newline,

- carriage return, etc.)

-* <tt>/[[:upper:]]/</tt> - Uppercase alphabetical

-* <tt>/[[:xdigit:]]/</tt> - Digit allowed in a hexadecimal number (i.e.,

-Ruby also supports the following non-POSIX character classes:

-* <tt>/[[:word:]]/</tt> - A character in one of the following Unicode

- general categories _Letter_, _Mark_, _Number_,

- Connector_Punctuation<i/i>

-* <tt>/[[:ascii:]]/</tt> - A character in the ASCII character set

- # U+06F2 is "EXTENDED ARABIC-INDIC DIGIT TWO"

- /[[:digit:]]/.match("\u06F2") #=> #<MatchData "\u{06F2}">

- /[[:upper:]][[:lower:]]/.match("Hello") #=> #<MatchData "He">

- /[[:xdigit:]][[:xdigit:]]/.match("A6") #=> #<MatchData "A6">

-The constructs described so far match a single character. They can be

-followed by a repetition metacharacter to specify how many times they need

-to occur. Such metacharacters are called quantifiers.

-* <tt>*</tt> - Zero or more times

-* <tt>+</tt> - One or more times

-* <tt>?</tt> - Zero or one times (optional)

-* <tt>{</tt>n<tt>}</tt> - Exactly n times

-* <tt>{</tt>n<tt>,}</tt> - n or more times

-* <tt>{,</tt>m<tt>}</tt> - m or less times

-* <tt>{</tt>n<tt>,</tt>m<tt>}</tt> - At least n and

- at most m times

- # At least one uppercase character ('H'), at least one lowercase

- # character ('e'), two 'l' characters, then one 'o'

- "Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

-Repetition is greedy by default: as many occurrences as possible

-are matched while still allowing the overall match to succeed. By

-contrast, lazy matching makes the minimal amount of matches

-necessary for overall success. A greedy metacharacter can be made lazy by

-following it with <tt>?</tt>.

- # Both patterns below match the string. The fist uses a greedy

- # quantifier so '.+' matches '<a>'; the second uses a lazy

- # quantifier so '.+?' matches '<a>'.

- /<.+>/.match("<a>") #=> #<MatchData "<a>">

- /<.+?>/.match("<a>") #=> #<MatchData "<a>">

-A quantifier followed by <tt>+</tt> matches possessively: once it

-has matched it does not backtrack. They behave like greedy quantifiers,

-but having matched they refuse to "give up" their match even if this

-jeopardises the overall match.

-Parentheses can be used for capturing. The text enclosed by the

-nth group of parentheses can be subsequently referred to

-with n. Within a pattern use the backreference

-<tt>\</tt>n; outside of the pattern use

-<tt>MatchData[</tt>n<tt>]</tt>.

- # 'at' is captured by the first group of parentheses, then referred to

- /[csh](..) [csh]\1 in/.match("The cat sat in the hat")

- #=> #<MatchData "cat sat in" 1:"at">

- # Regexp#match returns a MatchData object which makes the captured

- # text available with its #[] method.

- /[csh](..) [csh]\1 in/.match("The cat sat in the hat")[1] #=> 'at'

-Capture groups can be referred to by name when defined with the

-<tt>(?<</tt>name<tt>>)</tt> or <tt>(?'</tt>name<tt>')</tt>

- /\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")

- => #<MatchData "$3.67" dollars:"3" cents:"67">

- /\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")[:dollars] #=> "3"

-Named groups can be backreferenced with <tt>\k<</tt>name<tt>></tt>,

-where _name_ is the group name.

- /(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')

- #=> #<MatchData "ototo" vowel:"o">

-*Note*: A regexp can't use named backreferences and numbered

-backreferences simultaneously.

-When named capture groups are used with a literal regexp on the left-hand

-side of an expression and the <tt>=~</tt> operator, the captured text is

-also assigned to local variables with corresponding names.

- /\$(?<dollars>\d+)\.(?<cents>\d+)/ =~ "$3.67" #=> 0

-Parentheses also group the terms they enclose, allowing them to be

-quantified as one atomic whole.

- # The pattern below matches a vowel followed by 2 word characters:

- /[aeiou]\w{2}/.match("Caenorhabditis elegans") #=> #<MatchData "aen">

- # Whereas the following pattern matches a vowel followed by a word

- # character, twice, i.e. <tt>[aeiou]\w[aeiou]\w</tt>: 'enor'.

- /([aeiou]\w){2}/.match("Caenorhabditis elegans")

- #=> #<MatchData "enor" 1:"or">

-The <tt>(?:</tt>...<tt>)</tt> construct provides grouping without

-capturing. That is, it combines the terms it contains into an atomic whole

-without creating a backreference. This benefits performance at the slight

-expense of readabilty.

- # The group of parentheses captures 'n' and the second 'ti'. The

- # second group is referred to later with the backreference \2

- /I(n)ves(ti)ga\2ons/.match("Investigations")

- #=> #<MatchData "Investigations" 1:"n" 2:"ti">

- # The first group of parentheses is now made non-capturing with '?:',

- # so it still matches 'n', but doesn't create the backreference. Thus,

- # the backreference \1 now refers to 'ti'.

- /I(?:n)ves(ti)ga\1ons/.match("Investigations")

- #=> #<MatchData "Investigations" 1:"ti">

-=== Atomic Grouping

-Grouping can be made atomic with

-<tt>(?></tt>pat<tt>)</tt>. This causes the subexpression pat

-to be matched independently of the rest of the expression such that what

-it matches becomes fixed for the remainder of the match, unless the entire

-subexpression must be abandoned and subsequently revisited. In this

-way pat is treated as a non-divisible whole. Atomic grouping is

-typically used to optimise patterns so as to prevent the regular

-expression engine from backtracking needlesly.

- # The <tt>"</tt> in the pattern below matches the first character of

- # the string, then <tt>.*</tt> matches Quote". This causes the

- # overall match to fail, so the text matched by <tt>.*</tt> is

- # backtracked by one position, which leaves the final character of the

- # string available to match <tt>"</tt>

- /".*"/.match('"Quote"') #=> #<MatchData "\"Quote\"">

- # If <tt>.*</tt> is grouped atomically, it refuses to backtrack

- # Quote", even though this means that the overall match fails

- /"(?>.*)"/.match('"Quote"') #=> nil

-== Subexpression Calls

-The <tt>\g<</tt>name<tt>></tt> syntax matches the previous

-subexpression named _name_, which can be a group name or number, again.

-This differs from backreferences in that it re-executes the group rather

-than simply trying to re-match the same text.

- # Matches a ( character and assigns it to the <tt>paren</tt>

- # group, tries to call that the <tt>paren</tt> sub-expression again

- # but fails, then matches a literal ).

- /\A(?<paren>$\g<paren>*$)*\z/ =~ '()'

- /\A(?<paren>$\g<paren>*$)*\z/ =~ '(())' #=> 0

-1. Matches at the beginning of the string, i.e. before the first

-2. Enters a named capture group called <tt>paren</tt>

-3. Matches a literal (, the first character in the string

-4. Calls the <tt>paren</tt> group again, i.e. recurses back to the

-5. Re-enters the <tt>paren</tt> group

-6. Matches a literal (, the second character in the

-7. Try to call <tt>paren</tt> a third time, but fail because

- doing so would prevent an overall successful match

-8. Match a literal ), the third character in the string.

- Marks the end of the second recursive call

-9. Match a literal ), the fourth character in the string

-10. Match the end of the string

-The vertical bar metacharacter (<tt>|</tt>) combines two expressions into

-a single one that matches either of the expressions. Each expression is an

-alternative.

- /\w(and|or)\w/.match("Feliformia") #=> #<MatchData "form" 1:"or">

- /\w(and|or)\w/.match("furandi") #=> #<MatchData "randi" 1:"and">

- /\w(and|or)\w/.match("dissemblance") #=> nil

-== Character Properties

-The <tt>\p{}</tt> construct matches characters with the named property,

-much like POSIX bracket classes.

-* <tt>/\p{Alnum}/</tt> - Alphabetic and numeric character

-* <tt>/\p{Alpha}/</tt> - Alphabetic character

-* <tt>/\p{Blank}/</tt> - Space or tab

-* <tt>/\p{Cntrl}/</tt> - Control character

-* <tt>/\p{Digit}/</tt> - Digit

-* <tt>/\p{Graph}/</tt> - Non-blank character (excludes spaces, control

- characters, and similar)

-* <tt>/\p{Lower}/</tt> - Lowercase alphabetical character

-* <tt>/\p{Print}/</tt> - Like <tt>\p{Graph}</tt>, but includes the space character

-* <tt>/\p{Punct}/</tt> - Punctuation character

-* <tt>/\p{Space}/</tt> - Whitespace character (<tt>[:blank:]</tt>, newline,

- carriage return, etc.)

-* <tt>/\p{Upper}/</tt> - Uppercase alphabetical

-* <tt>/\p{XDigit}/</tt> - Digit allowed in a hexadecimal number (i.e., 0-9a-fA-F)

-* <tt>/\p{Word}/</tt> - A member of one of the following Unicode general

- category Letter, Mark, Number,

- Connector\_Punctuation

-* <tt>/\p{ASCII}/</tt> - A character in the ASCII character set

-* <tt>/\p{Any}/</tt> - Any Unicode character (including unassigned

-* <tt>/\p{Assigned}/</tt> - An assigned character

-A Unicode character's General Category value can also be matched

-with <tt>\p{</tt>Ab<tt>}</tt> where Ab is the category's

-abbreviation as described below:

-* <tt>/\p{L}/</tt> - 'Letter'

-* <tt>/\p{Ll}/</tt> - 'Letter: Lowercase'

-* <tt>/\p{Lm}/</tt> - 'Letter: Mark'

-* <tt>/\p{Lo}/</tt> - 'Letter: Other'

-* <tt>/\p{Lt}/</tt> - 'Letter: Titlecase'

-* <tt>/\p{Lu}/</tt> - 'Letter: Uppercase

-* <tt>/\p{Lo}/</tt> - 'Letter: Other'

-* <tt>/\p{M}/</tt> - 'Mark'

-* <tt>/\p{Mn}/</tt> - 'Mark: Nonspacing'

-* <tt>/\p{Mc}/</tt> - 'Mark: Spacing Combining'

-* <tt>/\p{Me}/</tt> - 'Mark: Enclosing'

-* <tt>/\p{N}/</tt> - 'Number'

-* <tt>/\p{Nd}/</tt> - 'Number: Decimal Digit'

-* <tt>/\p{Nl}/</tt> - 'Number: Letter'

-* <tt>/\p{No}/</tt> - 'Number: Other'

-* <tt>/\p{P}/</tt> - 'Punctuation'

-* <tt>/\p{Pc}/</tt> - 'Punctuation: Connector'

-* <tt>/\p{Pd}/</tt> - 'Punctuation: Dash'

-* <tt>/\p{Ps}/</tt> - 'Punctuation: Open'

-* <tt>/\p{Pe}/</tt> - 'Punctuation: Close'

-* <tt>/\p{Pi}/</tt> - 'Punctuation: Initial Quote'

-* <tt>/\p{Pf}/</tt> - 'Punctuation: Final Quote'

-* <tt>/\p{Po}/</tt> - 'Punctuation: Other'

-* <tt>/\p{S}/</tt> - 'Symbol'

-* <tt>/\p{Sm}/</tt> - 'Symbol: Math'

-* <tt>/\p{Sc}/</tt> - 'Symbol: Currency'

-* <tt>/\p{Sk}/</tt> - 'Symbol: Modifier'

-* <tt>/\p{So}/</tt> - 'Symbol: Other'

-* <tt>/\p{Z}/</tt> - 'Separator'

-* <tt>/\p{Zs}/</tt> - 'Separator: Space'

-* <tt>/\p{Zl}/</tt> - 'Separator: Line'

-* <tt>/\p{Zp}/</tt> - 'Separator: Paragraph'

-* <tt>/\p{C}/</tt> - 'Other'

-* <tt>/\p{Cc}/</tt> - 'Other: Control'

-* <tt>/\p{Cf}/</tt> - 'Other: Format'

-* <tt>/\p{Cn}/</tt> - 'Other: Not Assigned'

-* <tt>/\p{Co}/</tt> - 'Other: Private Use'

-* <tt>/\p{Cs}/</tt> - 'Other: Surrogate'

-Lastly, <tt>\p{}</tt> matches a character's Unicode script. The

-following scripts are supported: Arabic, Armenian,

-Balinese, Bengali, Bopomofo, Braille,

-Buginese, Buhid, Canadian_Aboriginal, Carian,

-Cham, Cherokee, Common, Coptic,

-Cuneiform, Cypriot, Cyrillic, Deseret,

-Devanagari, Ethiopic, Georgian, Glagolitic,

-Gothic, Greek, Gujarati, Gurmukhi, Han,

-Hangul, Hanunoo, Hebrew, Hiragana,

-Inherited, Kannada, Katakana, Kayah_Li,

-Kharoshthi, Khmer, Lao, Latin, Lepcha,

-Limbu, Linear_B, Lycian, Lydian,

-Malayalam, Mongolian, Myanmar, New_Tai_Lue,

-Nko, Ogham, Ol_Chiki, Old_Italic,

-Old_Persian, Oriya, Osmanya, Phags_Pa,

-Phoenician, Rejang, Runic, Saurashtra,

-Shavian, Sinhala, Sundanese, Syloti_Nagri,

-Syriac, Tagalog, Tagbanwa, Tai_Le,

-Tamil, Telugu, Thaana, Thai, Tibetan,

-Tifinagh, Ugaritic, Vai, and Yi.

- # Unicode codepoint U+06E9 is named "ARABIC PLACE OF SAJDAH" and

- # belongs to the Arabic script.

- /\p{Arabic}/.match("\u06E9") #=> #<MatchData "\u06E9">

-All character properties can be inverted by prefixing their name with a

-caret (<tt>^</tt>).

- # Letter 'A' is not in the Unicode Ll (Letter; Lowercase) category, so

- # this match succeeds

- /\p{^Ll}/.match("A") #=> #<MatchData "A">

-Anchors are metacharacter that match the zero-width positions between

-characters, anchoring the match to a specific position.

-* <tt>^</tt> - Matches beginning of line

-* <tt>$</tt> - Matches end of line

-* <tt>\A</tt> - Matches beginning of string.

-* <tt>\Z</tt> - Matches end of string. If string ends with a newline,

- it matches just before newline

-* <tt>\z</tt> - Matches end of string

-* <tt>\G</tt> - Matches point where last match finished

-* <tt>\b</tt> - Matches word boundaries when outside brackets; backspace

- (0x08) inside brackets

-* <tt>\B</tt> - Matches non-word boundaries

-* <tt>(?=</tt>pat<tt>)</tt> - Positive lookahead assertion:

- ensures that the following characters match pat, but doesn't

- include those characters in the matched text

-* <tt>(?!</tt>pat<tt>)</tt> - Negative lookahead assertion:

- ensures that the following characters do not match pat, but

- doesn't include those characters in the matched text

-* <tt>(?<=</tt>pat<tt>)</tt> - Positive lookbehind

- assertion: ensures that the preceding characters match pat, but

- doesn't include those characters in the matched text

-* <tt>(?<!</tt>pat<tt>)</tt> - Negative lookbehind

- assertion: ensures that the preceding characters do not match

- pat, but doesn't include those characters in the matched text

- # If a pattern isn't anchored it can begin at any point in the string

- /real/.match("surrealist") #=> #<MatchData "real">

- # Anchoring the pattern to the beginning of the string forces the

- # match to start there. 'real' doesn't occur at the beginning of the

- # string, so now the match fails

- /\Areal/.match("surrealist") #=> nil

- # The match below fails because although 'Demand' contains 'and', the

- pattern does not occur at a word boundary.

- /\band/.match("Demand")

- # Whereas in the following example 'and' has been anchored to a

- # non-word boundary so instead of matching the first 'and' it matches

- # from the fourth letter of 'demand' instead

- /\Band.+/.match("Supply and demand curve") #=> #<MatchData "and curve">

- # The pattern below uses positive lookahead and positive lookbehind to

- # match text appearing in tags without including the tags in the

- /(?<=)\w+(?=<\/b>)/.match("Fortune favours the bold")

- #=> #<MatchData "bold">

-The end delimiter for a regexp can be followed by one or more single-letter

-options which control how the pattern can match.

-* <tt>/pat/i</tt> - Ignore case

-* <tt>/pat/m</tt> - Treat a newline as a character matched by <tt>.</tt>

-* <tt>/pat/x</tt> - Ignore whitespace and comments in the pattern

-* <tt>/pat/o</tt> - Perform <tt>#{}</tt> interpolation only once

-<tt>i</tt>, <tt>m</tt>, and <tt>x</tt> can also be applied on the

-subexpression level with the

-<tt>(?</tt>on<tt>-</tt>off<tt>)</tt> construct, which

-enables options on, and disables options off for the

-expression enclosed by the parentheses.

- /a(?i:b)c/.match('aBc') #=> #<MatchData "aBc">

- /a(?i:b)c/.match('abc') #=> #<MatchData "abc">

-== Free-Spacing Mode and Comments

-As mentioned above, the <tt>x</tt> option enables free-spacing

-mode. Literal white space inside the pattern is ignored, and the

-octothorpe (<tt>#</tt>) character introduces a comment until the end of

-the line. This allows the components of the pattern to be organised in a

-potentially more readable fashion.

- # A contrived pattern to match a number with optional decimal places

- [[:digit:]]+ # 1 or more digits before the decimal point

- (\. # Decimal point

- [[:digit:]]+ # 1 or more digits after the decimal point

- )? # The decimal point and following digits are optional

- float_pat.match('3.14') #=> #<MatchData "3.14" 1:".14">

-*Note*: To match whitespace in an <tt>x</tt> pattern use an escape such as

-<tt>\s</tt> or <tt>\p{Space}</tt>.

-Comments can be included in a non-<tt>x</tt> pattern with the

-<tt>(?#</tt>comment<tt>)</tt> construct, where comment is

-arbitrary text ignored by the regexp engine.

-Regular expressions are assumed to use the source encoding. This can be

-overridden with one of the following modifiers.

-* <tt>/</tt>pat<tt>/u</tt> - UTF-8

-* <tt>/</tt>pat<tt>/e</tt> - EUC-JP

-* <tt>/</tt>pat<tt>/s</tt> - Windows-31J

-* <tt>/</tt>pat<tt>/n</tt> - ASCII-8BIT

-A regexp can be matched against a string when they either share an

-encoding, or the regexp's encoding is _US-ASCII_ and the string's encoding

-is ASCII-compatible.

-If a match between incompatible encodings is attempted an

-<tt>Encoding::CompatibilityError</tt> exception is raised.

-The <tt>Regexp#fixed_encoding?</tt> predicate indicates whether the regexp

-has a fixed encoding, that is one incompatible with ASCII. A

-regexp's encoding can be explicitly fixed by supplying

-<tt>Regexp::FIXEDENCODING</tt> as the second argument of

-<tt>Regexp.new</tt>:

- r = Regexp.new("a".force_encoding("iso-8859-1"),Regexp::FIXEDENCODING)

- #=> Encoding::CompatibilityError: incompatible encoding regexp match

- (ISO-8859-1 regexp with UTF-8 string)

-Certain pathological combinations of constructs can lead to abysmally bad

-Consider a string of 25 as, a d, 4 as, and a

- s = 'a' * 25 + 'd' 'a' * 4 + 'c'

- #=> "aaaaaaaaaaaaaaaaaaaaaaaaadadadadac"

-The following patterns match instantly as you would expect:

- /(b|a)/ =~ s #=> 0

- /(b|a+)/ =~ s #=> 0

- /(b|a+)*\/ =~ s #=> 0

-However, the following pattern takes appreciably longer:

- /(b|a+)*c/ =~ s #=> 32

-This happens because an atom in the regexp is quantified by both an

-immediate <tt>+</tt> and an enclosing <tt>*</tt> with nothing to

-differentiate which is in control of any particular character. The

-nondeterminism that results produces super-linear performance. (Consult

-Mastering Regular Expressions (3rd ed.), pp 222, by

-Jeffery Friedl, for an in-depth analysis). This particular case

-can be fixed by use of atomic grouping, which prevents the unnecessary

- (start = Time.now) && /(b|a+)*c/ =~ s && (Time.now - start)

- (start = Time.now) && /(?>b|a+)*c/ =~ s && (Time.now - start)

-A similar case is typified by the following example, which takes

-approximately 60 seconds to execute for me:

- # Match a string of 29 as against a pattern of 29 optional

- # as followed by 29 mandatory as.

- Regexp.new('a?' * 29 + 'a' * 29) =~ 'a' * 29

-The 29 optional as match the string, but this prevents the 29

-mandatory as that follow from matching. Ruby must then backtrack

-repeatedly so as to satisfy as many of the optional matches as it can

-while still matching the mandatory 29. It is plain to us that none of the

-optional matches can succeed, but this fact unfortunately eludes Ruby.

-One approach for improving performance is to anchor the match to the

-beginning of the string, thus significantly reducing the amount of

-backtracking needed.

- Regexp.new('\A' 'a?' * 29 + 'a' * 29).match('a' * 29)

- #=> #<MatchData "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa">

-# -*- coding: utf-8 -*-

-2010-02-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: 1.3.6.

- * test/*: Windows test fixes

- * lib/rubygems/remote_fetcher.rb: Fix same file detection on windows.

-2010-02-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/config_file.rb: Fix use of ConfigFile#api_key= vs

- #rubygems_api_key=. Patch by Nick Quaranto.

-2010-02-12 Eric Hodel <drbrain@segment7.net>

- * Rakefile: RubyGems doesn't depend on previous RubyGems.

-2010-02-11 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: http://rubygems.org is now the default source.

- * lib/rubygems/dependency.rb: Only warn once about

- #version_requirement

-2010-02-09 Eric Hodel <drbrain@segment7.net>

- * bin/update_rubygems: Use system, exec more correctly, remove

- * lib/rubygems/commands/query_command.rb: List every version when

- --prerelease --all is given.

-2010-02-08 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/dependency_command.rb: Support --prerelease.

- * lib/rubygems/commands/fetch_command.rb: Support --prerelease.

- * lib/rubygems/format.rb: Don't crash on empty files. Bug #27292 by

- * lib/rubygems/server.rb: Fix markup. Bug #27045 by Eric Young.

- * History.txt: RubyGems 1.3.6 release notes.

-2010-02-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Allow prerelease gems to

- depend on non-prerelease gems.

-2010-02-06 Eric Hodel <drbrain@segment7.net>

- * test/test_gem_commands_specification_command.rb: Don't enforce YAML

- format. Patch #27791 by Aaron Patterson.

- * lib/rubygems/version.rb: Allow captial letters in prerelease

- * lib/rubygems/config_file.rb: Explain format of ~/.gemrc. Bug

- #27698 by J Smith.

- * lib/rubygems/gem_path_searcher.rb: Handle nil require_paths.

- Patch #27334 by Roger Pack.

- * lib/rubygems/server.rb: Handle --bind option. Patch #27357 by

- * lib/rubygems/doc_manager: gem rdoc --overwrite to preserve built

- rdoc. Patch #25982 by Akinori MUSHA.

- * lib/rubygems/commands/which_command.rb: Fail if no paths were

- found. Adapted patch #27681 by Caio Chassot.

- * lib/rubygems/remote_fetcher.rb: Don't copy if the file is where we

- want it. Patch #27409 by Jakub Šťastný.

-2010-02-01 John Barnette <jbarnette@rubygems.org>

- * lib/rubygems/command*: Add 'gem push' and 'gem owner' for

- interacting with modern/Gemcutter sources [Nick Quaranto]

-2010-01-18 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_list.rb: Ignore development dependencies

- unless explicitly needed. Bug #27608 by Roger Pack.

-2010-01-12 John Barnette <jbarnette@rubygems.org>

- * Rakefile: Don't add development deps when building the

- rubygems-update gem, it borks older versions when they're updating

- from a stub index.

-2009-12-22 Evan Phoenix <evan@fallingsnow.net>

- * lib/rubygems/spec_fetcher.rb: Don't bother re-Marshaling the spec

-2009-11-04 John Barnette <jbarnette@rubygems.org>

- * lib/rubygems/timer.rb: Removed. The deprecation sun set in July.

-2009-10-14 John Barnette <jbarnette@rubygems.org>

- * lib/rubygems/dependency.rb: Burndown/cleanup. Refactored code

- and tests. Gem::Dependency.version_requirement(s) is deprecated in

- favor of Gem::Dependency.requirement.

- * lib/rubygems/requirement.rb: Burndown/cleanup. Refactored code

- and tests. See test/support/shortcuts.rb for some new test helpers.

-2009-10-13 John Barnette <jbarnette@rubygems.org>

- * lib/rubygems/local_remote_options.rb: Make --source additive,

- not exclusive. If exclusive sources are desired, use

- --clear-sources first.

-2009-09-29 John Barnette <jbarnette@rubyforge.org>

- * lib/rubygems/spec_fetcher.rb: Be slightly more robust when faced

- with corrupted indexes.

-2009-09-03 John Barnette <jbarnette@rubyforge.org>

- * LOTS: Use "raise" consistently, not "fail".

-2009-09-01 John Barnette <jbarnette@rubyforge.org>

- * lib/rubygems/version.rb: Gem::Version immutability

- burndown. Changed canonical internal representation to an

- Array. Refactored significant amounts of the internals for

- clarity. Breaking change: Gem::Version::Requirement is no longer

- available, use Gem::Requirement instead. Breaking change: custom

- YAML marshaling is gone. Credit to Yehuda Katz for certain bits of

- * test/test_gem_dependency.rb: Moved a bunch of tests over from

- test_gem_version.rb. Work in progress.

- * test/test_gem_specification.rb: Removed a failing YAML

- test. Many more will be going away shortly.

- * test/test_gem_version.rb: Significant refactoring for

- maintainability and clarity. Moved a ton of poorly-placed tests to

- test_gem_dependency.rb for future refactoring.

-2009-08-19 Ryan Davis <ryand-ruby@zenspider.com>

- * lib/rubygems.rb: Cleanup of rdoc and file layout.

- * lib/rubygems/versions.rb: Added Version#spermy_recommendation

- and fixed bug in Version::Part#inspect. General cleanup.

-2009-07-29 John Barnette <jbarnette@rubyforge.org>

- * lib/rubygems/package/tar_input.rb: Add Maglev to the list of

- implementations with working Zlib. Bug #26790 by Peter McLain.

-2009-07-21 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: 1.3.5.

- * lib/rubygems/package.rb: Remove dangling digest require. Reported

-2009-06-25 Eric Hodel <drbrain@segment7.net>

- * release_notes/: Merged into History.txt for Hoe.

- * lib/rubygems/commands/setup_command.rb: Streamlined install text.

-2009-06-23 Eric Hodel <drbrain@segment7.net>

- * release_notes/rel_1_3_5.rdoc: RubyGems 1.3.5 release notes.

- * lib/rubygems/builder.rb: Only print out with verbose.

- * lib/rubygems/package_task.rb: Only print out with -t.

-2009-06-12 Ryan Davis <ryand@zenspider.com>

- * Rakefile: Switched to Hoe.

-2009-06-10 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems/installer.rb: --user-install is no longer enabled by

- * lib/rubygems/source_index.rb: Fix use of prerelease gems.

-2009-06-04 Eric Hodel <drbrain@segment7.net>

- * util/gem_prelude.rb.template: Backports from 1.9.

-2009-06-03 Eric Hodel <drbrain@segment7.net>

- * bin/gem: Support 1.8.6+

- * lib/rubygems/digest*: Removed, support dropped for Ruby < 1.8.6

- * lib/rubygems/installer.rb: Support env(1) in wrong path, use

- /bin/sh if shebang has options. By Nobu, ruby trunk r22853.

- * lib/rubygems/config_file.rb: Switch to stdcall for appdata folder.

- [ruby-core:22601].

- * lib/rubygems.rb: Use only File::expand_path on 1.9 for home dir.

- Don't recklessly create directories. Simplify RbConfig::datadir

-2009-05-30 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/which_command.rb: Only print out directory

- information to a TTY.

- * lib/rubygems/rubygems_version.rb: 1.3.4.

- * doc/release_notes/rel_1_3_4.rdoc: RubyGems 1.3.4 release notes.

-2009-05-28 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/setup_command.rb: Fix --format-executable

- * lib/rubygems/requirement.rb: Fix typo in #parse. Bug #26000 by

-2009-05-21 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Add 'dev' and svn revision for -1 RUBY_PATCHLEVEL

- and RUBY_REVISION.

-2009-05-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/defaults.rb: Restore 1.9.1 path behavior.

- * lib/rubygems/specification.rb: Fix undefined ivar warning.

- * lib/rubygems/indexer.rb: Force loading of builder gem.

- * test/gemutilities.rb: Remove gem_prelude code by hand to avoid 1.9

-2009-05-19 Luis Lavena <luislavena@gmail.com>

- * test/test_gem_specification.rb: skip symlinks tests on Windows.

- * test/test_gem_commands_install_command.rb: skip chmod test on

-2009-05-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems*: Fix 1.9 warnings about circular require.

-2009-05-12 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/remote_fetcher.rb: Fixed the download method in the

- remote_fetcher.rb file so that it handles local installs on MS

- Windows when using explicit paths that aren't on the 'C:' drive.

- Bug #25882 by Lars Christensen.

- * lib/rubygems/commands/update_command.rb: Replaced deprecated

- Gem::SourceIndex method 'search' with 'find_name' in the 'execute'

-2009-05-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/query_command.rb: Support prerelease version

- listing (--prerelease), list locally installed prereleases.

- * lib/rubygems/source_info_cache.rb: Gem::SourceInfoCache is

- officially unsupported, maintaining its tests is hard.

- * lib/rubygems/source_index.rb: Add #all_gems, fix #remove_spec,

- #search to work with it. Prerelease gems can now be used.

-2009-05-04 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb: 1.3.3.

- * doc/release_notes/rel_1_3_3.rdoc: RubyGems 1.3.3 release notes.

- * lib/rubygems/specification.rb: Default has_rdoc to true, ignore

- * lib/rubygems/doc_manager.rb: Always generate RDoc regardless of

- * lib/rubygems.rb: Raise Gem::LoadError if Kernel#gem fails due to

- previously-loaded gem. Bug reported by Alf Mikula.

-2009-05-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/server_command.rb: Allow port names with

- * lib/rubygems/requirement.rb: Match prerelease versions and ~>

- correctly. Patch #25759 by Yossef Mendelssohn.

-2009-05-01 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Check bindir for executables, not

- root. Bug reported by David Chelimsky. Remove Time.today, no way

- to override it before RubyGems loads. Bug #25564 by Emanuele

- Vicentini. Raise Gem::Exception for #installation_path when not

- installed. Bug #25741 by Daniel Berger. Don't error in #validate

- when homepage is nil. Bug #25677 by Mike Burrows.

- * lib/rubygems/commands/cleanup_command.rb: Clean up --user-install

- gems. Bug #25516 by Brett Eisenberg.

- * lib/rubygems/uninstaller.rb: Uninstall executables from the correct

- directory. Bug #25555 by Brett Eisenberg.

- * lib/rubygems/server.rb: Add search that jumps to RDoc. Patch

- #22959 by Vladimir Dobriakov.

-2009-05-01 James Tucker <jftucker@gmail.com>

- * lib/rubygems.rb: Gem.bin_path now escapes paths with spaces.

-2009-04-30 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/commands/install_command.rb: Replaced deprecated

- Gem::SourceIndex method 'search' with 'find_name' when using

- the -t option. Fixes bug # 25632 by Daniel Berger.

-2009-04-30 James Tucker <jftucker@gmail.com>

- * lib/rubygems/ext/rake_builder.rb: Use explicit ruby command loading

- rubygems to invoke rake.

-2009-04-24 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/specification_command.rb: Added requesting

- single fields from a spec.

-2009-04-23 James Tucker <jftucker@gmail.com>

- * lib/rubygems/ext/configure_builder.rb: Support Gem::Command.build_args.

-2009-04-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb: 1.3.2.

-2009-04-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Complain when summary and

- description are identical.

-2009-04-08 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Strip directories, complain for

- non-files in #validate.

-2009-04-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Implement #initialize_copy.

- * lib/rubygems/commands/contents_command.rb: Add --no-prefix and

-2009-04-06 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/defaults.rb: Don't allow gem to overwrite ruby on

- install. Fixes bug #24958 by Michael Soulier.

- * doc/release_notes/rel_1_3_2.rdoc: Preliminary 1.3.2 release notes.

- * Rakefile: Trim off some stale code, switch to Manifest.txt, one

- step closer to Hoe!

-2009-04-06 Daniel Berger <djberg96@gmail.com>

- * test/test_gem_ext_configure_builder.rb: Better handling for MS

- * test/gemutilities.rb: Added the make_command and vc_windows? helper

-2009-04-03 Eric Hodel <drbrain@segment7.net>

- * lib/: RDoc improvements.

-2009-04-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/setup_command.rb: Fix --destdir. Patch

- #24970 by Richard Brown.

-2009-04-02 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems/version.rb: Documentation of prerelease

- versions. See http://technomancy.us/123 for details.

-2009-03-31 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/spec_fetcher.rb: If the cached specs file won't load,

- refetch. Bug #24961 by Dylan Stamat.

- * lib/rubygems/defaults.rb: Add a sanity check to

- Gem.default_exec_format. Workaround for bug #24958 by Michael

- * lib/rubygems/commands/setup_command.rb: Fix confusion with option

- names. Patch #24971 by Richard Brown.

- * lib/rubygems/specification.rb: Make #validate complain about

- * lib/gauntlet_rubygems.rb: For verification of the validator.

-2009-03-27 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: RubyGems now loads plugins from rubygems_plugin.rb

- in installed gems. This can be used to add commands (See

- Gem::CommandManager) or add install/uninstall hooks (See

- Gem::Installer and Gem::Uninstaller).

- * setup.rb: Ensure we're in a RubyGems dir when installing.

-2009-03-26 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/package_task.rb: Import from Rake's

- rake/gempackagetask.rb

- * Rakefile: Switched to RDoc::Task from RDoc 2.4.2.

- * lib/rubygems.rb: Gem.find_files now returns paths in $LOAD_PATH.

- * lib/rubygems/commands/sources_command.rb: Allow sources to be added

- behind proxies. Bug #24785 by Elia Schito.

-2009-03-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/install_command.rb: Fix typo. Patch #24446

- by Luis Parravicini.

- * lib/rubygems/version.rb: Handle non-String versions by calling

- #to_s. Patch #24392 by Stephen Bannasch.

-2009-03-22 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/remote_fetcher.rb: Always escape URI's to deal with spaces

- and such, regardless of platform.

- * lib/rubygesm/validator.rb: Use the test-unit gem if installed.

- Part of the fix for RF #24261 by Daniel Berger

- * lib/rubygems/commands/install_command.rb: Explictly require

- rubygems/uninstaller.rb if the user wants to bail because of failed

- Part of the fix for RF #24261 by Daniel Berger

-2009-03-17 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/query_command.rb: Make `gem unpack` work with

- more than one gem name, fix warning about installation location.

-2009-03-16 James Tucker <jftucker@gmail.com>

- * lib/rubygems.rb: Deprecate ConfigMap[:RUBY_INSTALL_NAME]

- * lib/rubygems/defaults.rb: Gem.default_exec_format to use

- ConfigMap[:ruby_install_name].

- * util/gem_prelude.rb.template: Fix potential bug in

- Gem.default_exec_format when ConfigMap[:BASERUBY] is not 'ruby'.

-2009-03-14 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems/installer.rb: Cleanup quotes on Windows stub scripts.

- * lib/rubygems/commands/setup_command.rb: ditto.

-2008-03-13 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/uninstall_command.rb: Add --user-install to

- allow uninstallation from ~/.gem. Bug #23760 by Roger Pack.

- * lib/rubygems/uninstaller.rb: Automatically uninstall from

- * lib/rubygems/commands/update_command.rb: Rescue InstallError

- and continue. Bug #19268 by Gabriel Wilkins.

- * lib/rubygems/doc_manager.rb: Remove some options from the args list

- that RDoc no longer supports.

-2008-03-12 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: #description no longer removes

- * lib/rubygems/indexer.rb: Wrap description in a pre and force-wrap

- lines to 78 characters for prettier display.

- * lib/rubygems/commands/setup_command.rb: Clarify RubyGems RDoc

- installation location. Bug #22656 by Gian Marco Gherardi.

-2008-03-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/query_command.rb: Add platforms to gem list

- * lib/rubygems/commands/setup_command.rb: Allow setup to run from

- read-only location. Patch #21862 by Luis Herrera.

- * lib/rubygems/package/tar_input.rb: Use real File methods. Bug

- #23966 by Mike Furr.

- * lib/rubygems.rb: Don't add PATCHLEVEL if it's -1. Patch #24048 by

- * lib/rubygems/package/tar_input.rb: Choose security policy

- correctly. Bug #24001 by Mike Furr.

- * lib/rubygems/remote_fetcher.rb: Handle local paths with spaces.

- Bug #24169 by Ryan Davis.

- * lib/rubygems/specification.rb: Removed Gem::Specification::list,

- causes leaks. Bug #23668 by Steve Purcell.

-2008-03-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Use Gem::bin_path in executable stubs to

- work around Kernel#load bug.

- * lib/rubygems/commands/install_command.rb: Copy user_install down to

- Gem::DependencyInstaller. Patch #23573 by Alf Mikula.

- * lib/rubygems/command.rb: Add info on gem server directly to `gem

- help`. Patch #22271 by Hugh Sasse.

-2008-03-06 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Don't allow FIXME in specs.

- * lib/rubygems/commands/spec_command.rb: Add --ruby and --marshal

- * lib/rubygems.rb: Add Gem::bin_path. Patch #24114 by James Tucker.

-2008-03-04 Eric Hodel <drbrain@segment7.net>

- * setup.rb: Moved guts to lib/rubygems/commands/setup_command.rb.

- * lib/rubygems/indexer.rb: Added RSS feed generation on full index

-2008-03-04 Phil Hagelberg <technomancy@gmail.com>

- * lib/*: Prerelease gems go into their own index now and are excluded

- from other indices. InstallCommand only gets prereleases if explicitly

- requested. Thanks to Alex Vollmer.

-2008-03-04 Eric Hodel <drbrain@segment7.net>

- * lib/*: Add lots of pretty pretty_print stuff!

-2008-02-25 Ryan Davis <ryand@zenspider.com>

- * lib/rubygems/commands/check_command.rb: Fix various usability

-2009-02-10 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/specification: Refactored and fixed the installation_path

- method. It was overwrought and it now no longer uses File::SEPARATOR

- [RubyForge: bug #23879 by Daniel Berger]

-2009-02-10 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/validator.rb: The Gem::Validator#verify_gem_file method

- now explicitly rescues Errno::EINVAL as well as Errno::ENOENT because

- MS Windows raises a different SystemCallError for empty paths.

-2009-01-21 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/remote_fetcher.rb: Split out nil and file handling in

- the download method. Modified file URI handling to work properly.

- [RubyForge: bug #16495 by Paul Sadauskas]

-2009-01-19 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/remote_fetcher.rb: Added uri scheme validation back

- into the open_uri_or_path method, though it now accepts 'https' and

- * test/test_gem_remote_fetcher.rb: Updated the test_fetch_size_bad_uri

- to reflect the updated error message.

-2009-01-15 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/remote_fetcher.rb: Removed the open_file_uri_path method

- since the URI#path method already does the same thing, and changed

- the file_uri? method so that it explicitly calls .to_s.

- * lib/rubygems/local_remote_options.rb: Allow file urls.

-2009-01-15 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/commands/generate_index_command.rb: Fixed a typo in

- * test/test_gem_doc_manager.rb: The test_uninstall_doc_unwritable

- test is now skipped on Windows.

- * test/test_gem_install_update_options.rb: The

- test_user_install_disabled_read_only test is now skipped on Windows.

- * test/test_gem_installer.rb: The test_generate_bin_symlink_no_perms

- and test_generate_bin_script_no_perms tests are now skipped on Windows.

-2009-01-14 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/specification.rb: Added support for a license attribute.

- [RubyForge: feature #11041 (partial) by Kevin Williams]

- * lib/rubygems/commands/query_command.rb: Gem detail information now

- includes license information.

- * test/test_gem_specification.rb: Added tests for the license attribute.

-2009-01-05 Chad Woolley <thewoolleyman@gmail.com>

- * move processing of build args out of gem binary so they are handled correctly via API usage.

- * lib/rubygems/command.rb: Add class accessor for build_args.

- * lib/rubygems/ext/rake_builder.rb: Use Gem::Command.build_args instead of ARGV.

- * lib/rubygems/ext/ext_conf_builder.rb: Use Gem::Command.build_args instead of ARGV.

- * lib/rubygems/gem_runner.rb: Move build arg processing from gem binary.

- * lib/rubygems/commands/contents_command.rb: Use nonzero return code (required to make tests pass).

- * bin/gem: Move build arg processing to gem_runner.rb.

- [RubyForge: bug #23210]

- * lib/rubygems/config_file.rb: Fix --config-file option with no

- equals and subsequent options to properly assign config file.

- Previously config file was overwritten by subsequent option.

-2009-1-4 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/installer.rb: Remove existing path if it already

- exists before installing.

- [RubyForge: patch #22837 by Eric Wong]

- * lib/rubygems.rb: Minor modification to the location_of_caller

- method - deal with possible characters after line number

-2009-1-3 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems.rb: Better activation error message.

- [RubyForge: patch #23082 by Tim Carey-Smith]

-2009-1-2 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/ext/rake_builder.rb: Quote path if it contains spaces

- [RubyForge: patch #23003 by Charlie Savage]

- * lib/rubygems/local_remote_options.rb: Ignore duplicate sources

- [RubyForge: bug #22277 by Elliot Temple]

- * lib/rubygems/remote_fetcher.rb: Automatically normalize the URI

- [RubyForge: bug #22151 by Alex Legler]

- * lib/rubygems/specification.rb: Ensure that specification_version is

- a Fixnum [RubyForge: bug #22598 by Tsutomu Kuroda]

- * lib/rubygems/specification.rb: Bumped the CURRENT_SPECIFICATION_VERSION

- and added an entry to the SPECIFICATION_VERSION_HISTORY

-2009-1-1 Daniel Berger <djberg96@gmail.com>

- * test/test_gem_dependency.rb: Removed a duplicate "def dep" that

- was causing a warning.

- * lib/rubygems/platform.rb: Added an empty? method in order to

- better handle gem indexing when dealing with gems created

- prior to 0.9.5. [Rubyforge: bug #22603 by Johnathan Conley]

- * lib/rubygems.rb: Added an explicit 'require "etc"'.

- [RubyForge: bug #22313 by Matthew Boedicker]

-2008-12-31 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/local_remote_options: Allow 'https' as a valid scheme

- in addition to 'http' [RubyForge: patch #22485 by Duarte Henriques]

- * setup.rb: Deal with extraneous quotation mark when autogenerating

- .bat file on MS Windows [RubyForge: bug #22712 Takayuki Ishikawa]

- * lib/rubygems/commands/unpack_command.rb: Fixed the --target option

- [RubyForge: patch #22532 by Bryan Ash]

-2008-12-30 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/builder.rb: Don't allow .gem file to be added back

- onto itself [RubyForge: bug #19136, patch #23346 by Daniel Berger]

- * lib/rubygems/defaults.rb: The default_path now only returns the

- default_dir if the Gem.user_home doesn't exist

- [RubyForge: bug #23037 by Pierre PLR]

- * lib/rubygems.rb: Handle the possibility that Etc.getpwuid might

- return nil on platforms other than Windows

- [RubyForge: bug #22764 by Dudley Flanders]

-2008-12-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/doc_manager.rb: Set title for generated documentation.

- * lib/rubygems/dependency.rb: Make #=~ work with Gem::Specification.

-2008-12-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Fix documentation for

- Gem::Installer#write_spec. Issue by okkez.

-2008-12-12 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/local_remote_options.rb: Merge documentation fix by

- okkez [ruby-dev:37271].

- * lib/rubygems/source_info_cache_entry.rb: Merge documentation fix

- from [ruby-dev:37255].

-2008-12-08 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Add Gem::promote_load_path

-2008-12-01 Ryan Davis <ryand-ruby@zenspider.com>

- * lib/rubygems/remote_fetcher.rb: made threadsafe.

-2008-11-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/install_command.rb: Don't do any post-install

- stuff if no gems were installed. Issue by Daniel Berger.

-2008-11-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Read the file outside the exception

- block so we raise a sane error.

- * lib/rubygems/indexer.rb: Allow the modern index to be updated

- incrementally. Allow the legacy and modern indicies to be updated

-2008-11-17 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Added ability to only generate modern or

-2008-11-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/timer.rb: Deprecate and move methods to Gem and

-2008-11-11 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems/, test/: Make Version understand prerelease

- versions using letters. (eg. '1.2.1.b') Thanks to Josh Susser and

-2008-11-03 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Gem name must be a String.

-2008-10-31 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/defaults.rb: Update to support 1.9 libdir.

- * util/gem_prelude.rb: Move to .template, automatically fold in

-2008-10-29 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Handle nonexistent home directory. Bug #22229 by

- Alexey Verkhovsky.

-2008-10-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb, lib/rubygems/custom_require.rb: Make kernel

- methods private. Patch #20801 by James M. Lawrence. Expose

- our kernel extensions to RDoc. Make Gem::location_of_caller behave on

- Windows. Patch by Daniel Berger.

- * doc/release_notes/rel_1_3_1.rdoc: Final release notes for 1.3.1.

- * lib/rubygems/rubygems_version.rb: 1.3.1.

-2008-10-10 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/unpack_command.rb: Silence PATH warning.

-2008-10-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Fix requires for inflate, deflate, etc.

- * test/*: Convert to minitest/unit.

- * lib/rubygems/validator.rb: Fix for MiniTest instead of test/unit

-2008-10-03 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems.rb: Make Gem.dir respect :gemhome value from config.

- * lib/rubygems/config_file.rb: Expose :gemhome value.

-2008-09-26 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems.rb: Disregard ownership of ~ under Windows while

- creating ~/.gem. Fixes issues related to no uid support under

-2008-09-24 Eric Hodel <drbrain@segment7.net>

- * doc/release_notes/rel_1_3_0.rdoc: Final release notes for 1.3.0.

- * lib/rubygems/rubygems_version.rb: 1.3.0.

- * lib/rubygems/builder.rb: Examine process status correctly. Patch

- * test/test_gem_ext_rake_builder.rb: Override Gem.ruby and

- ENV['rake'] for 1.9 integration. Patch by Nobu.

-2008-09-16 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems.rb: Use the path set in the config file if

- * lib/rubygems/config_file.rb: Expose the path.

-2008-09-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Only create ~/.gem by user owning ~. Bug #21561

-2008-09-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Autoload SpecFetcher to improve load

- time. Patch #21577 by Simon Chiang.

- * lib/rubygems/commands/lock_command.rb: Modernize. Fix --strict.

- Patch #21814 by Sven Engelhardt.

- * lib/rubygems/platform.rb: Fix for solaris platform. Patch #21911

-2008-09-10 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/install_command.rb: Describe _version_ in `gem

- * lib/rubygems/commands/environment_command.rb: Describe environment

- variables and gemrc in `gem help env`.

- * lib/rubygems.rb: Warn when executing Gem::manage_gems.

- * lib/rubygems/doc_manager.rb: Have RubyGems update the ri cache.

- * lib/rubygems/source_index.rb: Ensure specs are read as UTF-8.

- * lib/rubygems/specification.rb: Add magic comment to .gemspec files

- so they are read in as UTF-8.

-2008-08-22 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems.rb: Corrected usage of HOMEDRIVE and HOMEPATH on Windows.

- Escape Gem.ruby if spaces in the path are present. Solves bug related to

- extensions compile process.

- * test/test_gem.rb: Added test to verify both conditions.

-2008-08-17 Eric Hodel <drbrain@segment7.net>

- * doc/release_notes/rel_1_3_0.rdoc: Initial release notes for 1.3.0.

- * util/CL2notes: Release note creation helper script.

-2008-08-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/local_remote_options.rb: Added #both? to complement

- #local? and #remote?.

- * lib/rubygems/commands/query_command.rb: Print out LOCAL/REMOTE with

- --both, even without a TTY.

- * lib/rubygems.rb: Add Gem.find_files, allows a gem to discover

- features provided by other gems.

-2008-08-14 Wilson Bilkovich <wilson@supremetyrant.com>

- * lib/rubygems/source_index.rb: Deprecate options to 'search' other than

- Gem::Dependency instances and issue warning until November 2008.

- * lib/rubygems/platform.rb: Remove deprecated constant warnings

- and really deprecate them.

- * Rakefile: If the SETUP_OPTIONS environment variable is set, pass its

- contents as arguments to setup.rb

- * test/test_gem_commands_uninstall_command.rb: Added

-2008-08-13 Wilson Bilkovich <wilson@supremetyrant.com>

- * lib/rubygems/uninstaller.rb: Fix binary script uninstallation.

- Bug #21234 by Neil Wilson.

- * test/test_gem_commands_uninstall_command.rb: Added

-2008-08-12 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Try to create directory before diverting

- * lib/rubygems/uninstaller.rb: Fix uninstallation with -i. Bug

- #20812 by John Clayton. Have #remove_all call #uninstall_gem so hooks

- get called. Bug #21242 by Neil Wilson.

- * lib/rubygems/commands/update_command.rb: Fix updating RubyGems when

- no previous rubygems-update is installed. Bug #20775 by Hemant Kumar.

-2008-08-11 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Fix HTTPS support. Patch #21072 by

- Alex Arnell. Fix Not Modified handling. Bug #21310 by Gordon

-2008-07-11 Luis Lavena <luislavena@gmail.com>

- * setup.rb: Properly build --destdir folder structure using Pathname.

- * test/mockgemui.rb: Fix warnings about instance variables in a module.

-2008-07-02 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems/defaults.rb: Add Gem.user_dir to use paths like

- ~/.gem/ruby/1.8/gems and the like instead of just ~/.gem. Update

- remote fetcher and installer to use it.

-2008-07-01 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Add #gem_home, #bin_dir for hooks. Use

- DependencyInstaller's source_index so reinstallation via -i does not

- * lib/rubygems/uninstaller.rb: Add #gem_home, #bin_dir for hooks.

- * lib/rubygems/commands/query_command.rb: Don't print LOCAL/REMOTE

- gems if stdout is not a TTY.

- * lib/rubygems/commands/query_command.rb: Use the regexp we already

- have for `gem list --installed`. Bug #20876 by Nick Hoffman.

- * lib/rubygems/commands/which_command.rb: Clarify what `gem which` is

-2008-06-30 Eric Hodel <drbrain@segment7.net>

- * test/test_ext_configure_builder.rb: Locale-free patch by Yusuke

- Endoh [ruby-core:17444].

- * lib/rubygems.rb: Add pre/post (un)install hooks.

- * lib/rubygems/installer.rb: Call pre/post install hooks as

- * lib/rubygems/uninstaller.rb: Call pre/post uninstall hooks as

- appropriate. Minor refactoring of #uninstall.

- * lib/rubygems/package/tar_reader.rb: Some OSs raise EINVAL on seek.

- Based on patch in bug #20791 by Neil Wilson.

- * lib/rubygems/specification.rb: Correctly check for support of

- development dependencies for #to_ruby. Bug #20778 by Evan Weaver.

- * lib/rubygems/spec_fetcher.rb: Correctly load all cache file even if

- latest has been loaded. Bug #20776 by Uwe Kubosch.

-2008-06-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/config_file.rb: Add Gem::ConfigFile constants for

- packagers and implementors to override defaults.

- * test/*: Fixes to run tests when under test/rubygems/. Patch by

- Yusuke ENDOH [ruby-core:17353].

-2008-06-24 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Cleanup to support

- if-modified-since requests. pair: Ryan Davis

- * lib/rubygems/indexer: Force platform to Gem::Platform::RUBY when

- nil or blank. Fixes various uninstallable gems.

-2008-06-24 Phil Hagelberg <technomancy@gmail.com>

- * lib/rubygems/installer.rb: Fall back on ~/.gem if GEM_HOME is

- * lib/rubygems/install_update_options.rb: Allow --user-install or

- --no-user-install command-line switch to explicitly force whether

- or not ~/.gem should be used.

- * lib/rubygems/remote_fetcher.rb: Use ~/.gem/cache if cache dir is

- * test/gemutilities.rb: Use MockGemUi for all tests.

-2008-06-21 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Load specifications from the future.

- Roll back specification version change.

- * lib/rubygems/remote_fetcher.rb: Reset connection when an HTTP

- server misbehaves.

- * setup.rb: Fix --destdir for windows.

- * doc/release_notes/rel_1_2_0.rdoc: Bugs in RubyGems were

- unintentionally added, order bug fixes by importance.

- * lib/rubygems/rubygems_version.rb: 1.2.0.

-2008-06-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/uninstaller.rb: Improve output when a gem to uninstall

- isn't found. Bug #20746 reported by Chad Wooley.

- * setup.rb: Fix rdoc installation with --destdir. Patch #20739 by

- * lib/rubygems/commands/install_command.rb: Don't reset GEM_PATH when

- installing. Fixes Bug #20746 by Chad Wooley.

-2008-06-20 Luis Lavena <luislavena@gmail.com>

- * setup.rb: Only prepend install_destdir when especified. Fixes

- installation issues related to Windows paths (/C:/...)

-2008-06-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Ensure that the entire

- dependency chain is installed. Fixes bug reported by Chad Woolley.

-2008-06-18 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/dependency_command.rb: Restore matching

- everything when no name is specified, regexp matching. Fixes bug

- #20716, bug #20717 by Chad Woolley.

-2008-06-18 Chad Woolley <thewoolleyman@gmail.com>

- * lib/rubygems/config_file.rb: Fix --config-file option with no

- equals and subsequent options to properly assign config file.

- Previously config file was overwritten by subsequent option.

-2008-06-17 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/version.rb: Gem::Version #hash and #eql? now operate

- on the version string, terms of the version string, so "1" and "1.0"

- no longer correspond to the same slot. Fixes indexer bug reported by

- * setup.rb: Fix --format-executable. Patch #20698 by Richard Brown.

- * util/gem_prelude.rb: Prevent infinite recursion, check for Gem now.

- Patch from ruby trunk by nobu.

- * lib/*: Spelling cleanup. Patch from trunk by Evan Farrar.

- * test/*: Fixes for win32 test failures reported by Luis Lavena.

- * util/gem_prelude.rb: Only remove methods added by gem_prelude.rb.

-2008-06-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Fix quick_index generation.

- * lib/rubygems/specification.rb: Correctly guard new spec features

- for older RubyGems.

- * lib/rubygems/config_file.rb: Add system-wide config file

- (/etc/gemrc). Patch #14723 by Phil Hagelberg. Add windows code to

- use appropriate directory. Code by Daniel Berger.

- * doc/release_notes/rel_1_2_0.rdoc: Draft of 1.2.0 release notes.

-2008-06-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/server.rb: Store off if we are returning Marshal

- format before running =~ again. Fixes bug reported by Chad Woolley.

- * lib/rubygems/commands/stale_command.rb: `gem stale` lists gems by

- last access time. Patch #20593 by Aaron Patterson.

- * lib/rubygems/setup.rb: Add --vendor and --destdir to setup.rb for

- packagers. Patch #20610 by Richard Brown. Don't look for stub

- files to remove any more.

- * lib/rubygems/specification.rb: Bump specification version and be

- backwards compatible with type 2 specs.

- * lib/rubygems/commands/query_command.rb: Add installed location to

- details for installed gems.

-2008-06-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Only install all dependencies

- when install_dir option is set. Don't include satisfied dependencies

- when gathering dependencies.

- * lib/rubygems/commands/query_command.rb: Display authors, rubyforge

- and homepage urls with details.

- * lib/rubygems/commands/environment_command.rb: Add executable

- directory (from Rubinius).

- * lib/rubygems/commands/install_command.rb: Don't set install_dir by

- * lib/rubygems/commands/update_command.rb: Don't set install_dir by

- default. Use #find_missing for efficiency.

-2008-06-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/server.rb: Fully mirror Gem::Indexer indexes, set

- correct content-type headers, always refresh the source index.

- * lib/rubygems/source_index.rb: Add spec_dirs so that #refresh! will

- always reload from the same locations. #refresh! on manually-built

- SourceIndex now raises. Fixes #20509 by Chad Woolley.

-2008-06-06 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Remove previous bin_script_path in case

- * lib/rubygems/commands/pristine_command.rb: Force reinstallation of

- the gem using the installer. Fixes bug #20387 by Erik Persson.

- * lib/rubygems/doc_manager.rb: Ensure args to RDoc are all strings.

- * lib/rubygems/source_index.rb: Use find_matching to discover updated

- specs instead of fetch.

- * lib/rubygems/commands/query_command.rb: Platform, not name in spec

-2008-06-05 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/local_remote_options.rb: Ensure remote repository URLs

- reference directories. Fixes bug #20134 by Neil Wilson.

- * lib/rubygems/source_index.rb: Gracefully handle ^C or explicit exit

- while loading .gemspec files from disk. Fixes bug #20523 by Joel

- * lib/rubygems/specification.rb: Use File#expand_path in

- installation_path. Fixes bug #19317 by Hemant Kumar.

- * lib/rubygems/spec_fetcher.rb: Fix legacy test against URI.

- * lib/rubygems/remote_fetcher.rb: Always raise FetchError from

- RemoteFetcher. Fix FetchErrors without URIs. Refactor Net::HTTP

- request code to use persistent connections for HEAD requests. Feature

- Request #7973 by Christian Schachtzabel.

- * lib/rubygems.rb: Don't load custom_require until after the OS and

- implementation have had a chance to set paths.

-2008-06-04 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/source_index.rb: Only fetch specs we need in

- * lib/rubygems.rb: Fix typo in ::activate exception.

- * lib/rubygems/dependency.rb: For #to_s, display dependency type when

- * lib/rubygems/dependency_installer.rb: Reset #installed_gems for

- every #install. Fixes bug #19444 by Glenn Rempe.

- * lib/rubygems/installer.rb: Don't re-read the disk to check for new

- gems, add them by hand on install.

-2008-06-03 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Add ::gzip, ::gunzip, ::deflate and ::inflate.

- * lib/rubygems/server.rb: Add specs and latest_specs indicies.

- * setup.rb: Don't require rdoc until needed. Patch #20414 by Brian

- * lib/uninstaller.rb: Correctly uninstall gems installed with a

- legacy platform. Patch #19877 by Luis Lavena.

- * lib/rubygems/commands/update_command.rb: Only fetch remote specs

- when we know what we're looking for.

-2008-06-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Remove double slash in

- #installation_path. Fixes bug #19896 by Heiko Seebach.

- * lib/rubygems/remote_fetcher.rb: Require StringIO. Fixes bug #19866

- * lib/rubygems.rb: Require rubygems/defaults/#{RBX_ENGINE}.rb and

- rubygem/defaults/operating_system.rb if they exist. (OS require comes

- first and may be overridden by operating system.)

-2008-06-01 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Ensure identical names, versions and

- platforms are identical for a smaller index.

- * lib/rubygems/spec_fetcher.rb: Only write to cache when we own it.

- * lib/rubygems.rb: Honor default_path if GEM_PATH environment

- variable is not set. Patch #19502 by Donavan Pantke.

- * lib/rubygems/installer.rb: Set file mode indicated by tar file.

- Patch #19737 by Jason Roelofs.

-2008-06-01 John Barnette <jbarnette@rubyforge.org>

- * lib/rubygems.rb: Add Gem.available?(gem, *specs) for easy availability

- checks at runtime.

-2008-05-31 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/dependency_command.rb: Delay fetching specs

- until needed. Reverse dependencies can no longer be calculated for

- remote sources. Add backwards compatibility.

- * lib/rubygems/commands/fetch_command.rb: Add backwards

-2008-05-30 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/local_remote_options.rb: --sources option should not

- add URIs to Gem.sources.

- * lib/rubygems/spec_fetcher.rb: Add #warn_legacy to help handling

- * luby/rubygems/commands/query_command.rb: Add backwards

- compatibility with legacy sources.

-2008-05-28 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Add #uri to

- Gem::RemoteFetcher::FetchError.

- * lib/rubygems/user_interaction.rb: Improve RDoc slightly.

- * lib/rubygems/spec_fetcher.rb: Introduce backwards compatibility for

- legacy (pre 1.2) repositories

- * lib/rubygems/commands/sources_command.rb: Backwards compatibility

- and restoration of --update.

- * lib/rubygems/specification.rb: Ensure nil-typed dependencies become

- runtime dependencies.

-2008-05-27 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/spec_fetcher.rb: Switch #fetch, #find_matching to be

- compatible with Gem::SourceInfoCache#search_with_source. Add caching

- for .gemspec files.

- * lib/rubygems/dependency_installer.rb: Switch to SpecFetcher.

- * lib/rubygems/source_index.rb: Switch #outdated to use SpecFetcher.

- * lib/rubygems/commands/dependency_command.rb: Switch to SpecFetcher.

- * lib/rubygems/commands/outdated_command.rb: Switch to SpecFetcher.

- * lib/rubygems/commands/query_command.rb: Switch to SpecFetcher.

- * lib/rubygems/commands/sources_command.rb: Switch to SpecFetcher.

- * lib/rubygems/commands/update_command.rb: Switch to SpecFetcher.

- * lib/rubygems/version.rb: Handle comparisons with non-Gem::Version

-2008-05-13 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/spec_fetcher.rb: Add caching of specs, latest_specs

- * test/gemutilities.rb: Ensure Gem.user_home doesn't point to ~.

-2008-05-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Add Marshal format index of spec names,

- versions and platforms. WIP.

- * lib/rubygems/spec_fetcher.rb: WIP for replacement of

- Gem::SourceInfoCache and SourceInfoCacheEntry.

- * lib/rubygems/dependency.rb: Add #=~.

-2008-05-07 John Barnette <jbarnette@gmail.com>

- * lib/rubygems/specification.rb, et. al: Let gems have development

- dependencies, which aren't installed (except when --development is

- supplied) or activated.

-2008-05-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Refactored into simpler more imperative

- * lib/rubygems.rb: Leave rbconfig/datadir.rb for non-RubyGems use.

-2008-04-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/server.rb: Refresh the source index per request so new

- gems will be found after server startup.

-2008-04-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Only print out "Bulk updating" when

- verbose, fix #latest_specs documentation.

- * lib/rubygems/dependency_installer.rb: Add :cache_dir option for

-2008-04-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/test_utilities.rb: Expose some internal testing

- utilities that are of general use.

-2008-04-10 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Fix Gem.prefix so it reports nil when rubygems.rb

- is in sitelibdir, libdir, or doesn't have 'lib' as a parent directory.

- * doc/release_notes/rel_1_1_1.rdoc: RubyGems 1.1.1 release notes.

- * lib/rubygems/rubygems_version.rb: 1.1.1.

-2008-04-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/server.rb: Fix fragment URIs. Patch by James Tucker.

- * lib/rubygems/commands/update_command.rb: Pass

- --no-format-executable to setup.rb. Patch by Stephen Bannasch.

-2008-04-06 Chad Woolley <thewoolleyman@gmail.com>

- * lib/rubygems.rb: Add setter Gems.platforms=, to allow platforms

- to be set/reset when invoking or testing RubyGems programatically.

- Also force Gems.platforms to automatically reset to default of

- [Gem::Platform::RUBY, Gem::Platform.local] if cleared.

- * lib/rubygems/version_option.rb: Change add_platform_option

- to initialize Gem.platforms to contain only Gem::Platform::RUBY

-2008-04-04 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Make Gem::SourceIndex#refresh!

- more-correct. Reported by Paul Haddad.

- * lib/rubygems.rb: Add Gem::refresh. Bug #19176 by Hongli Lai.

- * lib/rubygems/dependency_installer.rb: Put downloaded gems into

- install_dir's cache. Patch #19182 by Richard Brown.

-2008-04-03 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache.rb: Merge full cache file into

- latest data. Don't write cache files when checking for them. Only

- update full cache file when we've read it. Refresh all data when

- * lib/rubygems/dependency_installer.rb: Fix --force to work without

- network for dependent gems. Fix all-fetching test.

- * lib/rubygems/commands/query_command.rb: Obey --all flag for gem

- * lib/rubygems/commands/environment_command.rb: Don't display

- RubyGemsPackageVersion.

- * lib/rubygems/indexer.rb: Fix typo. Patch by Tom Copeland.

- * lib/rubygems/command_manager.rb: Display RubyGemsVersion with

- * lib/rubygems/commands/pristine_command.rb: Rebuild extensions along

- with everything else. Patch #19281 by Dr. Nic Williams.

-2008-04-01 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Fix prefix to point to directory above RubyGems,

- so RubyGems will be installed into lib/.

- * setup.rb: Work around apple's libdir-installed RubyGems, by

- installing into sitelibdir.

- * Rakefile: Add svnversion to RubyGems version number for `rake

-2008-03-31 Luis Lavena <luislavena@gmail.com>

- * test/: Allow tests to use a random (but controlled) port number

- instead of a hardcoded one. This helps CI tools when running

-2008-03-30 Luis Lavena <luislavena@gmail.com>

- * test/test_gem.rb: Leave APPLE_GEM_HOME tests only to *nixes.

- * lib/rubygems/remote_fetcher.rb: Errno::ECONNABORTED raised on Windows

- on closed Keep-Alive connections.

-2008-03-29 Eric Hodel <drbrain@segment7.net>

- * gemspecs/: Removed.

- * examples/: Removed.

- * doc/design/: Removed.

- * doc/rdoc_templates/: Removed.

- * Rakefile: Package doc/release_notes/.

- * setup.rb: Use full path to release_notes, ensure RDoc can be

- both removed and installed.

-2008-03-28 Eric Hodel <drbrain@segment7.net>

- * bin/gem, Rakefile: RubyGems now requires Ruby > 1.8.3.

- * lib/rubygems.rb: Added Gem.ruby_version, Gem.read_binary,

- * lib/, test/: Read files in binary mode for windows and ruby 1.9.

- * lib/rubygems/commands/update_command.rb: Only update once.

- * lib/rubygems/commands/sources_command.rb: Ditto.

- * lib/rubygems/source_index.rb: Fix #remove_extra, #find_missing so

- legacy platform gems don't get updated repeatedly.

- * doc/release_notes/rel_1_1_0.rdoc: RubyGems 1.1.0 release notes.

- * lib/rubygems/rubygems_version.rb: 1.1.0.

-2008-03-28 Ryan Woodrum <rwoodrum@avvo.com>

- * lib/rubygems/commands/query_command.rb: Add --installed

- subcommand to check if a gem and/or version is installed.

- * test/test_gem_commands_query_command.rb: Add relevant tests.

- * test/gemutilities.rb: Override exit() for query tests.

- * test/mockgemui.rb: Add =() to manipulate output values (clear).

-2008-03-28 Chad Woolley <thewoolleyman@gmail.com>

- * lib/rubygems/source_info_cache.rb: Add reset_cache_file.

-2008-03-27 Chad Woolley <thewoolleyman@gmail.com>

- * lib/rubygems/user_interaction.rb: Raise Gem::SystemExitException

- instead of exiting, kill unused terminate_interaction!.

- * lib/rubygems/exceptions.rb: Add Gem::SystemExitException.

- * lib/rubygems/commands/install_command.rb: Raise

- Gem::SystemExitException instead of exiting.

- * bin/gem: Rescue Gem::SystemExitException and exit with

- specified exit_code.

- * test/test_gem_commands_install_command.rb: Assert on

- Gem::SystemExitException and exit_code in tests.

-2008-03-27 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/sources_command.rb: Allow sources to be

- removed without network. Fixes bug #18644 by Mikel Lindsaar.

-2008-03-27 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems/commands/environment_command.rb: Use platform specific

- PATH_SEPARATOR instead of hardcoded ':'

- * test/test_gem_commands_unpack_command.rb: Ditto.

- * test/test_gem_commands_environment_command.rb: Ditto.

- * test/gemutilities.rb: Fix binary file reads being truncated on

- * test/test_gem_commands_install_command.rb: Switch to read_binary.

- * test/test_gem_commands_update_command.rb: Ditto.

- * test/test_gem_commands_server_command.rb: Consider full path when

- evaluating location (instead of hardcoded or missing drive leter).

- * test/test_gem_installer.rb: Ditto.

- * test/test_gem_dependency_installer.rb: exclude no-wrapper tests for

-2008-03-26 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems.rb: Handle backslashes that came from GEM_HOME and

- GEM_PATH on Windows.

-2008-03-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Add updating from latest index,

- default to updating from latest index. Reduces common-case update

- to under 3,000 gems at present.

- * lib/rubygems/remote_fetcher: Fix error reporting from net/http.

- * lib/rubygems.rb: Sort methods, remove last vestiges of autorequire,

-2008-03-23 Luis Lavena <luislavena@gmail.com>

- * setup.rb: generated Windows stubs will honors prefix using Gem.ruby

- instead of hardcoded 'ruby.exe'

- * lib/rubygems/installer.rb: generated Windows stubs scripts will now

- work from differnt directories than Gem::bindir. Fixes bug #16259 by

- Claus Folke Brobak

-2008-03-20 Eric Hodel <drbrain@segment7.net>

- * test/test_gem_source_info_cache.rb: Test with real objects now.

- * lib/rubygems/source_index.rb: #latest_specs now has latest specs

- for all platforms.

- * lib/rubygems/source_info_cache.rb: Add latest cache data, only load

- full cache data when needed.

-2008-03-20 Luis Lavena <luislavena@gmail.com>

- * test/gemutilities.rb: Change all the file processing mechanism to

- enable binary mode by default (required for Windows file operations

- dealing with non-printable characters).

-2008-03-19 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems/package/tar_output.rb: Adapted code to use #wrap instead

- of #new when dealing with Zlib::GzipWriter (fixes SEGV and warnings due

- GzipWriter object not being closed explicitly).

-2008-03-12 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Add latest_index.

-2008-03-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/defaults.rb: Add special case for RUBY_ENGINE constant

- when setting default gem dir.

- * Rakefile: Add update_rubinius and diff_rubinius.

-2008-03-08 Lincoln Stoll <lstoll@lstoll.net>

- * lib/rubygems/server.rb: Drop use of RDoc's TemplatePage in favor of

-2008-03-04 Ryan Davis <ryan@wrath.local>

- * lib/rubygems/remote_fetcher.rb: Moved #download from

- DependencyInstaller.

- * lib/rubygems/commands/fetch_command.rb: Updated to use #download.

- * lib/rubygems/dependency_installer.rb: install now takes name or dep.

- Renamed gather_specs_to_download to find_spec_by_name_and_version.

- Modifed #initialize to not take gem name or version.

-2008-03-04 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/package*: Removed #open_from_io and friends, switched

- to #open, no special handling for file names.

- * lib/rubygems/package/tar_output.rb: Refactored ::open to use

- * lib/rubygems/remote_fetcher.rb: Print out number of requests made

- before connection reset.

-2008-02-29 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/package/tar_reader/entry.rb: Removed is_directory and

- is_file? in favor of file? and directory?.

-2008-02-28 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/package.rb: Broke up Tar bits into separate files.

- * lib/rubygems/package/tar_reader/entry.rb: Don't copy TarHeader data

- into Entry, go through #header instead. Better tests for

-2008-02-27 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Automatically fall back to

- local-only install on network error. Fixes bug #15759 by Chauk-Mean P.

- * lib/rubygems/source_index.rb: Process spec dirs so that earlier

- dirs override later dirs. Fixes bug #14816 by Kurt Stephens.

-2008-02-26 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/update_command.rb: Only update gems that need

- updates. Fixes bug #14780 by Mathieu Lajugie. Don't force

- remote-only updates. Properly handle dependencies when updating.

- Fixes bug #17488 by Hongli Lai.

- * lib/rubygems/commands/environment_command.rb: Display path as a

- * lib/rubygems.rb: Don't add APPLE_GEM_HOME with ENV['GEM_HOME'].

-2008-02-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Expand sitelibdir when checking prefix. Fixes bug

- #17983 by Hemant Kumar.

- * setup.rb: Print release notes on installation. Tell people where

- `gem` was installed.

- * bin/update_rubygems: Added --help output to explain how to install

- earlier versions of RubyGems. Added --version option workaround.

- Fixes bug #16842 by Chad Woolley.

- * lib/rubygems/install_command.rb: Give proper exit code on failure.

- Fixes bug #17438 by Josh Nichols.

-2008-02-23 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Change hosts correctly when

- redirecting. Handle EOFError from Net::HTTP.

- * lib/rubygems/commands/specification_command.rb: Pull specifications

- * lib/rubygems/uninstaller.rb: When :executable is set, don't ask the

- user. Fixes bug #16812 by Matt Mower. Raise exception instead of

- printing message when gem is not in GEM_HOME.

- * lib/rubygems/uninstall_command.rb: Print message when gem is not in

- * lib/rubygems/commands/cleanup_command.rb: Clean up all old gems.

- * lib/rubygems/commands/unpack_command.rb: Scan every gem path when

- unpacking. Fixes bug #17602 by Ryan Davis.

-2008-02-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/install_update_options.rb: Add --bindir option to

- specify destination to install executables into. Patch #17937 by

- * lib/rubygems/specification.rb: Fix Time.today == Time.today. Bug

- #17413 by Andrei Bocan.

- * setup.rb: Properly check for deletablitily of user and system

- caches. Bug #17869 by Alexey Verkhovsky. Fix --no-format-executable.

- Fixes bug #16879 by Charles Nutter.

-2008-02-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Add persistent connection support.

- Patch #18180 by Aaron Patterson.

- * lib/rubygems/installer.rb: Fix #shebang to use the ruby install

- name. Patch #16878 by Donavan Pantke.

- * lib/rubygems/defaults.rb, lib/rubygems.rb: Enable defaults for

- Gem.path and Gem.bindir. Patch #17886 by Donavan Pantke.

- * test/test_gem_ext_configure_builder.rb: Make test_self_build_fail

- more platform independent. Patch #17599 by Martin Krauskopf.

-2008-02-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/fetch_command.rb: Fix a bug when fetching

- from non-default sources. Report non-existent gems instead of

-2008-01-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/update_command.rb: Use portable and safe ENV

- operation. Patch by usa in ruby SVN revision 14739.

- * lib/rubygems/open-uri.rb: Fix tests. Patch by NARUSE Yui.

-2007-12-23 Eric Hodel <drbrain@segment7.net>

- * util/gem_prelude.rb: Remove methods from Gem, not QuickLoader, to

-2007-12-22 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/environment_command.rb: Put GEM PATHS in the

- * lib/rubygems/commands/uninstall_command.rb: Add --install-dir to

- specify which local repository to uninstall from. Patch #15151 by

- * lib/rubygems/uninstaller.rb: Only allow uninstallation of gems from

- specified directory. Properly clean up executables on uninstall.

- Patch #15151 by Donavan Pantke.

- * lib/rubygems/install_update_options.rb: Add --no-env-shebang

- option. Patch #16508 by Donavan Pantke.

- * util/gem_prelude.rb: Use require to load rubygems.rb to make

- $LOADED_FEATURES correct on RubyGems update.

-2007-12-21 Eric Hodel <drbrain@segment7.net>

- * util/gem_prelude.rb: Place bin before lib so bin stubs work.

-2007-12-20 Eric Hodel <drbrain@segment7.net>

- * Rakefile: Require Ruby > 1.8.2. Enable CERT_DIR.

- * lib/rubygems.rb: Work with RbConfig and Config. Bug #16457 by

- Christian Ramilo, John Barnette.

- * lib/rubygems/commands/build_command.rb: Relax yaml? test to work

- * lib/rubygems/rubygems_version.rb: 1.0.1.

- * doc/release_notes/rel_1_0_1.rdoc: RubyGems 1.0.1 release notes.

-2007-12-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Revert change that only wrapped

- executables with #!.

- * lib/rubygems/specification.rb: Warn about a lot of things that

- could be wrong with gemspecs on build, including missing #!. Use

- 'x86-mswin32' for legacy 'mswin32' platform, fix CURRENT platform.

- Paired with Luis Lavena.

- * lib/rubygems/remote_installer.rb: Deleted.

- * lib/rubygems.rb: Removed Kernel#require_gem.

- * doc/release_notes/rel_1_0_0.rdoc: RubyGems 1.0 release notes.

- * lib/rubygems/rubygems_version.rb: 1.0.0.

-2007-12-18 Luis Lavena <luislavena@gmail.com>

- * lib/rubygems/commands/mirror_command.rb: Work around URI::parse

- processing file:// scheme and drive paths on Windows.

- * test/test_gem_commands_mirror_command.rb: ditto.

-2007-12-17 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Copy files into bindir if they don't

- have a shebang. Bug reported by Luis Lavena.

- * lib/rubygems/server.rb: Handle platforms in Gem::Server#quick.

- Exactly match gem names. Bugs reported by Chad Woolley.

- * lib/rubygems/platform.rb: Remove platform constants in favor of

- Gem::Platform::CURRENT. Bug reported by Luis Lavena.

- * lib/rubygems/dependency_installer.rb: Work around Dir::glob not

- understanding File::ALT_SEPARATOR. Bug submitted by Luis Lavena.

-2007-12-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Be more verbose in error messages

- * lib/rubygems/server.rb: Be more verbose in error/missing responses.

-2007-12-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Output extension build results when

- really verbose. From bug #15853 John Croisant.

- * lib/rubygems/specification.rb: Fix backwards compatibility with

- 0.9.4, don't allow the platform to be nil or an empty string. Bug

- #16177 by Dan Manges.

- * setup.rb: Re-exec setup.rb if rubygems is loaded and RUBYOPT is

- set. Fixes bug #15974 by Joshua Sierles.

- * lib/rubygems/update_command.rb: Tweak formatting of updated

- message. Bug #15625 by Bil Kleb.

- * lib/rubygems/remote_fetcher.rb: Add URI to exception message for

- Gem::RemoteFetcher#fetch_size. Bug #14801 by Bil Kleb.

-2007-12-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/query_command.rb: Don't display duplicate

- version numbers. Bug #15828 by Tim Fletcher.

- * setup.rb: Fix my stupidity with --help. Patch #16308 by Stephen

- Bannasch. Fix --prefix= argument. Bug #16002 by Piglop.

-2007-12-13 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/server_command.rb: Fix --no-daemon. Bug by

- * lib/rubygems/server.rb: Fix Marshal quick index. Bug by Chad

- * lib/rubygems/installer.rb: Respect Gem::Specification#bindir. Bug

- #16202 by Suraj Kurapati.

- * lib/rubygems/commands/update_command.rb: Fix `gem update mysql`.

- Bug #16244 by Stephen Bannasch.

-2007-12-12 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Add --format-executable option to

- install executables with ruby's program-suffix and prefix. Patch

- #14688 by Jeremy Kemper. Also, installing in really-verbose mode

- prints out written files.

- * setup.rb: Add --format-executable option to install gem with ruby's

- program-suffix and prefix. Add --help. Fixes bug #16056 by Chad

- * lib/rubygems/uninstaller.rb: Fallback to original_platform_name

- correctly. Patch #15960 by Nicola Piccinini's friend.

-2007-12-11 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/validator.rb: Correct test run failures when no tests

- are provided. Patch #15701 by Jérémy Zurcher.

- * lib/rubygems/commands/mirror_command.rb: Don't File.join a

- URI::HTTP. Patch #16116 by Morgan Nelson.

- * lib/rubygems/commands/unpack_command.rb: Add --target option to

- `gem unpack`. Patch #16154 by Kevin Barnes.

-2007-12-10 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Revert to nil for the default

- security policy to avoid requiring OpenSSL.

- * lib/rubygems/defaults.rb: Consolidate defaults for easier editing.

- Patch #15150 by Donavan Pantke.

-2007-11-27 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Remove dependency on forwadable.

- Patch by Koichi Sasada.

- * lib/rubygems/specification.rb: Reduce dependency on time.rb. Patch

-2007-11-26 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/version.rb: Fix bug 15948 with version bump

- * test/test_gem_version.rb: Test for bug 15948 with version bump

- * util/gem_prelude.rb: wrap init code with exception handler

- and skip badly formed directory names

-2007-11-23 Rich Kilmer <rich@infoether.com>

- * lib/rubygems.rb: Centralize all CONFIG options into Hash

- Gem::ConfigMap with keys as symbols, change all references

- to CONFIG to ConfigMap

- * lib/rubygems/require_paths_builder.rb: Added to support

- building .require_paths file

- * lib/rubygems/installer.rb: Add building of .require_paths if

- * lib/rubygems/platform.rb: Use new ConfigMap hash for arch

- * util/gem_prelude.rb: new gem prelude for Ruby 1.9

- * test/test_gem_installer.rb: change to use ConfigMap hash

- * test/gemutilities.rb: change to use ConfigMap hash

-2007-11-21 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/platform.rb: Gem::Platform.new now returns

- Gem::Platform.local if the arch matches Gem::Platform::CURRENT.

- Bugs #15815 and #15782 submitted by Daniel Berger.

-2007-11-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/platform.rb: Handle bare 'mswin32' platform's CPU.

-2007-11-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb: 0.9.5.

-2007-11-16 Eric Hodel <drbrain@segment7.net>

- * test/gemutilities: Add a legacy platform gem to the default test

- * lib/rubygems/specification.rb: Add Gem::Specification#original_name

- for legacy purposes

- * lib/rubygems/indexer.rb: Use #original_name to make the indexer

- backwards compatible.

- * lib/rubygems/master_index_builder.rb: Reduce memory consumption.

-2007-11-13 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb: 0.9.4.7 beta.

- * lib/rubygems.rb: Patch for RUBY_FRAMEWORK for OS X 10.5. Patch

- submitted by Laurent Sansonetti.

- * lib/rubygems.rb: cygwin, djgpp, mingw are Windows platforms. Fixes

- bug #15537 by Roger Pack.

-2007-11-11 Eric Hodel <drbrain@segment7.net>

- * Rakefile: Tasks for maintaining ruby trunk export of RubyGems.

- * lib/rubygems/specification.rb: Preserve original platform across

- * lib/rubygems/dependency_installer.rb: Retry with original platform

- name on fetch error.

-2007-11-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Set #original_platform only once.

- * lib/rubygems/indexer.rb: Handle legacy platforms.

- * lib/rubygems/platform.rb: Gem::Platform is a valid argument. Bug

- #15511 submitted by Daniel Berger.

- * lib/rubygems/custom_require.rb: Fix compatibility with 1.8.2. Bug

- #14933 submitted by Aaron Patterson.

- * lib/rubygems/command.rb: Now '-V' enables verbose. Bug #14951

- submitted by Sasa Ebach.

- * lib/rubygems/commands/check_command.rb: Change use of '-v', '-V' to

- * lib/rubygems/package.rb: #send! is gone again.

- * lib/rubygems.rb: Don't add custom_require for 1.9.

- * test/*: Make compatible with 1.9 import.

-2007-10-30 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Don't re-use @platform to maintain

- backwards compatibility.

- * lib/rubygems/platform.rb: Handle nil and 'ruby' platforms in ::new.

-2007-10-20 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/uninstaller.rb: Changed '.cmd' to '.bat' in the

- remove_executables method for MS Windows. Patch from Luis Lavena.

-2007-10-18 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb: 0.9.4.6 beta.

-2007-10-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/update_command.rb: Don't install with

- dependencies when updating. This is a hack.

-2007-10-19 Daniel Berger <djberg96@gmail.com>

- * setup.rb: gem.cmd stub is now gem.cmd, and the stub generation was

- changed - now better for NT. Patch #14725 (Luis Lavena).

- * lib/rubygems/installer.rb: Same as for setup.rb.

-2007-10-18 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/platform.rb: Modified the Platform.local method for MS

- Windows for versions built with VC++ 6. Patch #14727 (Luis Lavena).

- * test/test_gem_specification.rb: Added version independent tests for

- MS Windows. Patch #14727 (Luis Lavena).

-2007-10-18 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb: Add platform to User-Agent.

- * lib/rubygems/commands/install_command.rb: Fix typo. Debian bug

- #443135 submitted by Reuben Thomas.

- * lib/rubygems/dependency_installer.rb: Don't install dropped

- dependencies. Fixes bug #14724 submitted by Luis Lavena.

-2007-10-17 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/update_command.rb: Unset RUBYOPT when running

- * setup.rb: Re-exec without RUBYOPT if it is set. Fixes bug #14683

- submitted by Lyle Johnson.

-2007-10-16 Daniel Berger <djberg96@gmail.com>

- * lib/rubygems/indexer/abstract_index_builder.rb: The compress method

- now does a binary read to make MS Windows happy.

-2007-10-16 Eric Hodel <drbrain@segment7.net>

- * setup.rb: Installs bin stubs that warn when you try to use the old

- commands. Simple mswin deprecation stubs by Luis Lavena.

-2007-10-12 Eric Hodel <drbrain@segment7.net>

- * setup.rb: Remove source caches on install.

- * doc/release_notes/rel_0_9_5.rdoc: Draft added.

- * lib/rubygems/rubygems_version.rb: 0.9.4.5 beta.

-2007-10-10 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Fix small bug found by Alan C.

-2007-10-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Use install_dir so custom gem

- repos can be used.

- * lib/rubygems/specification.rb: Always set required attributes, even

- if they match the default.

-2007-10-08 Ryan Davis <ryan@wrath.local>

- * lib/rubygems.rb: Fixed require order so custom_require is

- last. Added HACK tag to remind Jim to release rake.

- * test/test_gem_source_index.rb: Fixed latest_specs' tests so

- failures were much more readable.

- * lib/rubygems/source_index.rb: Fixed latest_specs to deal with

- platforms appropriately. Returns array again.

-2007-10-08 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/config_file.rb: Boost bulk_threshold to 1000, Marshal

- format is smaller than yaml format quick index.

- * lib/rubygems/installer.rb: Make #shebang correctly rewrite env

- * lib/rubygems/specification.rb: Mark Time.today for removal, too much

- depends upon it now.

-2007-10-07 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Sped up ::_load.

- * lib/rubygems/source_index.rb: Sped up #search.

- * lib/rubygems/version.rb: Replace #to_ints with #ints, and cache

- * lib/rubygems/source_info_cache.rb: Only flush cache when it changes.

-2007-10-05 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/user_interaction.rb: Allow customization of completion

- message for progress reporters.

- * lib/rubygems/command.rb: Add --quiet option.

- * lib/rubygems/commands/generate_index_command.rb: Add description.

-2007-10-04 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/uninstaller.rb: Also check and uninstall old platform

- name to ensure legacy platform gems are uninstalled.

- * lib/rubygems/doc_manager.rb: Remove existing rdoc and ri directory

- so regenerating docs succeeds even if previously interrupted.

-2007-10-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb: Make #outdated search only for gems

- matching the current platform.

- * lib/rubygems/commands/dependency_command.rb: Add --platform.

- * lib/rubygems/commands/outdated_command.rb: Ditto.

- * lib/rubygems/commands/specification_command.rb: Ditto.

- * lib/rubygems/commands/update_command.rb: Ditto.

-2007-10-02 Wilson Bilkovich <wilson@supremetyrant.com>

- * lib/rubygems/specification.rb: Custom Marshal format to reduce index

- * lib/rubygems/requirement.rb: Ditto

- * lib/rubygems/version.rb: Ditto

-2007-10-01 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/platform.rb: Handle mswin32 on VC6. Partial patch and

- assistance by Luis Lavena. Handle cpu-os-version style platforms for

- command-line arguments.

-2007-09-30 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Gem::Specification is now

- forward-compatible while loading.

-2007-09-29 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache_entry.rb: Correctly handle URIs.

- * lib/rubygems/remote_fetcher.rb: ditto.

- * lib/rubygems/remote_options.rb: Add --update-sources option. Patch

- #14246 submitted by Alan Francis.

- * lib/rubygems/config_file.rb: Add update_sources setting to control

- automatic refreshing of sources (patch #14246). Fix bug where things

- would be overwritten in ~/.gemrc when they shouldn't.

-2007-09-28 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems.rb: Gem.ruby now returns the full path. Added

- Gem.prefix to make self updating work right.

- * setup.rb, pre-install.rb, post-install.rb: Replace with a small,

- simple setup script that works.

- * lib/rubygems/commands/update_command.rb: Pass rdoc, ri and prefix

- flags down to setup.rb when self updating.

-2007-09-26 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/version_option.rb: Always include RUBY platform,

- allow RUBY platform as an option.

- * lib/rubygems/specification.rb: Gems with non-ruby platform sort

- last (first in preference for installation).

- * lib/rubygems/platform.rb: Allow matching of legacy platforms.

- * lib/rubygems/source_index.rb: Add only_platform option to #search.

-2007-09-24 Wilson Bilkovich <wilson@supremetyrant.com>

- * lib/rubygems/indexer.rb: Generate a Marshal index in parallel to YAML

- * lib/rubygems/source_index.rb: Fetch a Marshal index if it exists, to

- avoid the memory cost of parsing a huge YAML file

- * lib/rubygems/commands/mirror_command.rb: Check for Marshal first

- * lib/rubygems/indexer/abstract_index_builder.rb: Index refactoring

- * lib/rubygems/indexer/marshal_index_builder.rb: Build Marshal index

- * lib/rubygems/indexer/master_index_builder.rb: Simplify YAML generation

- * lib/rubygems/indexer/quick_index_builder.rb: Build Marshal quickindex

- * lib/rubygems/server.rb: Serve up Marshal index as well as YAML

- * lib/rubygems/source_info_cache_entry.rb: Expect a Marshal index

-2007-09-23 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/fetch_command.rb: `gem fetch` downloads a gem

- to the current directory. Feature request #10752 by Bret Pettichord.

- * lib/rubygems/commands/local_remote_options.rb, etc.: Fix spelling of

- * lib/rubygems/installer.rb: Revert feature request #8818, it

- interferes with `ruby -S` and multiple versions of ruby (1.8 and 1.9).

- * lib/rubygems/dependency_installer.rb: Fix a bug where the wrong

- platform gem would be installed.

- * lib/rubygems/version_option.rb: Add --platform.

- * lib/rubygems/install_update_options.rb: Verify --security-policy.

- * lib/rubygems/local_remote_options.rb: Verify --source, --http-proxy.

-2007-09-22 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/open-uri.rb: Don't document our OpenURI.

- * lib/rubygems/commands/generate_index_command.rb: Fix Indexer class

- * lib/rubygems/commands/mirror_command.rb: Fix for 1.9.

- * lib/rubygems/commands/pristine_command.rb: Have `gem pristine`

- give a better report of what it accomplished.

- * lib/rubygems/command.rb: Add optional description field.

- * lib/rubygems/installer.rb: Hack around broken Pathname#absolute? on

- windows. Patch #14139 by Jim Hughes.

-2007-09-20 Eric Hodel <drbrain@segment7.net>

- * misc files: Tests pass on 1.9.

- * test/gemutilities.rb: Added Object#send! stub for 1.8.

- * test/test_open_uri.rb: Require gem_open_uri.rb to avoid warnings.

- * lib/rubygems/commands/sources_command.rb: Clarify `gem sources -c`

- and what `gem sources` does. Patch by Hugh Sasse.

-2007-09-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/platform.rb: Make Gem::Platform a class.

- * lib/rubygems/specification.rb: Gem::Specification#validate returns

- true, non-Gem::Platform platforms are no longer allowed.

- * test/gemutilities.rb: 1.9 compatiblity fixes.

- * lib/rubygems/dependency_installer.rb: Work around a bug in URI.parse

- which misinterprets "C:/". Patch #13537 submitted by Daniel Berger.

- * lib/rubygems/format.rb: Ensure file handles are closed. Patch

- #13533 submitted by Daniel Berger.

- * test/test_gem_installer.rb: Win32 path fix. Patch #13528 submitted

- * test/gemutilities.rb: Make the platform be a win32 platform on

- win32. Fixes confusion in generate_bin_symlink tests. Patch #13529

- submitted by Daniel Berger.

- * test/test_gem_specification.rb: Sequel to above. Patch

- #13535 submitted by Daniel Berger.

- * lib/rubygems/source_index.rb: Make the updating cache message more

- clear. Patch #12778 submitted by Bil Kleb.

- * lib/rubygems/server.rb: Allow gem's rdoc-style.css to be used.

- Patch #13589 by Stephen Bannasch.

- * lib/rubygems/indexer.rb: Fail on missing builder gem only when

- trying to use the indexer. Fixes bug #13939 by Bryan Stearns.

- * lib/rubygems/indexer/indexer.rb: Move Indexer up one level in

- * lib/rubygems/indexer/compressor.rb: Only used in

- Gem::Indexer::AbstractIndexBuilder subclasses, merged there.

- * lib/rubygems/command_aids.rb: Merged Gem::CommandAids into

- Gem::Command since that's the only place it gets used.

- * misc other files: mswin fixes. Paired with Daniel Berger.

-2007-08-24 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb: Fix #full_name for versionless

- * lib/rubygems/command_manager.rb: We're only looking for NameError.

- * lib/rubygems/command.rb: 1.9 fix.

- * lib/rubygems/format.rb: ditto.

- * lib/rubygems/installer.rb: ditto.

-2007-08-24 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb: 0.9.4.4

-2007-08-23 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/platform.rb: Add HPUX, AIX and NetBSD. Thanks to

- Daniel Berger, Yutaka KANEMOTO and Andre Nathan respectively.

- * lib/rubygems/installer.rb: Move all option setting to #initialize to

- make `gem pristine` work again.

- * lib/rubygems/commands/environment_command.rb: Include platforms.

- * lib/rubygems/dependency_installer.rb: Support local non-root

-2007-08-22 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Don't reinstall dependencies

- existing in the install dir. Don't install dependencies for older

- versions of the gem we're installing. #installed_gems now contains

- loaded gemspecs. Always prefer local gems. Handle globs correctly.

- All deps are now installed into the install_dir.

- * lib/rubygems/commands/install_command.rb: Switch to

- Gem::DependencyInstaller. Warn when -y is given, it will be removed.

- Try our best to install everything the user asked.

- * lib/rubygems.rb: Gem.bindir now handles Pathname correctly.

- * lib/rubygems/remote_fetcher.rb: Don't downcase anymore.

-2007-08-21 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Add installation from local

- gems. Install gems in the correct order. Handle -E, -f,

- --ignore-dependencies, -i, -r, -l, -b, -P, -w, -v options for `gem

- * test/gemutilities.rb: Work around OS X /private/tmp.

- * lib/rubygems/platform.rb: Switch to using arch instead of target_*

- for JRuby compatibility. Thanks to Nick Sieger.

-2007-08-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_installer.rb: Add working but unfinished

- Gem::DependencyInstaller.

- * lib/rubygems/source_info_cache.rb: Add #search_with_source.

- * lib/rubygems/dependency_list.rb: Move #fill_dependencies to

- Gem::DependencyInstaller

- * lib/rubygems/platform.rb: Split from specification.rb. Add methods

- to recognize platforms from Config::CONFIG.

- * lib/rubygems.rb: Add Gem::platforms.

- * lib/rubygems/specification.rb: Disallow String platforms.

-2007-08-18 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache.rb: Search by Gem::Dependenency.

- * lib/rubygems/source_index: Search by Gem::Dependenency.

- * lib/rubygems/version.rb: Version can be String or Integer.

- Gem::Requirement::default is now >= 0. Gem::Requirement can be built

- from a Gem::Dependency.

- * lib/rubygems/dependency_list.rb: Uses TSort now. Add

- Gem::DependencyList#fill_dependencies.

- * lib/rubygems/server.rb: Support quick index.

-2007-08-17 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/dependency_list.rb: For diamond dependencies with

- different versions on the bottom of the diamond, trim all but the

- latest dependency. This will prevent gems like hoe from being

- installed multiple times.

-2007-08-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb: Support building mkrf extensions. Fixes

- bug #11313. Patch by Jeremy Hinegardner.

- * lib/rubygems/installer.rb: Ensure bin files are executable. Fixes

- bug #8985 submitted by Ara Howard.

- * lib/rubygems/installer.rb: Insert installing gem home dir into bin

- wrapper. Patch #8818 by Ara Howard.

-2007-08-13 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/uninstall_command.rb: Gems with version of 0

- can now be uninstalled.

-2007-08-11 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/config_file.rb: Command-line args override ~/.gemrc

- now. Gem.sources is pulled from ~/.gemrc now. Gem::ConfigFile can

- write itself out now.

- * lib/rubygems/commands/sources_command.rb: Now writes out

- Gem.configuration on changes. No longer checks source cache on

-2007-08-09 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache.rb: Make Gem::SourceInfoCache#search

- only search gems in Gem.sources.

- * lib/rubygems.rb: Make Gem::configuration a real Gem::ConfigFile

- * lib/rubygems/commands/query_command.rb: Fix `gem query --details`.

- Add `gem query --no-versions`.

- * lib/rubygems/local_remote_options.rb: Make `gem mumble --source URL`

- only use that source.

- * lib/rubygems/config_file.rb: Fix Gem::ConfigFile#[]= to match

- Gem::ConfigFile#[].

-2007-08-08 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/commands/specification_command.rb: Match only exact gem

- names. Fixes bug #9681. Patch by Michael DeCandia.

- * lib/rubygems/commands/unpack_command.rb: Match only exact gem names.

- Fixes bug #9681. Patch by Michael DeCandia.

- * lib/rubygems/commands/contents_command.rb: Match only exact gem

- names. Fixes bug #9681. Patch by Michael DeCandia

- * lib/rubygems/remote_fetcher.rb: Perform a GET request if the HEAD

- request doesn't have Content-Length. Fixes bug #9771. Patch by Ben

- * lib/rubygems.rb: Clear Gem::searcher when we Gem::clear_paths.

- Fixes bug #12886. Submitted by Peter Williams.

- * lib/rubygems.rb: Add #default_sources and rework #sources to use it.

- * post-install.rb: No longer runs install_sources.

- * pkgs/sources: Updated to something what a 0.0.2 would look like, if

-2007-08-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/gem_commands.rb: Removed and broken up into individual

- * lib/rubygems/command_manager.rb: Lazily loads gem commands. Now to

- use CommandManager just "require 'rubygems/command_manager'" and

- everything will be there.

-2007-08-01 Eric Hodel <drbrain@segment7.net>

- * lib/*, test/*: Pushed down dependencies as far as reasonable.

- Removed Gem::manage_gems. Now only 14 files are loaded with "require

- 'rubygems'". Added tests for `gem build` and `gem cert`.

- * lib/rubygems/extensions.rb: Added common place for all extensions.

-2007-07-26 Eric Hodel <drbrain@segment7.net>

- * test/test_gem_ext_configure_builder.rb: Linux has different behavior

- for `sh ./configure` when configure is missing. Fix adapted from

- Patch #10019 by Donavan Pantke.

- * lib/rubygems/commands/pristine_command.rb: Compare fully-qualified

- paths. Fixes bug #7976 by Lyle Johnson.

- * lib/rubygems/config_file.rb: Add ConfigFile#[]=, so --proxy

- command-line option works. Fixes #8152 by Justin Sabelkko.

- * lib/rubygems/post-install.rb: Make sure we use the

- latest-and-greatest RubyGems when running post-install.rb. Fixes Bug

- #8411 by Duy Nguyen.

- * lib/rubygems/remote_fetcher.rb: An empty HTTP_PROXY means no proxy.

- Fixes Bug #9042 by Michael Brodhead.

- * lib/rubygems/version.rb: Disallow newlines in version string. Strip

- spaces from version string. Fixes Bug #9499 by Bryce Kerley.

- * lib/rubygems/commands/sources_command.rb: Fix spelling error. Fixes

- Bug #11064 by Chris Eskow.

-2007-07-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/indexer.rb: Create the index in /tmp, then move it into

- place when we're done. This will prevent spurious bulk index updates

- from occurring while the quick index is missing. Remove the option to

- not build the quick index.

- * lib/rubygems/commands/generate_index_command.rb: --no-quick is gone.

- * lib/rubygems/user_interaction.rb: If stdin is not a tty, it is

- unlikely that gem is going to get a response when asking a question.

- Patch #10660 by Paul Brannan.

- * lib/rubygems/validator.rb: Output test failures when using install

- -t. Patch #10659 by Paul Brannan.

- * lib/rubygems/custom_require.rb (Kernel#require): Only rescue a

- LoadError that matches the file we are requiring. Patch #10723 by

- * lib/rubygems/remote_fetcher.rb: Support HTTP basic authentication.

- Patch #8121 by Max Dunn.

- * lib/rubygems/commands/install_command.rb: Don't raise an error when

- a gem has no tests. Patch #11824 by Katsuyuki MIYAMUKO.

-2007-07-23 Eric Hodel <drbrain@segment7.net>

- * lib/commands/contents_command.rb: Add --lib-only option, remove

- useless --list option. Feature request #9498 by Martin DeMello.

- * lib/rubygems/specification.rb: Restrict to only files in

- #require_paths. Add #required_rubygems_version. Feature request

- #7780 by Eric Hodel.

- * lib/rubygems/commands/dependency_command.rb: Display dependencies for

- remote gems. Feature request #12133 by Eric Hodel. -r for reverse

- dependencies is now -R.

- * lib/rubygems/commands/specification_command.rb: Display

- specifications for remote gems. Feature request #12133 by Eric Hodel.

- * lib/rubygems/installer.rb (Gem::Installer#install): Check

- required_rubygems_version.

- * lib/rubygems/user_interaction.rb

- (Gem::UserInteraction#choose_from_list): Check result for EOF. Fixes

- bug #8018. Patch by Jos Backus.

- * post-install.rb: Install using absolute path. Fixes bug #10675.

- Patch by Jeremy Burks.

- * lib/rubygems/commands/environment_command.rb: Add RUBY VERSION to

- environment output.

- * lib/rubygems/command.rb: Don't worry about duplicated command-line

- options, OptionParser takes care of them for us.

-2007-07-22 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb (Gem::Specification#files): Make it

- * lib/rubygems/command.rb: Better documentation. -v flag now lets you

- get to "really verbose" mode which makes the verbose progress meter

- work. Add command groups to separate types of commands easily.

- * lib/rubygems/commands/which_command.rb, bin/gemwhich: Move `gemwhich`

- * lib/rubygems/commands/mirror_command.rb, bin/gem_mirror: Move

- `gem_mirror` under `gem`.

- * lib/rubygems/commands/lock_command.rb, bin/gemlock: Move `gemlock`

- * lib/rubygems/commands/server_command.rb, bin/gem_server: Move

- `gem_server` under `gem`.

- * lib/rubygems/doc_manager.rb (Gem::DocManager#initialize): Only raise

- when operating on the filesystem.

- * lib/rubygems/server.rb: Remove option processing, now in

- Gem::Commands::ServerCommand.

- * lib/rubygems/commands/generate_index.rb, bin/index_gem_repository.rb:

- Move `index_gem_repository.rb` to `gem generate_index`.

- * lib/rubygems/indexer (Gem::Indexer): Extract from

- index_gem_repository.rb and merge RubyForge changes.

- * lib/rubygems/command_manager.rb (Gem::CommandManager#run): Print

- backtrace when --debug is set too.

- * lib/rubygems/command_manager.rb (Gem::CommandManager#load_and_instantiate):

- Don't infinitely loop in retry.

- * bin/gemri: Removed. Everybody should have ri integration now.

- * lib/rubygems/config_file.rb: Allow settings to be examined. Pull

- settings from .gemrc.

- * lib/rubygems/commands/environment_command.rb: Add ruby executable

- and configuration settings to `gem env`.

- * lib/rubygems/indexer/indexer.rb (Gem::Indexer::Indexer#build_index):

- Now uses UserInteraction.

- * various: Use UserInteraction for output.

- * lib/gemconfigure.rb: Removed. Same as multiple gem commands.

- * lib/rubygems/commands/contents_command.rb: Removed extra --verbose

- * lib/rubygems/gem_commands.rb (Gem::LocalRemoteOptions): Moved -B,

- --source, -p from Gem::Commands::common_options.

-2007-07-22 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: Added another example to the gem

- example output (Gile Bowkett)

- * test/test_documentation_generation.rb, lib/rubygems/doc_manager.rb:

- Added a test for documentation generation and fixed a bug when doc

- location is not writable.

-2007-06-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/gem_path_searcher.rb (Gem::GemPathSearcher): Moved out

- of lib/rubygems/custom_require.rb and added tests.

-2007-06-02 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/source_info_cache.rb (Gem::try_file): Fix for issue

- where a non-existing source cache file causes the gem command to

- not find a gem. This fixes it by marshalling out an empty

- hash. (Thanks to Nick Sieger for this fix).

-2007-06-01 Jim Weirich <jim@weirichhouse.org>

- (Gem::OperationNotSupportedError::latest_partials): Changed from

- match data style to $1 style regexp (on the recommendation of

- better performance).

-2007-05-30 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/source_index.rb (Gem::SourceIndex::update):

- Modified to get the bulk_threshhold from the configuration.

- (Gem::SourceIndex::convert_specs): Ryan removed the "reduce_specs"

- method because it is not needed any more and is creating memory

- * lib/rubygems/config_file.rb (Gem::ConfigFile): Added

- bulk_threshhold field to ConfigFile.

- (Gem::ConfigFile::initialize): Initialize bulk threshhold to 500.

- * lib/rubygems/command.rb

- (Gem::Command::specific_extra_args_hash): Added

- -B (--bulk-threshhold) option to allow user specified bulk

- download threshhold.

-2007-05-23 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/commands/sources_command.rb

- (Gem::Commands::SourcesCommand::initialize): Added a --clear-all

- option to the sources subcommand. Clear-all will remove the cache

- * lib/rubygems/source_info_cache.rb (Gem): Moved system_cache_file

- and user_cache_file to class methods so that we can get the file

- names without creating a SourceInfoCache instance.

-2007-05-23 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache.rb: Teach SIC to repair itself

- when it encounters a bad cache file.

-2007-05-14 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/command_manager.rb: Re-added registration for

- gem cleanup command which I accidentally removed during refactoring.

-2007-05-10 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb: Uncommented the require

- * lib/rubygems/source_info_cache.rb: Uncommented the require

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to version 0.9.3

- in preparation for release.

- * lib/rubygems/package.rb (Gem::TarInput::zipped_stream):

- Zipped_stream now always uses the in memory string IO buffer.

- There were just too many problems with ZLib (on windows)

-2007-03-26 Jim Weirich <jim@weirichhouse.org>

- * (Index): new digest technique.

- * lib/rubygems/validator.rb (Gem::Validator::verify_gem): Removed

- really old MD5 and replaced with gem based digests.

- * experimental/deployment.rb (Gem::Deployment::Manager::initialize):

- New digest technique.

- * experimental/test_deployment.rb (TestDeployment::test_deployed_file):

- New digest technique.

-2007-03-26 Chad Fowler <chad@chadfowler.com>

- * Extracted the big ball of mud that was gem_commands.rb into

-2007-03-17 Chad Fowler <chad@chadfowler.com>

- * Various ruby 1.8.6 fixes for failing tests.

- * Updated setup.rb to 3.4.1

- * Renamed cmd_manager to command_manager to keep names consistent

- * lib/installer.rb: Rework path checking to use Pathname (ara howard bug #8811)

-2007-03-02 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems.rb: Add bin directory before library directory,

- otherwise gems like rake don't work.

-2007-03-01 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/open-uri.rb: Fix all the infinite loop errors.

- * lib/rubygems.rb: Add dirs from activate after -I and ENV['RUBYLIB']

- dirs. Otherwise gems won't allow -I to work when #gem is called.

-2007-02-11 Chad Fowler <chad@chadfowler.com>

- * test/gemutilities.rb: Fix to make Windows tests pass. (Anatol Pomozov)

-2007-02-05 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to version 0.9.2

- and made a release.

-2007-02-04 Chad Fowler <chad@chadfowler.com>

- * Fixed failing tests (changed from assert_equal to assert_match to

- deal with ARGV inconsistencies in test vs. production).

-2007-02-03 Jim Weirich <jim@weirichhouse.org>

- * Bumped version to 0.9.1.1.

- * lib/rubygems/gem_open_uri.rb: Added the patched open-uri back

- into the gems software. Evidently, the 1.8 version of open-uri

- does not handle authenticating proxies with username and password.

- * lib/rubygems/source_info_cache.rb (Gem::cache_data): Added

- rescue block to capture bad file loads. The original rescue was

- only around the marshal load (bug was probably introduced when the

- file data was preloaded into a string).

- (Gem::set_cache_data): Added set_cache_data to be used during

- testing to avoid reload the cache file over and over.

- * lib/rubygems/gem_commands.rb: Added require for command class so

- that this file can be loaded independently.

- * lib/rubygems/source_index.rb (Gem::SourceIndex::outdated): Minor

- * test/gemutilities.rb

- (RubyGemTestCase::util_setup_source_info_cache): Minor cleanup

- * test/test_gem_source_info_cache.rb

- (TestGemSourceInfoCache::test_write_cache_user): Switched to using

- set_cache_data here and several other places to avoid rereading

- the cache data over and over again.

-2007-02-02 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb:

- Fixed gem unpack (broken since 0.9.1)

-2007-01-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache.rb (Gem::SourceInfoCache#cache_data):

- Read the source_cache in binary mode for mswin.

-2007-01-16 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/rubygems_version.rb (Gem): Released 0.9.1.

-2007-01-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb (Gem::Installer#extract_files): Only allow

- installation to absolute directories. (Call File::expand_path first).

- More informative message for attempting to install with bad path.

- * post-install.rb: Install sources first, since its rather important.

-2007-01-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_info_cache.rb: require 'fileutils', as its

-2007-01-12 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb (Gem::Installer#extract_files): Don't

- allow gems to place files outside the installation directory. Fixes

- bug 7751 by Gavin Sinclair.

-2007-01-08 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/specification.rb

- (Gem::Specification::test_suite_file): Added rescue clause for

- default_executable.

- (Gem::Specification::add_bindir): Added rescue clause for

- * test/test_specification.rb

- (TestSpecification::test_pathologically_bad_non_array_stuff_doesnt_goof_up_files):

- Added a sanity check on hash for some pathologically bad case.

- (TestSpecification::test_pathologically_bad_exectuables_doesnt_goof_up_hash):

- Added sanity check for pathologically bad executables field.

-2007-01-08 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/gem_commands.rb (Gem::PristineCommand#execute): Better

- * lib/rubygems.rb, lib/rubygems/custom_require.rb: Correctly include

- documentation for methods added to Kernel.

-2007-01-07 Eric Hodel <drbrain@segment7.net>

- * Rakefile: Include GPL.txt. Fixes bug #7572 by David Lee.

-2007-01-06 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to version

- * lib/rubygems/specification.rb

- (Gem::Specification::test_suite_file): Rewrote default_executable

- to be a bit more explicit.

- (Gem::Specification::add_bindir): Rewrote the 'files' accessor to

- handle pathologically bad input.

- (Gem::Specification::copy_of): Added as_array private method.

- * Rakefile (package_version): Added '*.out' to clobber list.

- Removed the broken-1.0.0.gem file from the clobber list.

- * test/test_specification.rb

- (TestSpecification::test_default_executable):

- Seriously beefed up tests for certain specification issues.

- * test/gemenvironment.rb (TestEnvironment::create): Added the 'f'

- flag to deleting 'gemhome'.

-2006-12-30 Eric Hodel <drbrain@segment7.net>

- * post-install.rb, lib/rubygems/server.rb: RubyGems now installs RDoc

- and ri for itself.

-2006-12-28 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb (Gem::Installer#build_extensions):

- Extension build failures now raise Gem::Installer::ExtensionBuildErrors.

-2006-12-26 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/package.rb (Gem::Package::TarInput#initialize): Bad

- packages now raise FormatError instead of a generic RuntimeError.

- * lib/rubygems/installer.rb (Gem::Installer#install): Raise an

- InstallError when we have a bad gem file.

-2006-12-25 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/custom_require.rb (Gem::GemPathSearcher::find):

- Removed SUFFIX_PATTERN. Evidently this was miss during an earlier

- attempt to remove it.

- (Gem::GemPathSearcher::matching_file): Changed reference to

- SUFFIX_PATTERN into a call to Gem.suffix_pattern.

- * Removed tab characters from numerous source files.

- * lib/rubygems/installer.rb (Gem::Uninstaller::uninstall): Removed

- stray tab characters.

- * lib/rubygems.rb (Kernel::require_gem): Added file and line

- number information to require_gem worning (makes it easier to

- track down those offending lines of code).

- (Kernel::location_of_caller): Added helper function to determine

- file and line number of caller.

-2006-12-25 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb (Gem::Installer#app_script_text):

- Simpler, more readable bin script.

- * lib/rubygems/gem_commands.rb (Gem::PristineCommand#execute):

- Regenerate bin scripts. This will clean up require_gem in scripts.

-2006-12-24 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb (Gem::RemoteFetcher#fetch_path):

- Rescue various errors and return a more-friendly error.

-2006-12-23 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/command.rb lib/rubygems/gem_commands.rb: Make help

- output fit in 80 columns.

- * lib/rubygems/rubygems_version.rb: Bump version to 0.9.0.8, beta

- time! (Oops, didn't go into beta.)

-2006-12-20 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_fetcher.rb (Gem::RemoteFetcher#fetch_size): Give

- a sensible error on bad URIs.

- * lib/rubygems/gem_commands.rb (Gem::SourceCommand): Allow management

- of sources in source_cache. Fixes bug #1128.

- * lib/rubygems.rb (Kernel#require_gem): Add deprecation warning in

-2006-12-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb (Gem::ExtBuilder): Refactored for

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller#specs_n_sources_matching): Don't display gems

- that can't be installed.

- * lib/rubygems.rb, pre-install.rb: Fix installation errors on 1.9.

- Fixes bug #4536 by Ryan Davis.

- * lib/rubygems/source_index.rb, lib/rubygems/gem_commands.rb,

- lib/rubygems-custom_require.rb: Use File.join with glob strings.

- Fixes bug #1096 submitted by Chad Fowler.

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller#install_dependencies): Make --force actually

- force. Fixes bug #7365 by Robert James.

-2006-12-18 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/gem_commands (Gem::OutdatedCommand): Add a way to see

- which gems are out-of-date.

- * setup.rb: Ignore errors for .config and InstalledFiles when

- the source path is read-only/NFS. Fixes bugs #1395 and #1374. Patch

- * bin/gem_server: Pull code out into lib/rubygems/server.rb for

- reusability. Closes Feature Request #2220 by Chris Morris.

-2006-12-16 Chad Fowler <chad@chadfowler.com>

- * test/: Added functional test for extension gems proving that

- non-compiling extensions don't result in success message.

- * lib/rubygems/specification.rb: Raise exception if loaded spec is

- nil. Closes bug #7299.

- * test/gemenvironment.rb: Clean out gemhome every time to avoid dirty

- directory failing tests.

- * lib/rubygems/installer.rb: Change uninstall to require a full gem

- name (not a partial match). Fixes bug #6007 and related unreported

-2006-12-15 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/installer.rb (Gem::Uninstaller): Correctly uninstall

- executables if GEM_HOME is set. Patch #2264 by Sylvain Joyeux.

- * lib/rubygems.rb (Gem::loaded_specs): Expose list of currently loaded

- * lib/rubygems/gem_commands (Gem::UninstallCommand): Allow multiple

- gems to be uninstalled at once.

-2006-12-14 Eric Hodel <drbrain@segment7.net>

- * post-install.rb: Don't attempt to read unreadable files. Fixes

-2006-12-13 Eric Hodel <drbrain@segment7.net>

- * pre-install.rb.rb, post-install.rb: Don't call manage_gems because

- we don't have sources installed yet. Bump version requirement to

- 1.8.2 since rubygems/open-uri.rb was removed. Should fix bug #6206.

- * lib/rubygems/installer.rb (Gem::Installer#build_extensions): Capture

- stderr into results when building extensions.

- * lib/rubygems/gem_commands.rb (Gem::ContentsCommand): Allow version

- to be passed to gem contents. Not backwards compatible, -v now -V and

- vice versa. Select newest gem for contents. Fixes bugs #2723, #7225.

- Patches by Sava Chankov, Tom Pollard.

- * lib/rubygems/gem_commands.rb (Gem::InstallCommand#execute): Allow

- install errors to result in non-zero exit code. Fixes bug #2773.

-2006-12-03 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/remote_installer.rb (Gem::RemoteInstaller#install):

- Add :cache_dir option to override the default.

- * lib/rubygems/remote_installer.rb (Gem::RemoteInstaller#download_gem):

- Check cache to see if the gem has been cached before downloading.

-2006-12-02 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems.rb (Gem::OperationNotSupportedError::suffixes,

- Gem::OperationNotSupportedError::suffix_pattern): Removed

- duplicate copies of the SUFFIX_PATTERN by providing a global

- method Gem.suffixes and Gem.suffix_pattern.

- * lib/rubygems/remote_fetcher.rb (Gem::open_uri_or_path): Reworked

- the connection options for the open-uri call. Since we are not

- using the rubygems supplied open_uri, we can use some new options

- available that make proxy handling much easier.

- (Gem::file_uri): Renamed is_file_uri to file_uri?.

- * lib/rubygems/loadpath_manager.rb (Gem::LoadPathManager::self):

- Added .jar to list of suffixes.

- * test/functional.rb (FunctionalTest::test_env_remotesources):

- Changed test to uses Gem.sources (the sources method on

- remote_fetcher was removed).

- * test/test_remote_fetcher.rb (TestRemoteFetcher): Renamed some of

- the test constants and instance variables so that they were more

- consistent and explained the tests a wee bit better.

- (TestRemoteFetcher::test_no_proxy): Added assert_data_from_server

- and assert_data_from_proxy to make it clear what the test was

- doing and give better error messages on errors.

- (TestRemoteFetcher::assert_data_from_server): Added

- assert_data_from_server.

- (TestRemoteFetcher::assert_data_from_proxy): Added

- assert_data_from_proxy.

-2006-11-30 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/open-uri.rb: Removed the duplicated library.

-2006-11-30 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification (Gem::Specification#eql?): Allow gemspecs

- to be used intelligently with Array#- and Array#uniq.

- * lib/rubygems/installer.rb: Return extension-building results in

- Exception on build failure.

- * lib/rubygems/remote_installer.rb: Ensure gems with similar names

- cannot be matched for install. (Broken when searching was removed

- from RemoteInstaller.)

-2006-11-29 Eric Hodel <drbrain@segment7.net>

- * post-install.rb: Now requires rbconfig.

- * lib/rubygems/specification.rb, lib/rubygems/version.rb: Fixed many

- ivar warnings due to YAML specs.

- * lib/rubygems/validator.rb, lib/rubygems/validator.rb

- (Gem::Validator#unit_test Gem::RemoteInstaller::): Ensure the

- current directory is restored.

- * lib/rubygems/remote_fetcher.rb, lib/rubygems/remote_installer.rb,

- lib/rubygems/installer.rb: Raise more-friendly and less-deadly errors.

- * lib/rubygems/remote_installer.rb (Gem::RemoteInstaller#install):

- Create version requirement correctly.

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller#find_gem_to_install): Allow RemoteInstaller to

- work with SilentUI.

- * lib/rubygems/remote_fetcher.rb (RemoteFetcher#open_uri_or_path):

- Don't double-require open-uri.

-2006-11-27 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/specification.rb

- (Gem::Specification#default_executable): Fixed bug where @executables

- could be nil when loaded from index.

-2006-11-21 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/source_index.rb (Gem::SourceIndex#latest_specs): Grab

- the latest versions of everything in the index. Written by Ryan

-2006-11-20 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/cmd_manager.rb: Added PristineCommand

- * lib/rubygems/gem_commands.rb: Added PristineCommand to restore

- gems to pristine condition in the event of files begin deleted

- based on the cached .gem file

-2006-11-19 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/*_fetcher.rb: Removed code specific to remote source

- * lib/rubygems/remote_installer.rb (Gem::RemoteInstaller#search):

- Moved to Gem::SourceInfoCache#search

- * lib/rubygems/source_info_cache.rb: Taught to update itself

- * lib/rubygems/source_info_cache_entry.rb: Taught to update itself

- * lib/rubygems/source_index.rb: Taught to update itself from a uri.

-2006-11-18 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: Applied Kevin Clark's patch to make

- RubyGems recognize mkrf files.

-2006-11-17 Eric Hodel <drbrain@segment7.net>

- * test/test_remote_fetcher.rb: Don't allow files in Dir.pwd to make

- tests fail. Spotted by Chad Fowler.

- * lib/rubygems/remote_installer.rb (Gem::RemoteFetcher,

- Gem::CacheFetcher): Break out of remote_installer.rb into separate

- * lib/rubygems/remote_installer.rb (Gem::SourceInfoCache,

- Gem::SourceInfoCacheEntry): Allow requiring just the source cache

- without the remote fetcher.

-2006-11-16 Eric Hodel <drbrain@segment7.net>

- * test/test_local_cache.rb: Moved to better name

- * test/test_gem_source_info_cache.rb: Renamed test methods to match

- implementations. Sorted test names.

- * lib/rubygems/remote_installer (Gem::SourceInfoCache): cache_data no

- longer resets dirty flag. Sped up source cache loading. Exposed

- cache file name in use.

-2006-11-15 Eric Hodel <drbrain@segment7.net>

- * test/, lib/: Made files -w clean.

- * test/: Made tests run independently.

- * Rakefile: Tests now run with warnings on.

-2006-11-14 Eric Hodel <drbrain@segment7.net>

- * lib/rubygems/user_interaction.rb (Gem::StreamUI#progress_reporter):

- Fix for Gem.configuration.verbose = nil, false

- * lib/rubygems.rb (Gem::configuration): Fix RakeFileUtils pollution.

-2006-10-05 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/installer.rb (Gem::Installer::shebang): Updated to

- optionally call env_shebang if the command line option is set.

- (Gem::Installer::shebang_env): Added this method.

-2006-09-25 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to version

- * lib/rubygems/security.rb (Gem::Security::Exception): Added

- permissions for cert files and directories.

- (Gem::Security::Policy::verify_gem): File.exists? => File.exist?

- (Gem::Security::self.verify_trust_dir): Beefed up code to create

- trust directory structure.

- (Gem::Security::self): Apply permissions when creating trust

- * lib/rubygems/package.rb (TarInput::initialize): File.exists? =>

-2006-09-24 Jim Weirich <jim@weirichhouse.org>

- (Gem::OperationNotSupportedError::configuration): Added

- method_missing to configuration hash to allow nicer reference

-2006-09-22 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::initialize): Proxy patch fixup to

- escape user/password from Anatol Pomozov.

- (Gem::RemoteSourceFetcher::connect_to): Proxy patch fixup to

- escape user/password from Anatol Pomozov.

- * test/test_remote_fetcher.rb (TestRemoteFetcher::setup): Proxy

- patch fixup to escape user/password from Anatol Pomozov.

- (TestRemoteFetcher::test_no_proxy): Proxy patch fixup to escape

- user/password from Anatol Pomozov.

- * test/io_capture.rb (Gem::IoCapture): Created new IoCapture

- module to handle capturing output of code under test.

- * test/test_installer.rb

- (TestInstaller::test_generate_bin_symlinks_win32): Removed ugly

- $TESTING hack and substituted new io capture module.

- (TestInstaller::test_install_with_message): Removed one-off stdout

- capture and replaced with new IO Capture module.

-2006-09-19 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to version

- * test/test_version_comparison.rb (TestRequirementEquality): Added

- more tests for Dependency equality testing and one additions check

- for requirement vs non-requirement equality.

- * lib/rubygems/version.rb (Gem::Dependency::==) Fixed '=' bug in

-2006-09-18 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/remote_installer.rb

- Only show the last 3 gem versions on a multiplatform remote

-2006-09-18 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller::install): Added Hugh Sasse's patch for

- skipping gems on install.

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to 0.9.0.2.

- * lib/rubygems/version.rb (Gem::Dependency::hash): Added hash code

- --http-proxy, the ENV var http_proxy and with no proxy.

-2006-08-26 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller::download_gem): Fixed download_gems so that

- it properly passes the proxy option to the fetcher class. (based

- on patch by Andy Shen).

-2006-08-12 Jim Weirich <jim@weirichhouse.org>

- * bin/index_gem_repository.rb (Indexer::sanitize): Added a

- sanitize step to the gem index generation in the hope of avoiding

- problems with non-ASCII names in the yaml data.

-2006-06-14 Jim Weirich <jim@weirichhouse.org>

- * Rakefile (announce): Added 1.9 hack for ENV['CERT_DIR']. Remove

- this in the future if 1.9 behavior changes.

-2006-06-13 Jim Weirich <jim@weirichhouse.org>

- * Rakefile: ENV['CERT_DIR'] is now '' rather than nil.

- * lib/rubygems/specification.rb (Gem::Specification::initialize):

- Eric added some 1.9 compatibility code (funcall vs send).

- * lib/rubygems/package.rb (TarOutput::self): Eric added some 1.9

- compatibility code (funcall vs send).

- * experimental/deployment.rb (Gem::Deployment): Moved the

- deployment code out of the live code base into the experimental

- directory. The code wasn't used and the tests were not all

-2006-06-11 Jim Weirich <jim@weirichhouse.org>

- * bin/gemri: Added gemri to bin directory.

- * lib/rubygems/custom_require.rb (Gem::GemPathSearcher::find):

- Added .rbw to suffix pattern in custom_require.

-2006-06-07 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems.rb: Added copyright notices to all Ruby files.

-2006-04-07 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_commands.rb (Gem::RDocCommand::execute): Added

- RI option to the rdoc subcommand.

-2006-04-05 Jim Weirich <jim@weirichhouse.org>

- * test/test_parse_commands.rb

- (TestParseCommands::test_parsing_update_options): Fixed unit tests

- to assert that the install dir is expanded.

- * lib/rubygems/doc_manager.rb (Gem::DocManager::generate_ri):

- Break out from generate_rdoc to support installing all RI docs

- * lib/rubygems/gem_commands.rb

- (Gem::InstallUpdateOptions::add_install_update_options): Expanded

- repository directory to absolute path.

- (Gem::InstallCommand::execute): Make sure that *all* of the RI

- documents are generated before generating any RDocs (due to a bug

- in the RDoc library).

- * lib/rubygems/installer.rb (Gem::ExtExtConfBuilder::self): Fixed

- typo in ExtExtConfBuilder that prevented C based gems to install.

- (Gem::ExtExtConfBuilder::self): Installed patch to prevent the

- overriding of target_prefix in native extensions (thanks to Aaron

- Patterson for the patch).

-2006-04-04 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/rubygems_version.rb (Gem): Bumped to version

- * lib/rubygems/incremental_fetcher.rb

- (Gem::IncrementalFetcher::update_cache): Now falls back to bulk

- updates if the number of gems if over 50.

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::source_index): Added "bulk" to the

- update message to differentiate it from the incremental message.

- * lib/rubygems/specification.rb

- (Gem::Specification::Specification): Modified to add dashes to

- gemspecs generated under Ruby 1.8.3. This makes it easier to run

- RubyGems on a 1.8.2 system.

-2006-04-01 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/doc_manager.rb (Gem::DocManager::run_rdoc): Changed

- exception handler to print error message if document generation

- fails, but then to continue with the rest of the installation.

- Permission errors still terminate the install because if one

- install fails because of permission problems, chances are that all

- (Gem::DocManager::install_ri): Removed wrapping of exceptions with

- DocumentError. Most exceptions now don't propagate out of

- (Gem::DocManager::install_rdoc): Removed wrapping of exceptions

- with DocumentError. Most exceptions now don't propagate out of

-2006-02-23 Jim Weirich <jim@weirichhouse.org>

- * bin/index_gem_repository.rb (MasterIndexBuilder::cleanup): Fixed

- bug where we were trying to read the index file (to compress it)

- before it was closed, often leading to a truncated index file.

-Tue Jan 24 16:26:13 2006 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/config_file.rb

- Luca Pireddu reported a fatal error when permissions on

- .gemrc were too restrictive. Fixed.

-Tue Dec 6 14:51:13 2005 Jim Weirich <jim@tardis>

- * lib/rubygems/source_index.rb

- (Gem::SourceIndex::load_specification): Added an untaint call to

- make the code run in SAFE=1 mode under 1.8.3.

- (Gem::SourceIndex::load_gems_in): Untaint here too.

- * lib/rubygems/installer.rb (Gem::Installer::install): Untaint

- (Gem::Installer::extract_files): Untaint here too.

- * lib/rubygems/custom_require.rb

- (Gem::GemPathSearcher::matching_file): Untaint here too.

- * test/gemenvironment.rb: Added $SAFE=1 to the test environment to

- make sure we can run in $SAFE mode.

-2005-12-03 Jim Weirich <jim@tardis>

- * lib/rubygems/rubygems_version.rb (Gem): Bumped version to

- * lib/rubygems/user_interaction.rb

- (Gem::StreamUI::SimpleProgressReporter::done): Added several new

- progress reporters.

- * lib/rubygems/command.rb

- (Gem::Command::specific_extra_args_hash): Added --verbose

- * lib/rubygems/config_file.rb (Gem::ConfigFile::handle_arguments):

- Added --traceback as alias for --backtrace (I always get them

- (Gem::ConfigFile::initialize): Added a verbose option.

-2005-11-28 Jim Weirich <jim@tardis>

- * lib/rubygems/remote_installer.rb

- (Gem::SourceInfoCacheEntry::replace_source_index): Fixed the

- SourceIndexCacheEntry so that it will manufacture an empty source

- index if given a nil value for the +si+ value.

-2005-11-08 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems.rb: Ara Howard's fix to allow 0.0.0 to be a valid gem

-2005-11-08 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: Fixed bug in gem unpack. It was

- sorting incorrectly, resulting in the wrong version being unpacked in

- some edge cases. Thanks to Jakob Skjerning for the detailed bug report.

-2005-11-03 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: Fixed bug that would cause the executables

- from the wrong gem to be uninstalled if the names matched the same

- regex. Thanks Eric Hodel.

-2005-11-01 Jim Weirich <jim@tardis>

- * lib/rubygems/gem_commands.rb (Gem::UpdateCommand::initialize):

- Upgrade => Update change.

- (Gem::UpdateCommand::execute): Upgrade => Update change.

-2005-11-01 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: Allow gem unpack to accept a gem file

- path instead of gem name: gem unpack mygem-1.0.0.gem.

-2005-10-31 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: Tilman Sauerbeck's patch to support

- extensions built with Rake!

-2005-09-13 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/package.rb (TarInput::initialize): Removed

- requirement for SSL when signatures are found in a gem. Only

- require SSL if the security policy requires checking the

- * lib/rubygems/custom_require.rb (Kernel::require): Disabled

- autorequire during custom require.

-2005-09-07 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_openssl.rb (Gem::ensure_ssl_available): Added a

- test in gem_openssl to make sure the ruby portion of ssl is also

-2005-08-31 Jim Weirich <jim@weirichhouse.org>

- * Rakefile (install): Changed the rake install task to use setup.rb.

-2005-07-08 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/remote_installer.rb: Applied Daniel Roux's patch

- to make RubyGems work with authenticating proxies.

-2005-07-08 Jim Weirich <jim@weirichhouse.org>

- * Preparing for release 0.8.11.

-2005-06-12 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/installer.rb

- (Gem::Installer::installation_satisfies_dependency): Refactored

- dependency check into ensure_dependency! and

- installation_satisfies_dependency?.

-2005-06-12 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems.rb,lib/rubygems/installer.rb: Applied Mark Hubbart's

- * lib/rubygems/remote_installer.rb: Applied David Glasser's install-

- * Applied Paul Duncan's incredibly complete gem signing patch.

- * lib/rubygems/installer.rb: Fixed bug in installer that caused

- dependency installation not to work.

-2005-06-06 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb: Fixed Erik hatcher's reported bug

- of gem directories having "-" at the end of their names (e.g.

- "BlueCloth-1.0.0-".

-2005-06-01 Jim Weirich <jim@weirichhouse.org>

- * scripts/specdoc.rb (_resolve_links): Updated to generate hieraki

- format so it can be included in the docs.rubygems.org site.

- * test/test_specification.rb (TestSpecification::test_to_ruby):

- Fixed test on date that hard-coded a specific date.

-2005-05-29 Jim Weirich <jim@weirichhouse.org>

- * Changes from the Seattle Code fest: (1) Package list command

- (e.g. gem inspect GEM). (2) .gemrc settings now allow cvsrc like

- options to set defaults per subcommand. (3) The autorequire spec

- attribute will now accept a list. (4) Binwrappers vs symlinks

- (more info to follow). (5) Substituted Time for Date in specs,

- increasing performance dramatically in an important area.

-2005-05-04 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems.rb (Gem::Exception::find_home): Changed rescue

- clause from Exception to StandardError. Exception doesn't seem to

- catch everything ... I'm not sure I understand why.

-2005-04-29 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specifiation.rb: Marcel Molina's patch to discover

- which attributes in the spec are Array attributes.

-2005-04-27 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: -y is now a synonym for

- --include-dependencies

-2005-04-21 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: Added non-require_gem dependency check

-2005-04-03 Chad Fowler <chad@chadfowler.com>

- * pre-install.rb: Added version check to RubyGems installation.

-2005-03-25 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/rubygems_version.rb (Gem): Created release for

- * lib/rubygems/gem_commands.rb

- (Gem::UpdateCommand::do_rubygems_update): Update --system now runs

- the ruby command directly rather than trying to load the

- update-rubygems command. There were too many things to go wrong

-2005-03-24 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller::find_dependencies_not_installed): Fixed to

- reload source index before attempting to detect dependencies.

-2005-03-23 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller::find_dependencies_not_installed): Switched

- to using SourceIndex#find_name to detect missing dependencies,

- avoiding a gem activation during an install.

- * lib/rubygems/installer.rb (Gem::Installer::install): Removed

- activate call from install step. If we need to do something about

- dependencies at this time, then we need a better way to do them.

- * lib/rubygems.rb: Removed the require for rubygems/timer.

-2005-03-16 Jim Weirich <jim@weirichhouse.org>

- * test/gemenvironment.rb (TestEnvironment::create): Added require

- * lib/rubygems/source_index.rb (Gem::SourceIndex::initialize):

- Allowing default argument to new to be an empty hash.

- (Gem::SourceIndex::from_installed_gems): Refactored into a class

- method that invokes a instance method.

- (Gem::SourceIndex::refresh): Refresh now does a complete reload

- from disk. This should be more accurate that the earlier version.

- * lib/rubygems/installer.rb (Gem::Uninstaller::uninstall): removed

- unneeded refresh!.

- * lib/rubygems.rb (Gem::Exception::source_index): Removed

- automatic refresh from Gem.source_index ... it wasn't reliable

- when removing installed gems.

- (Gem::Exception::activate): Added detection of previously loaded

-2005-03-15 Chad Fowler <chad@chadfowler.com>

- * bin/gem_server: (htonl) rdoc opens in existing browser window.

-2005-03-14 Jim Weirich <jim@weirichhouse.org>

-2005-03-13 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/installer.rb (Gem::Installer#shebang): Refactored and

- stripped result to avoid ^M issues.

-2005-03-11 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_commands.rb (Gem::DependencyCommand): Added a

- new command "gem dependency" to show the dependencies of an

- * lib/rubygems/cmd_manager.rb (Gem::CommandManager::initialize):

- Added DependencyCommand to the command manager registrar.

- * lib/rubygems/version.rb (Gem::Requirement): Unnested Requirement

- from the Version class. There was no benefit to having it nested.

- Gem::Version::Requirement is set to point to the new class so to

- be compatible with old gems.

- * lib/rubygems/installer.rb (Gem::Uninstaller::ask_if_ok): Changed

- uninstaller confirm message to read 'Continue with uninstall'.

- Its clearer that way.

- * lib/rubygems.rb (Gem::Exception::required_location): Switch to

- use SourceIndex#find_name rather than search. Made sure a nil

- value is returned with a path is not found.

- * lib/rubygems/source_index.rb (Gem::SourceIndex::search): Changed

- parameter name to gem_pattern to emphasize using Regex in search.

- (Gem::SourceIndex::find_name): Added find_name to handle the

- common case of searching for an exact match on the short name.

- * lib/rubygems.rb (Gem::Exception::activate): Make sure that

- activate more closely adheres to honoring the auto_require=>false

- (Gem::Exception::report_activate_error): Out of line error

- reporting for activate.

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller::find_dependencies_not_installed): Found

- another location that was using require_gem with auto_require.

- Fixed to use :auto_require=>false.

- * lib/rubygems/gem_commands.rb

- (Gem::InstallUpdateOptions::add_install_update_options): Added

- --ignore-dependencies option. Still needs to be wired to logic.

- * lib/rubygems/installer.rb (Gem::Installer::install): Added call

- to require_gem_with_options.

- * lib/rubygems.rb (Kernel::require_gem_with_options): Added to

- allow easier specification of the autorequire flag for

-2005-03-10 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::normalize_uri): Normialize a URI to

- start with http:// if it does not already.

- * test/test_deployment.rb (TestDeployment::xtest_deploy_sources):

- Disabled this test. It is part of the new deployment software and

- is not working yet.

-2005-03-09 Jim Weirich <jim@weirichhouse.org>

- * lib/gemconfigure.rb (Gem::self): Added to aid dynamic

- * lib/rubygems/command.rb (Gem::Command::command_manager): Moved

- command_manager to base class.

- * lib/rubygems/gem_commands.rb (Gem::CleanupCommand::execute):

- Both implicit and explicit gems now work with cleanup.

-2005-03-08 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/installer.rb (Gem::Uninstaller::ok_to_remove):

- Fixed source index to be loaded from the installed gems when doing

- an "OK TO REMOVE" dependency check.

-2005-03-06 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/deployment.rb: beginning of a deployment capability

- * test/test_deployment.rb: first tests of new deployment system

-2005-03-04 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: Small bugfix for the case when you

- pass in a gem name (or more) to cleanup for the cleanup command.

-2005-03-04 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/installer.rb (Gem::Uninstaller::ok_to_remove):

- Reworked logic in uninstall to be intelligent about dependencies.

- We only complain about dependencies if removing a gem will cause a

- dependency error. The uninstaller now checks for :ignore, :all

- and :executables options.

- * lib/rubygems/cmd_manager.rb (Gem::CommandManager::initialize):

- Registered Cleanup command.

- * lib/rubygems/gem_commands.rb (Gem::CleanupCommand): Added

- Cleanup command to gem.

- (Gem::UninstallCommand::initialize): Added --all, --ignore and

- --executables options to uninstall. This helps to avoid excessive

- YESes all the time.

-2005-02-28 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::LocalSourceInfoCache::write_cache): Open cache file in

-2005-02-28 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/config_file.rb: don't warn about not being able to

- * lib/rubygems/doc_manager.rb: (for DHH) don't install rdoc docs for

- * lib/rubygems/gem_commands.rb: Print which gems are updated on 'gem

- update'. If --system is used, report that the rubygems system

- software has been updated.

- * lib/rubygems/installer.rb: Cleaned up the uninstall has_dependents

- logic and output. It was misleading and buggy before.

-2005-02-27 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/config_file.rb

- (Gem::ConfigFile::default_config_file_name): Fixed bug in finding

- home directory for the .gemrc file.

-2005-02-27 Chad Fowler <chad@chadfowler.com>

- * Fixed a small bug with shebang construction

-2005-02-26 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/doc_manager.rb (Gem::DocManager::generate_rdoc):

- Removed warning about generating rdocs on gems w/o an rdoc flag.

- * lib/rubygems/gem_commands.rb

- (Gem::UpdateCommand::do_rubygems_update): Added --system option to

- update to specifically update the version of rubygems.

- (Gem::UpdateCommand::which_to_update): Fixed some refactoring bugs

- in the which_to_update method.

- * lib/rubygems/remote_installer.rb

- (Gem::LocalSourceInfoCache::read_cache): switched to Marshal

- rather than Yaml for local cache.

- * bin/gem: Added requirement for Ruby >= 1.8.0.

-2005-02-10 Chad Fowler <chad@chadfowler.com>

- * bin/gem_server: Added Martin Ankerl's wonderful new gem_server

-2005-01-27 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: Fixed

- `gem update` so it accepts a list of gems to update and _only_

- * lib/rubygems/installer.rb: Fixed a bug in the new shebang code.

- * lib/rubygems/remote_installer.rb: Attempt to fix Curt Hibbs'

- reported Proxy bug without actually having a proxy to test with.

-2005-01-22 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/custom_require.rb: Lyle Johnson's fix for Bug #1379

-2005-01-20 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/validator.rb: Applied Austin Ziegler/Kasper Schiess's

- patch to fix unit test running bug.

-2005-01-14 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: attempt at fixing Ryan Davis's

- reported Shebang bug. STILL NOT WORKING, because it doesn't work

- with ^M characters.

- * lib/rubygems/config_file.rb: small but ugly error fixed if no

- config file exists.

- * lib/rubygems/remote_installer.rb: Fixed bug http://rubyforge.org/tracker/index.php?func=detail&aid=1331&group_id=126&atid=575.

-2005-01-01 Chad Fowler <chad@chadfowler.com>

-2004-12-31 Jim Weirich <jim@weirichhouse.org>

- * Rakefile: Switch to standard Rake test tasks.

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::read_data): Added a retry to try a

- lower case gem name if the open failed. This fixes a problem

- where case differences are preventing some gems from installing.

-2004-12-29 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_commands.rb (Gem::InstallCommand::execute):

- Changed the RemoteInstaller to take an options hash rather than

- individual options. This will leave the interface more resilient

- to changes as more options are added

- (e.g. --install_dependencies).

- * lib/rubygems/specification.rb (Gem::Specification): Marked array

- attributes explicitly. This allows for explicit conversion to

- arrays when assigned.

- * test/test_specification.rb

- (TestSimpleSpecification::test_array_attributes): Added test for

- array_attributes forcing values to arrays.

-2004-12-28 Jim Weirich <jim@tardis>

- * lib/rubygems.rb (Gem::Exception::ensure_gem_subdirectories):

- Fixed the Ryan Davis patch to work correctly when directories are

-2004-12-18 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/version.rb: Erik Veenstra's sort patch.

- * lib/rubygems.rb: Ryan Davis's installation bug fix.

-2004-12-14 Gavin Sinclair <gsinclair@soyabean.com.au>

- * test/test_loadmanager.rb: invalidated it as a unit test; it's

- incompatible with custom_require.rb.

-2004-12-12 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/custom_require.rb: simple bug fix.

-2004-12-12 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/custom_require.rb: new file to replace

- loadpath_manager.rb and speed up the custom require functionality.

- * lib/rubygems/timer.rb: new file; simple benchmarking tool that's

- useful at the moment but needn't stay in RubyGems permanently.

- * lib/rubygems/source_index.rb: include Enumerable and implement #size

- * lib/rubygems/specification.rb: removed lazy initialisation of

- attributes to reduce #copy_of invocations; folded

- Specification.copy_of into Specification#copy_of.

- * lib/rubygems.rb: require 'rubygems/custom_require' instead of

- 'rubygems/loadpath_manager'; removed out of date documentation; added

- "require 'rubygems/timer'" to temporarily assist with benchmarks.

-2004-12-07 Jim Weirich <jim@weirichhouse.org>

-2004-12-06 Jim Weirich <jim@weirichhouse.org>

- * test/test_specification.rb

- (TestLegacyYamlSpecification::test_load): Fixed test to avoid the

- __FILE__ stuff. Running tests from rakefile guarantees that the

- file paths start from the right location.

- * pkgs/sources/sources.gemspec: Made Gem.sources_spec idempotent.

- * lib/rubygems/specification.rb (Gem::Specification::initialize):

- Added @@gather to Gem::Specification to facilitate proper loads.

- (Gem::Specification::Specification): Added Specification.load.

- * lib/rubygems/source_index.rb (Gem::SourceIndex): Fixed comments

- 'long name' => 'full name'.

- * lib/rubygems/gem_commands.rb (Gem::BuildCommand::load_gemspecs):

- Changed to use Gem.Specification.load.

- * Rakefile: Added sources-*.gem to clobber list.

- (egrep): Upgraded the DBG finder to include breakpoint.

- * post-install.rb (install_sources): Using block version of chdir.

- * lib/rubygems/remote_installer.rb

- (Gem::LocalSourceInfoCache::read_cache): Fixed initialization of

- * lib/rubygems.rb: Updated version to 0.8.2.

-2004-12-04 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::LocalSourceInfoCache::writable_file): Now just returns the

- selected cache file (which was selected based on writability).

- (Gem::LocalSourceInfoCache::try_file): Added try_file to determine

- if a file is a candidate for a cache file.

- (Gem::LocalSourceInfoCache::select_cache_file): Added failure if

- there are not valid cache file candidates.

- * lib/rubygems.rb (Gem::Exception): Renamed @@cache to

- (Gem::Exception::source_index): Renamed Gem.cache to

- Gem.source_index (but left cache as an alias).

-2004-12-03 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb (Gem::LocalSourceInfoCache):

- Added a local cache manager object to implement the read/write

- policies on the system and user cache files.

- (Gem::LocalSourceInfoCache::update): Added update and flush to the

- caching fetcher so that it knows when it needs to update the local

- (Gem::RemoteInstaller::initialize): Switched to using a cached

- fetcher in the remote installer. All the caching logic was

- removed from the installer. User writable cache files are now

- (Gem::RemoteInstaller::write_gem_to_file): write_gem_to_file now

- will create the path if needed.

-2004-12-02 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/package.rb (TarInput::zipped_stream): To workaround

- a problem with earlier than 1.2.1, we read the zipped data into a

- string, and then return an IO object on that string.

- (TarInput::each): Refactored getting a stream to the zipped data

- into <tt>zipped_stream</tt>.

-2004-12-01 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::convert_spec): We now proprocess the

- yaml string data to reduce it in size. This was done to

- workaround a problem with large YAML files (although it is just a

- temporary fix because our yaml data keeps growing and growing).

- * Rakefile: Added more targets to the clobber target.

- * test/test_remote_fetcher.rb

- (TestRemoteFetcher::test_explicit_proxy): Added tests for proxy

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::connect_to): Refactored to add proxy

-2004-11-28 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/loadpath_manager.rb: Added Mauricio's patch to work

- around string contains null byte issue.

-2004-11-27 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteSourceFetcher::get_size): Switched from open-uri with

- early abort to an HTTP.head call to get the size of the yaml file

-2004-11-26 Jim Weirich <jim@weirichhouse.org>

- * test/test_specification.rb

- (TestDefaultSpecification::test_defaults): Added test for some

- basic defaults in a gem spec.

- * test/test_remote_installer.rb (MockFetcher::source_info): Made

- the fake test data more realistic.

- (TestRemoteInstaller::test_source_info): Improved tests.

-2004-11-26 Jim Weirich <jim@tardis>

- * test/test_remote_installer.rb (MockFetcher): Added MockFetcher

- to make testing the remote installer easier. Currently there are

- two remote installer test classes. Eventually TestRemoteInstaller

- will succeed RemoteInstallerTest, which is very incomplete.

- * test/test_package.rb (TC_TarReader::TC_TarInput): Made the unit

- test ignore the setgid bit. The setgid bit doesn't work on my

- laptop for some reason. This may be a problem with my laptop

- rather than with this code. Should investigate further.

- * lib/rubygems/remote_installer.rb (Gem::RemoteSourceFetcher):

- Added a Fetcher object to the remote installer to handle all the

- details of getting the remote information. This allows testing

- the logic of the remote installer without actually doing remote

- (Gem::RemoteInstaller::sources): Renamed get_caches to

- source_info. The problem is that cache is too generic and there

- are actually several things that we will cache in the system.

- * lib/rubygems/cache.rb (Gem::Cache::self): Changed interface to

- from_installed_gems slightly.

- (Gem::Cache::self): Reordered rescue clauses so that the syntax

- exception might actually be handled.

- * lib/rubygems.rb (Gem::Exception::ensure_gem_subdirectories):

- Dumped the check_gem_subdirectories method to use the almost

- identical ensure_gem_subdirectories method.

- (Gem::Exception::ensure_gem_subdirectories): Only attempt to

- create the gem subdirectories if we can actually write them.

- * bin/gem_server: Added date of last file modification to header

- of /yaml. This is in preparation for using a head command with

- date/time stamping in fetching the source cache.

-2004-11-25 Ryan Davis <ryand@zenspider.com>

- * lib/rubygems.rb: Added GEM_SKIP functionality, which will tell

- loadpath_manager not to load specific libs from gems. For

- testing/ development purposes. Created by Ryan Davis.

-2004-11-24 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb: Allow multiple authors per gem.

- * lib/rubygems/gem_commands.rb: command line error message if you

- run 'gem install' with no args.

- * lib/rubygems/loadpath_manager.rb: Fixed @specs bug as reported by

- Lothar Schulz on ruby-talk.

-2004-11-07 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems.rb,lib/rubygems/installer.rb,lib/rubygems/cache.rb

- lib/rubygems/remote_installer.rb,lib/rubygems/gem_commands.rb:

- Fixes to make non-root installation work properly. Still need to

- fix uninstallation.

- * lib/rubygems/gem_commands.rb: Allow multiple gems/gem names on the

- command line for install.

-2004-10-31 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/version.rb,test/test_version_comparison.rb: Patrick May's

- * post-install.rb: Patrick May's fix for rubygems lib not being found

-2004-10-29 Chad Fowler <chad@chadfowler.com>

- * packages/,pkgs,install.rb: renamed "packages" to "pkgs" to avoid

- * remote_installer.rb: Added user-agent reporting for remote

- * setup.rb,install.rb,bin/update_rubygems: removed install.rb and

- added setup.rb and post-install.rb. Changed update_rubygems so that

- params passed to it can be passed on to setup.rb

-2004-10-25 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/installer.rb

- (Gem::Uninstaller::remove_executables): Corrected spelling of

-2004-10-24 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/version.rb (Gem::Version::Requirement::self): Now

- properly handles arrays of version constraints.

- * lib/rubygems/loadpath_manager.rb

- (Gem::LoadPathManager::Gem::Specification): Added comments

- describing the fast Spec class purpose. Added to_s to

- Gem::Specification (both fast and slow versions).

- (Gem::LoadPathManager.paths): Returns (cached) list of gem paths.

- (Gem::LoadPathManager::self): Refactored to use glob_over in

- search_loadpaths and search_gempaths.

- * lib/rubygems/installer.rb: Added some requires.

- * lib/rubygems/cache.rb (Gem::Cache::refresh): Fixed refresh! to

- call load_specification on the Cache class, not on itself.

- * lib/rubygems.rb (Gem::Exception::activate): added comments to

- activate. Also made sure that partial name matches in the gem

- cache search were avoided.

- (Gem::Exception::clear_paths): Added code to clear the gem cache

- when reseting the gem paths.

- (Gem::Exception::require): Added a function to take a gem name and

- a library file name (in that gem) and return a path to the library

- in the gem. David HH was interested in this in order to speed up

- some require statements under ModRuby. Eventually I hope we won't

- need these special tricks.

- (Gem::Exception::latest_partials): Fixed bug that assumed exactly

- three digits in a version number.

- * Rakefile (egrep): Added two tasks to find all the FIXME/TODO

- markers in the source code comments and to find the DBG print

-2004-10-23 Jim Weirich <jim@weirichhouse.org>

- * test/test_specification.rb

- (TestSimpleSpecification::test_add_bindir_to_list_of_files):

- Verify that an executable doesn't need the bindir if bindir is

- (TestSimpleSpecification::test_no_bindir_in_list_of_files): Added

- test the verify that exectuable can be written without a default

- * lib/rubygems/installer.rb

- (Gem::Installer::generate_bin_scripts): Added check so that the

- bindir is access only when there are actually executables to

- install. Checking for an installable bindir was giving permission

- errors when installing test gems.

-2004-10-21 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: Show extension build errors during install

- in addition to logging them to gem_make.out

-2004-10-02 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/validator.rb,lib/rubygems/gem_commands.rb: Added

- --test option for "gem check" that runs unit tests on already-

-2004-09-30 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/specification.rb - externalized the loaded_from runtime

- var on specification

- * lib/rubygems/cache.rb - optimized cache refresh! method and refactored

- processing of files when building cache.

- * lib/rubygems/loadpath_manager.rb - fixed bug in loadpath manager in

- finding native extensions that have ext on os x, win32 and solaris

-2004-09-20 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: If file match during local install is

- a directory, don't try to treat it erroneously as a gem (bug reported

- * lib/rubygems.rb: Fixed small bug in #latest_load_paths

- (NOTE: It looks like 0.8.0/0.8.1 was released in this timeframe)

-2004-09-14 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems.rb: Fixed bug in require_gem (thanks Jamis Buck!)

- that would require a gem based on an inexact search of its name

- in the local cache. This caused copland-webrick to be loaded

- when a request was made for "copland".

-2004-09-12 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb, test/test_specification.rb: Removed

- library_stubs attribute.

-2004-09-12 Gavin Sinclair <gsinclair@soyabean.com.au>

- * scripts/specdoc.rb: Check that all attributes are documented; and

- improved formatting.

- * scripts/specdoc.yaml: test_suite_file -> test_files; finished

- * scripts/specdoc.data: misc changes.

-2004-09-11 Chad Fowler <chad@chadfowler.com>

- * test/test_parse_commands.rb: Fix failing unit tests due to Rich's fix from

- * lib/rubygems/specification.rb: Add bindir to executable path on file list

-2004-09-11 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/gem_commands.rb - got rid of stub options

- * lib/rubygems/install.rb - changed output of messages so the UI would format

- * bin/gem_server - exit! from ^c

-2004-09-09 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/loadpath_manager.rb: Small bug when gem specs have ruby

- version requirements.

- * lib/rubygems/specification.rb, lib/rubygems/gem_commands.rb: Fixed failing

-2004-09-08 Chad Fowler <chad@chadfowler.com>

- * install.rb: added stub removal to the install process

-2004-09-06 Chad Fowler <chad@chadfowler.com>

- * test/test_package.rb: Fixed failing unit test as per Mauricio's email to

- the rubygems list.

- * Fixed minor issues with Windows cmd file generation.

-2004-09-06 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/remote_installer.rb - enabled caching of source caches

- based on the size of the yaml.Z/yaml file.

-2004-08-29 Chad Fowler <chad@chadfowler.com>

- * /lib/rubygems/gem_command.rb: small big fix for local gem installs

-2004-08-28 Rich Kilmer <rich@infoether.com>

- * /lib/rubygems/installer.rb, /lib/rubygems/doc_manager.rb,

- /lib/rubygems/cmd_manager.rb - Added an exception: FilePermissionError

- which checks to ensure write access to the install/uninstall/rdoc

- destination directories and raises a nice error instead of the standard

-2004-08-28 Rich Kilmer <rich@infoether.com>

- * /lib/rubygems/installer.rb - commented out stub addition and removal

-2004-08-28 Rich Kilmer <rich@infoether.com>

- * /lib/rubygems.rb, /lib/rubygems/loadpath_manager.rb -

- this adds all the loadpath_manager stuff with the 'ultimate require hack' to

- rubygems.rb. Also, require_gem methods body has been extracted into a method

- Gem.activate that differs in the calling signature in that the second param is

- a boolean that determines whether to autorequire or not.

-2004-08-27 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/user_interaction - added ask_yes_no as a method

- which returns true/false and formats/processes the [yn] stuff.

- it also has an optional second parameter of true/false for the

- * lib/rubygems/installer.rb, lib/rubygems/remote_installer.rb,

- lib/rubygems/command_manager.rb - changed all places where ask

- was used with [Yn] to ask_yes_no

-2004-08-24 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/installer.rb: Library stubs are now installed as per

- 'library_stubs' gemspec attribute. A stub is (still) also installed

- for the 'autorequire' attribute. All library stub handling

- refactored into two new classes: LibraryStubs and LibraryStub.

- * test/test_parse_commands.rb: as per 2004-08-17 below, the 'update'

- command takes --rdoc as its default now.

-2004-08-22 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/installer.rb: fixed stub generation...i added the version

- stuff that only app stubs should have...sorry!

-2004-08-17 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb: --rdoc is default on 'update' command,

- consistent with 'install'. 'default_str' methods changed to reflect

- --rdoc being default now.

-2004-08-21 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: Proper checking for gems in local

- directory on local install. rescue Gem::LoadError to avoid ugly

- * lib/rubygems/installer.rb: created Gem::LoadError to hold extra

- metadata. Setting up for proper dependency installation on local

-2004-08-20 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb: Fixed small bug in the previous spec

- * lib/rubygems/cache.rb: Prevent catastrophic failure if a gemspec is

- * lib/rubygems/installer.rb: Fixed (in not a great way) a bug that would

- cause a zero-length spec file to be written to the gem specifications

-2004-08-19 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb: #files auto-includes any #extensions,

- #extra_rdoc_files, #test_files, etc. that weren't explicitly added

-2004-08-18 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb: One more bug with #test_files.

- Default value of [] wasn't set, resulting in an attempt to call

- * lib/rubygems/gem_commands.rb: Unit tests appear to be working now.

- Still more testing to do.

- * lib/rubygems/remote_installer.rb, lib/rubygems/installer.rb: Fixed

- minor bugs in default selections for questions asked during

- installation and uninstallation

-2004-08-17 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/specification.rb:

- - #test_suite_file and #test_files now work on older gems.

- - Added Specification.from_yaml for loading YAML gemspecs

- - #to_ruby doesn't emit 'specification_version'

- * lib/rubygems/gem_commands.rb: Updated test-on-install code to use

- Specification#test_files instead of #unit_test_suite.

- * lib/rubygems/old_format.rb: Use Specification.from_yaml

- * lib/rubygems/package.rb: Ditto

-2004-08-17 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/command.rb: --debug option to turn on $DEBUG

- * lib/rubygems/config_file.rb: ditto

-2004-08-11 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/installer.rb: The application stub now defaults to

- the latest version of the library, and optionally allows an initial

- parameter conforming to _VERSION_ to be passed to select a prior

- version of the library (this initial parameter, if present, is shifted

- off of ARGV). This change was re-added...I erased it somehow :(

-2004-08-11 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb:

- - 'gem spec X' displays spec for _latest_ version of X. Added

- '--all' option if you want to see all versions.

- - RDocCommand code cleanup and slight change: document _all_

- versions of the gem by default, not just the first.

- * lib/rubygems/doc_manager.rb: removed 'kilmer' default template

- option and obsolete error message.

-2004-08-12 Chad Fowler <chad@chadfowler.com>

- * Added "gem rdoc" command for generating docs for already-installed

-2004-08-11 Rich Kilmer <rich@infoether.com>

- * bin/generate_yaml_index: updated to work with new gem format (and use the Gem::Format

- class to read). Will deploy after testing on RubyForge.

- * lib/rubygems/gem_commands.rb: generate rdoc by default on installs (I think this is

- just good practice.

- * lib/rubygems/remote_install.rb: raise an exception if dependent gems cannot be found

-2004-08-11 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/gem_commands.rb: query is now case insensitive (as it used to be)

- * lib/rubygems/installer.rb: gem_make.out wasn't being written when an extension failed to compile.

-2004-08-11 Rich Kilmer <rich@infoether.com>

- * removed String.to_requirement...we should not modify

- base classes in Ruby! modified to get rid of said to_requirement

- with Gem::Version::Requirement.create(obj)

- * specification.rb - fixed constructor bug of version requirement...

- it now defaults to Requirement.default

-2004-08-11 Chad Fowler <chad@chadfowler.com>

- * One more specification.rb bug fixed.

-2004-08-11 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/specification.rb:

- - Added convenience class methods: attribute_names,

- attribute_defaults, default_value, required_attributes, and

- required_attribute?.

- - IMPORTANT: attribute readers now use lazy initialization, just

- like some of them did before the 2004-08-01 change. This was done

- to fix the breakage when loading older gemspecs.

- - IMPORTANT: replaced instance variable access with attribute reader

- method calls in many cases. This is in line with the above change.

- - Good documentation for the "attribute" method.

- - Renamed _copy -> _copy_of.

- * lib/rubygems/cache.rb:

- - Some fairly shallow changes. Exception handling needs improvement.

- * lib/rubygems/version.rb:

- - (Version.create) new method (for convenience)

- - (Version::Requirement.create) new method (for convenience)

- - (Version::Requirement.default) new method (for consistency)

- * test/test_specification.rb: test attribute_names instead of

- attributes. Other "class convenience" methods remain to be tested

- at this stage. Also added test classes for legacy gemspecs.

- * test/data/legacy/keyedlist-0.4.0.ruby: added.

- * test/data/legacy/keyedlist-0.4.0.yaml: added.

-2004-08-06 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/specification.rb:

- - Added convenience class methods: attribute_names,

- attribute_defaults, default_value, required_attributes, and

- required_attribute?.

- - IMPORTANT: attribute readers now use lazy initialization, just

- like some of them did before the 2004-08-01 change. This was done

- to fix the breakage when loading older gemspecs.

- - Good documentation for the "attribute" method.

- - Renamed _copy -> _copy_of.

- * test/test_specification.rb: test attribute_names instead of

- attributes. Other "class convenience" methods remain to be tested

-2004-08-01 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/specification.rb:

- - (Re)defined class methods: attribute, attributes,

- required_attribute, read_only, overwrite_accessor. @@attributes

- contains a list of attribute names and default values. This

- allows higher-level specification of gemspec attributes, and the

- handling of them in a DRY fashion.

- - to_yaml_properties now includes all properties, to ensure

- correct deserialization of a Gem::Specification object.

- - #to_ruby and #to_yaml_properties rewritten to use @@attributes

- - Introduced 'specification_version' attribute and three constants:

- NONEXISTENT_SPECIFICATION_VERSION, CURRENT_SPECIFICATION_VERSION, and

- SPECIFICATION_VERSION_HISTORY. This allows us to track changes to

- - Refactored several "helper" methods, using the new class method

- 'attribute_alias_singular', which provides a "singular" alias for

- a "plural" attribute (e.g. require_path and require_paths).

- - All gemspec attributes now defined in a uniform fashion, which

- implies that they all have valid instance variables on

- initialization. Previously, some attributes were lazily

- - Introduced attribute 'library_stubs', to allow the specification

- of several stub files. (That feature not implemented, though.)

- - Introduced attribute 'test_files' and deprecated 'test_suite_file'.

- - Provided #warn_deprecated stub of a method, but don't know what to

- - Deprecated #has_test_suite? in favour of (new) #has_unit_tests?

- - Used overwrite_accessor to provide special behaviour for the

- setting of some attributes.

- - The 'date' attribute is now a Date object. We don't need high

- resolution, and Time objects, being system-dependent, are not nice

- - Various code style changes.

- - Summary: uniform treatment of gemspec attributes; reduced code by

- refactoring; 'test_suite_file' deprecated for 'test_files';

- 'library_stubs' introduced; spec versioning introduced.

- * lib/rubygems/version.rb: (Dependency) added #to_s, #==, and an

- alias (requirements_list -> requirement_list).

- * test/test_specification.rb: several new tests: _singular_attributes,

- _deprecated_attributes, _defaults, _to_{yaml,ruby}_and_back,

- _directly_setting_dependencies_doesnt_work, and more. Plus a new

- class to give Specification a more thorough workout (TestSpecificationComplex).

- * scripts/runtest.rb: require 'pp' so it's always available in unit

-2004-07-30 Rich Kilmer <rich@infoether.com>

- * lib/rubygems/installer.rb The application stub now defaults

- to the latest version of the library, and optionally allows

- an initial parameter conforming to _VERSION_ to be passed

- to select a prior version of the library (this initial

- parameter, if present, is shifted off of ARGV).

- * lib/rubygems/version.rb correct? is now a class method on

- Version enabling Gem::Version.correct?(...)

- * lib/rubygems/install.rb make it so uninstalling a gem will

- not remove executables if another version of that gem is

- installed and needs those executables

-2004-07-26 Jim Weirich <jim@tardis>

- * lib/rubygems.rb (Gem::Exception::latest_load_paths): Added

- latest_load_paths and refactored all_load_paths to use common

-2004-07-25 Rich Kilmer <rich@infoether.com>

- * fixed bug in using --source in command.rb (removed short -s version)

- * changed spec to use the RUBY_PLATFORM for Platform::CURRENT

- * added ability to choose from list of available gems on remote install

- if (1) some of the gems are binary and (2) there are move than one.

- If the gems are all source gems, the latest is selected.

-2004-07-25 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems.rb (Gem::Exception::all_load_paths): Added

- all_load_paths utility function.

- * bin/update_rubygems: Added a command to update the gem

- installation based on a update gem.

- * Rakefile: Pulled package file list out into a constant so it can

- be reused between the package command and the gem package command.

- Added a gem package target to support rubygems updates.

-2004-07-22 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/version.rb:

- * (Requirement#initialize) initialize @version to avoid warning

- * (Dependency#initialize) initialize @version_requirement to avoid

-2004-07-19 Chad Fowler <chad@chadfowler.com>

- * install.rb: Shebang line should point to the ruby version used during

-2004-07-19 Assaph Mehr <assaph@avaya.com>

- * lib/rubygems/command.rb, packages/sources/lib/sources.rb: Added

- command-line-configurable sources.

-2004-07-18 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/validator.rb: Fixed a bug that would cause "managed"

- files to appear to be unmanaged due to differences in how the paths

-2004-07-17 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb (InstallCommand#execute): removed clear

- bug (name -> gem.name).

-2004-07-14 Rich Kilmer <rich@infoether.com>

- * added old_format.rb which is used in the (hack) in format.rb

- to detect the older version of a gem, and if present, switches

- to that class instead.

- * fixed the ARGV passing in bin/gem to ingore args past -- which

- are used for passing params to source gems (extconf.rb)

-2004-07-13 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/installer.rb, lib/rubygems/package.rb,

- lib/rubygems/format.rb, test/test_package.rb: Added Mauricio

- Fernandez's patch to replace old gem format with tar.gz format.

- Fixed some failing unit tests that resulted. Still a couple left.

- * lib/rubygems.rb: Fixed a bug introduced by the previous patch.

-2004-07-13 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems.rb: (#require_gem) added the ability to do

- "require_gem 'rake/packagetask'", for instance, which is a

- shortcut for "require_gem 'rake'; require 'rake/packagetask'".

-2004-07-13 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb: refactored --version option

- in all cases to the new VersionOption module.

-2004-07-13 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/cmd_manager.rb: added 'unpack' command.

- * lib/rubygems/gem_commands.rb (UnpackCommand): added.

- * lib/rubygems/installer.rb (Installer#unpack): added.

-2004-07-09 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/user_interaction.rb (Gem::StreamUI::ask and

- Gem::StreamUI::choose_from_list): Added flush before each gets.

-2004-07-05 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/command.rb (Gem::Command#defaults_str): added.

- * lib/rubygems/command.rb (Gem::Command#create_option_parser):

- Defaults for the options are included in the parser output.

- * lib/rubygems/gem_commands.rb: all commands which have options

- and defaults now have #defaults_str implemented.

-2004-07-05 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/command.rb (Gem::Command#create_option_parser):

- Make the argument and option sections optional. They are only

- printed if there are options or arguments defined.

-2004-07-05 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb:

- - scrubbed up the 'help' command a bit, removing its options

- - added information to 'help commands'

-2004-07-04 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb:

- - modified generic help and examples

- - improved 'list' and 'search' help, and fixed bug in 'search'

- * lib/rubygems/cmd_manager.rb:

- - explicit support for top-level commands --help and --version

- - no more support for --examples and --commands

-2004-07-04 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/gem_commands.rb:

- - added 'list' and 'search' commands ('list' is no longer an alias

- - modified return value from all 'arguments' methods (see command.rb)

- * lib/rubygems/cmd_manager.rb: added 'search' command.

- * lib/rubygems/command.rb:

- (Command#create_option_parser): enhanced the option parser for 'help'

- (Command#remove_option): added (to support 'list' and 'search')

- * Rakefile: added 'gem' target. Runs "local" (not installed) command

-2004-07-04 Gavin Sinclair <gsinclair@soyabean.com.au>

- * Rakefile: added 'install' target.

- * lib/rubygems/cmd_manager.rb: code formatting.

- * lib/rubygems/gem_commands.rb:

- - refactored common install and update options into new module

- InstallUpdateOptions

- . consolidated option pairs (e.g. --test & --no-test ==> --[no-]test)

- . --gen-rdoc is now --rdoc

- - (UninstallCommand) corrected typo

- - (InstallCommand) corrected output with local install

- * test/test_parse_commands.rb: :%s/--gen-rdoc/--rdoc/g

-2004-07-03 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_commands.rb (Gem::InstallCommand::initialize):

- Added --no-gen-rdoc and --no-test to allow the user to override

- .gemrc default options.

- * lib/rubygems/doc_manager.rb (Gem::DocManager::generate_rdoc):

- Concatenate the local rdoc options to the end of the spec's rdoc

- (Gem::DocManager::configured_args): Added configured_args as a

- place to store local rdoc options.

- * lib/rubygems/gem_runner.rb (Gem::GemRunner::do_configuration):

- Configuration handled in do_configuration now.

- (Gem::GemRunner::do_configuration): Set the local rdoc

- configuration from the config file.

- * lib/rubygems/command.rb (Gem::Command::handles): Added a

- handles? method to Command so that we can detect which extra

- arguments can be used with a command.

- (Gem::Command::add_extra_args): New method to add the config

- file's extra arguments to the front of the argument list.

- (Gem::Command::extra_args): Added extra_args to Command class to

- hold the extra args discovered in the config file.

- * Rakefile: Added TEST=filename option to all the test targets.

- * test/functional.rb (FunctionalTest::test_gemrc): Added

- functional test for gemrc.

- * scripts/gemdoc.data: Added an example to the specification command.

- * lib/rubygems.rb (Gem::Exception::manage_gems): Added gem_runner

- and config_file to manage_gems.

- (Gem::Exception::use_paths): use_paths now accepts (and ignores)

- * bin/gem: Make Gem::GemRunner the top level object. It now

- creates and calls the CommandManager /after/ the arguments are

- * Rakefile: Added test/data/gemhome to clobber list.

-2004-07-01 Jim Weirich <jim@weirichhouse.org>

- * test/test_specification.rb

- (TestSpecification::test_rdoc_files_included): Test for rdoc files

- included in file list. Test for redundent file removal.

- * lib/rubygems/specification.rb (Gem::Specification::validate):

- Added gem version to validation requirement. Added normalize to

- remove redundent files in lists.

- * lib/rubygems/gem_commands.rb (Gem::InfoCommand::usage): Added

- usage and arguments methods for InfoCommand.

- (Gem::SpecificationCommand::usage): Fixed several usage comments.

-2004-06-30 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_commands.rb (Gem::InstallCommand::usage):

- Upcased the comment on the usage statement (and corresponding

- option). This makes the variable part of the command

- (e.g. GEMNAME) stand out from the static parts.

- * lib/rubygems/cmd_manager.rb (Gem::CommandManager::process_args):

- Downcased commands before searching (allows upper case or mixed

- case for commands on command line).

- * install.rb (install_rb): Fixed bug where the installer falsely

- triggered the old repository upgrade when the directory part of

- the file contained the matching "-digits." pattern. Now the

- pattern must be in the file's base name.

-2004-06-26 Gavin Sinclair <gsinclair@soyabean.com.au>

- * scripts/specdoc.rb: added (to generate gem specificiation document)

- * scripts/specdoc.data: added (supports specdoc.rb)

- * scripts/specdoc.yaml: added (supports specdoc.rb)

-2004-06-27 Jim Weirich <jim@weirichhouse.org>

- * scripts/gemdoc.data Removed extraneous marker.

- * lib/rubygems/specification.rb

- (Gem::Specification::satisfies_requirement): HA! Caught another

- version_requirement vs version_requirements error. (I really

- regret the decision to change that name.)

- * lib/rubygems/installer.rb (Gem::Uninstaller::has_dependents):

- Changed call to alert to alert_warning.

- * lib/rubygems/gem_commands.rb (Gem::UninstallCommand::execute):

- Again, remove local error handling to allow the error to perculate

- up the chain to the top level.

- * lib/rubygems/doc_manager.rb (Gem::DocManager::generate_rdoc):

- Removed one level of exception handling. Only catching RDocErrors

- at the outermost level. And instead of reporting the error and

- swallowing it, I convert it to a Gem::DocumentError (with the same

- error message). This is for better error handling.

- * lib/rubygems/command.rb (Gem::Command::handle_options): Removed

- exception handling from handle_options. This allows errors to be

- handled at the top level. Makes for a more consistent error

- * lib/rubygems/doc_manager.rb (Gem::DocumentError): Added

- DocumentError to wrap RDocErrors (which derive from Exception

- * lib/rubygems/cmd_manager.rb (Gem::RemoteError): RemoteError and

- LocalInstallationError are now Gem::Exceptions (rather than

- * lib/rubygems.rb (Gem::Exception): Changed base of Gem::Exception

- to RuntimeError (was ::Exception). Apps using gem as a library

- would have to catch Gem::Exceptions explicitly (yuck), or catch

- Exceptions generically. Catching Exceptions will catch

- EVERYTHING, including things like SystemExit. By makeing

- Gem::Exception a RuntimeError, apps can catch RuntimeError or even

-2004-06-26 Jim Weirich <jim@weirichhouse.org>

- * test/functional.rb (FunctionalTest::test_all_command_helps):

- Added functional test to show all commands have usage messaegs.

- * lib/rubygems/gem_commands.rb (Gem::HelpCommand::execute): Added

- version option to help (gem help version).

- (Gem): Cleaned up the help text. Dropped unneeded verbage.

- * lib/rubygems/cmd_manager.rb

- (Gem::CommandManager::find_command_possibilities): Added

- find_command_possibilities to help the Help command look for

- * lib/rubygems/installer.rb (Gem::Uninstaller::uninstall): Fixed

- null pointer bug where a list was destroyed in a method.

- * lib/rubygems/gem_commands.rb (Gem::BuildCommand::load_gemspecs):

- yaml gemspec files are now accepted by the build command.

- * lib/rubygems/command.rb (Gem::Command::parser): Created an

- on-demand option parser for all commands.

- (Gem::Command::handle_options): Command line option hash is now

- and instance variable with a reader.

- * Rakefile: Linked package version to the value in the rubygems.rb

- file. The gem env command now shows both gem version (e.g. 0.6)

- and the package version (e.g. 0.6.1).

-2004-06-25 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/gem_commands.rb (Gem::InfoCommand): Dropped the

- version command (its available via gem env). Added a gem info

- command to extract the yaml from a gemfile.

- (Gem::LocalRemoteOptions): Refactored the local/remote options

- (adding and testing) into a mixin module.

- * test/test_version_comparison.rb

- (TestDependencies::test_normalization): Added some tests for the

- normalization issues mentions below.

- * lib/rubygems/version.rb (Gem::Dependency::normalize): Old gems

- have requirements and dependencies incoded in the Yaml spec in an

- out of date format. When loaded, they have incorrect instance

- variables for modern objects. I added a normalize call to handle

- transforming out dated objects in to modern objects. (Remember

- this next time we change the data structure of something in the

- (Gem::Version::Requirement::parse): Requirements are comparable

- now, just so that we can test them with asserts.

- * lib/rubygems/remote_installer.rb

- (Gem::RemoteInstaller::find_dependencies_not_installed): Fixed

- recursive call to require_gem to properly pass dependency

- * lib/rubygems/installer.rb (Gem::Uninstaller::has_dependents):

- Fixed reference to version_requirement (needs to be plural).

- * lib/rubygems/command.rb (Gem::Command::invoke): Command now

- handles it own help messages. Commands no longer have to return

- true/false to trigger help messages.

- * lib/rubygems/cmd_manager.rb (Gem::CommandManager::process_args):

- Moved help handling into the help command.

- * lib/rubygems/gem_commands.rb (Gem::HelpCommand): Renamed the

- base command to HelpCommand and made it handle a lot of the help

- options. Still need work on individual command helps.

- * test/functional.rb (FunctionalTest::test_env_version): Added a

- bunch of new functional tests for the environment command.

- * lib/rubygems/gem_commands.rb (Gem::InstallCommand::execute):

- Made multiple gem names an error for now. Should look at later.

- * lib/rubygems/cmd_manager.rb (Gem::ListCommand): Added list as an

- (Gem::UpdateCommand::initialize): Corrected spelling of install

- (intall) in several places.

- * bin/gem_server: Added Gem.manage_gems to the gem_server to fix

- missing requirements.

- * lib/rubygems/cmd_manager.rb (Gem::InstallCommand::initialize):

- Added missing --both option to install.

- * test/test_command.rb

- (TestCommand::test_invode_with_bad_options): Catch the termination

- * test/mockgemui.rb (MockGemUi::terminate_interaction): Make the

- mock UI throw an exception when a termination is requested. This

- makes sure that we don't miss accidental terminations.

- * lib/rubygems/cmd_manager.rb (Gem::CommandManager::find_command):

- Added find_command to handle best matching command names.

- * test/functional.rb (FunctionalTest::test_build): Updated

- functional tests to use the new command structure.

- * lib/rubygems/version.rb (Gem::Version::Requirement): Changed the

- pessimistic version comparison operator to "~>". I like to think

- of it as "approximately greater than". (It was ">*").

- * bin/gem: Moved gem2 into the standard gem script location. It

- is now stable enough to use as the standard command.

- * lib/rubygems/cmd_manager.rb (Gem::CommandManager::run): Added

- run method to trap errors while running commands. Makes for

- (Gem::CommandManager): Move *all* commands to their own classes.

- Simplified CommandManager. Lowered the coupling between

- CommandManager and the Commands (the commands don't even need to

- know about the manager anymore). CommandManager maybe created

- with "new" for testing (the script will continue to use

- (Gem::RubyGemsInfoCommand): New command.

- (Gem::VersionCommand): New command.

-2004-06-24 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/user_interaction.rb (Gem::UserInteraction):

- Significantly rewrote the whole user interaction scheme. We are

- now using an UI object that responds to the standard list of UI

- commands (e.g. say, alert, ask). The UserInteraction module

- defines all the interaction methods to be forwarded to the default

- UI objects. The "ui" method returns that default object (and you

- can use self.ui=(new_ui) to change it). Also the use_ui(new_ui) {

- } command is convienent for switching the UI object for a short

-2004-06-18 Rich Kilmer <rich@infoether.com>

- * broke test_cmd_manager.rb into test_parse_commands and

- test_process_commands to test the parsing of command line options

- and the funtionality, respectively.

-2004-06-18 Rich Kilmer <rich@infoether.com>

- * added new unit test file: test/test_cmd_manager.rb to test the

- command manager classes. this is just the first few tests which

- will be expanded to a full test suite.

-2004-06-17 Chad FOwler <chad@chadfowler.com>

- * lib/rubygems/installer.rb: Fixed bug in windows batch file generation

- which was causing file not found errors.

- * lib/rubygems/installer.rb: Uninstall now removes scripts and batch

- * lib/rubygems/specification.rb: Fixed install bug. Thanks to Mark

- Sparshatt for the fix (via the rubyforge bug tracker).

-2004-06-17 Jim Weirich <jim@weirichhouse.org>

- * lib/rubygems/doc_manager.rb (Gem::DocManager::generate_rdoc):

- Changed rdoc generation to do a chdir into the base source

- directory and then to use a relative path for all the source

- files. This makes the generated RDOC html look better and may fix

- the windows drive/rdoc bug as a side effect.

-2004-06-17 Rich Kilmer <rich@infoether.com>

- * Added ability to capture the UserInteraction with:

- c = Gem::UserInteraction.capture

- and then you can override specific methods like 'say':

- c.on_say {|statement| puts "you said: #{statement}"}

-2004-06-15 Rich Kilmer <rich@infoether.com>

- * Added refactored command handling in rubygems/cmd_manager.rb and a

- (temporary) bin/gem2 command file to test things out. Once we feel

- comfortable, we can replace gem with gem2.

-2004-06-10 Rich Kilmer <rich@infoether.com>

- * Isolated all user interaction to pass through module methods on a new

- Gem::UserInteraction module. Those methods will be the method of abstracting

- the interaction of RubyGems for use in a GUI-based solution.

-2004-06-10 Rich Kilmer <rich@infoether.com>

- * require 'rubygems' now minimally requires only the files needed

- for runtime access to gems...not management of gems. To manage

- gems you now additionally need to execute Gem::manage_gems prior

- to using the builder/installer/etc. This makes gemspecs not

- backward compatible unless they add that line to the gemspec

- after the require 'rubygems' line.

-2004-06-10 Gavin Sinclair <gsinclair@soyabean.com.au>

- * bin/gem: --upgrade-all was broken, probably as a result of the

- search changes listed below.

-2004-06-09 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/remote_install.rb: delegate search functionality to

- Cache class, bringing remote and local search and list together into

- one piece of code.

- * bin/gem, lib/rubygems/validator.rb: move all STDIO work to bin/gem.

- Validator.alien now returns a hash of ErrorData objects.

- * bin/gem, lib/rubygems/installer.rb: move most of the STDIO stuff to

- bin/gem, communicating via exceptions in this case.

-2004-06-08 Rich Kilmer <rich@infoether.com>

- * Fixed the drive problem on win32 (hopefully) so multiple drives

- should now work. Its still a hack until rdoc is fixed.

-2004-06-08 Chad Fowler <chad@chadfowler.com>

- * Fixed bug caused by method change on Version::Requirement

-2004-06-08 Rich Kilmer <rich@infoether.com>

- * fixed bug in doc_manager.rb whereby the extra_rdoc_files should

- be appended to the list of directories prior to prepending the

-2004-06-08 Gavin Sinclair <gsinclair@soyabean.com.au>

- * bin/gem_server: List installed gems in [name,version] order.

-2004-06-08 Gavin Sinclair <gsinclair@soyabean.com.au>

- * lib/rubygems/installer.rb: don't warn about not being able to

- install a library stub if a library stub is already installed.

- Still warn if it's not a library stub that's there already.

-2004-06-08 Gavin Sinclair <gsinclair@soyabean.com.au>

- * bin/gem: renamed --upgrade-dist to --upgrade--all and fixed bug.

- * lib/rubygems/installer.rb: fixed bug with Ruby version assertion.

-2004-06-07 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/remote_installer.rb, lib/rubygems/version.rb: Fixed old

- dependency on #version method for Gem::Version::Requirement

- * bin/gem: new --upgrade-dist option allows one to upgrade every

- * lib/rubygems/specification.rb,lib/rubygems/installer.rb: new

- #required_ruby_version attribute added to gem specification for specifying a

- dependency on which version of ruby the gem needs. Format it accepts is

- the same as the Gem::Version::Requirement format.

-2004-06-06 Chad Fowler <chad@chadfowler.com>

- * bin/gem: install_stub is once again the default due to requests.

-2004-06-04 Chad Fowler <chad@chadfowler.com>

- * lib/rubygems/specification.rb, lib/rubygems/doc_manager.rb:

- Allow arbitrary files to be added for rdoc to run over them (as per

-2004-06-04 Chad Fowler <chad@chadfowler.com>

- * bin/gem: Reformatted --search and --list output such that

- multiple versions of a gem are compressed into a single entry

- (with version numbers in parentheses)

-2004-05-31 Jim Weirich <jweirich@one.net>

- * lib/rubygems/version.rb (Gem::Dependency): Dependency attribute

- renamed to version_requirements (made plural).

- (Gem::Version::bump): Added bump to implement pessimistic

- (Gem::Version::Requirement): Added pessimistic operator to list of

- operators. Operators now implemented using lambda.

- * lib/rubygems.rb (Kernel::require_gem): require_gem now takes an

- array of requirement strings.

- * lib/rubygems/version.rb (Gem::Version::Requirement::initialize):

- Simplified initialization by making parse a bit smarter.

- (Gem::Version::Requirement::satisfied_by): Simplified by using

- (Gem::Version::Requirement::satisfy): Added explicit one

- requirement satisfy test.

- (Gem::Version::Requirement::parse): parse now returns a two

- element string array (operator and version string). We don't

- bother converting to an integer array during parsing.

-2004-05-31 18:38 chadfowler

- * gemspec now supports #rdoc_options, to which you can append

- strings that will be passed to rdoc as additional options.

-2004-05-08 21:57 chadfowler

- * Using Gem::RubyGemsVersion to match the release number. If we

- need to use this as an internal version format specifier in the

- future, we can use the Gem::Version semantics.

-2004-05-30 14:33 gsinclair

- * bin/gem: Split --help into --help (basic), --help-options (what

- --help used to be), and --help-examples.

-2004-04-30 15:57 chadfowler

- * bin/gem: --install-stub is no longer the default ;)

-2004-04-30 15:51 chadfowler

- * lib/rubygems/installer.rb: Rich Kilmer (who kicks butt) figured

- out how to fix the library stub stuff.

-2004-04-29 19:12 chadfowler

- * lib/rubygems/doc_manager.rb: Dick Davies fixed a bug in the doc

-2004-04-29 13:41 gsinclair

- * lib/rubygems/installer.rb: Added skeleton code and comments to

- uninstall stub apps and libs

-2004-04-29 12:20 gsinclair

- * install.rb: Don't install library stub for 'sources'

-2004-04-29 12:20 gsinclair

- * lib/rubygems/installer.rb: Improvements to library stub

- installation: * don't overwrite existing file (emit warning) *

- nice warning if there's a permission problem * observe

- --[no-]install-stub flag (rather, observe the argument to

-2004-04-29 12:16 gsinclair

- * bin/gem: --install-stub is now the default

-2004-04-26 20:20 chadfowler

- * test/test_remote_installer.rb: Cleaning up after Gavin and his

- test-breaking self. ;)

-2004-04-26 12:06 gsinclair

- * bin/gem, lib/rubygems/installer.rb,

- lib/rubygems/remote_installer.rb: Installing a gem now causes a

- library stub to be installed as well, allowing you to require

- 'package' without knowing it's a gem.

-2004-04-25 23:18 chadfowler

- * lib/rubygems/: installer.rb, specification.rb: Prompt user if

- trying to uninstall a gem that other gems *may* depend on.

-2004-04-25 09:27 chadfowler

- * test/test_remote_installer.rb: Changed expected test results to

- match new (old) gem naming scheme--"ruby" doesn't appear as a

- platform in the gem name.

-2004-04-25 05:50 gsinclair

- * bin/gem: Changed @directory -> @install_dir for clarity

-2004-04-25 05:47 gsinclair

- * bin/gem: Improved display of gems, platform-wise

-2004-04-25 05:46 gsinclair

- * lib/rubygems/specification.rb: Added documentation

-2004-04-25 04:17 jimweirich

- * test/functional.rb: Fixed functional test to properly name a Ruby

-2004-04-25 04:17 jimweirich

- * packages/sources/.cvsignore, test/data/one/.cvsignore: Ignore the

-2004-04-25 04:17 jimweirich

- * lib/rubygems/specification.rb: Undefined several attributes that

- were redefined to avoid warnings.

-2004-04-25 04:17 jimweirich

- * lib/rubygems.rb: Need to initialize @gem_home and @gem_path with

- ||= to avoid warning.

-2004-04-25 03:40 gsinclair

- * lib/rubygems.rb, test/test_gempaths.rb: RUBY_GEMS -> GEM_PATH

- (environment variable)

-2004-04-25 03:33 gsinclair

- * lib/rubygems/specification.rb: Pretty-print the specification

-2004-04-25 03:18 gsinclair

- * lib/rubygems/specification.rb: Handle platform in a (hopefully)

-2004-04-25 03:16 gsinclair

- * install.rb: Use return value from Builder#build to locate gem

-2004-04-25 03:09 gsinclair

- * lib/rubygems/builder.rb: Return file name from #build

-2004-04-25 02:32 gsinclair

- * lib/rubygems/specification.rb: Platform goes at the *end* of the

-2004-04-22 06:19 chadfowler

- * test/test_remote_installer.rb: Fixed test to reflect fewer cache

-2004-04-21 17:19 rich

- * lib/rubygems/remote_installer.rb: added support to download the

- yaml index as a .Z (zlib compressed) file if it exists, then move

- on to the plain yaml file if it does not

-2004-04-20 20:23 chadfowler

- * examples/application/an-app.gemspec, lib/rubygems/format.rb,

- packages/sources/lib/sources.rb: Committed Dick Davies' patch to

-2004-04-18 01:51 gsinclair

- * bin/gem, lib/rubygems/doc_manager.rb: RDoc generation observes

- 'rdoc' config file value

-2004-04-17 12:15 gsinclair

- * bin/gem: Improved 'build' error output

-2004-04-17 12:12 gsinclair

- * lib/: rubygems.rb, rubygems/remote_installer.rb,

- rubygems/specification.rb, rubygems/validator.rb: All

- gems-related exceptions now extend Gem::Exception

-2004-04-17 12:11 gsinclair

- * lib/rubygems/specification.rb: Improved handling of summary and

- decription strings - convert to single line

-2004-04-17 01:09 gsinclair

- * bin/gem: Prevent remote install attempt if local install was

-2004-04-17 00:49 gsinclair

- * lib/rubygems/builder.rb: Better formatted the output code

-2004-04-16 21:31 gsinclair

- * lib/rubygems/remote_installer.rb: Stoopid coding error (thanks

-2004-04-16 00:00 rich

- * lib/rubygems/installer.rb: added code to optionally use nmake

- instead of make on win32 systems

-2004-04-15 20:12 gsinclair

- * bin/gem, lib/rubygems/remote_installer.rb: Clarified proxy

- handling and interface: --[no-]http-proxy [URL]

-2004-04-13 00:16 jimweirich

- * bin/gem, test/bogussources.rb, test/functional.rb: Oops, missed

- an instance of GEM_PATH in the gem binary.

-2004-04-12 21:28 jimweirich

- * lib/rubygems/cache.rb: Oops. Missed a GEM_PATH.

-2004-04-12 21:11 jimweirich

- * test/test_remote_installer.rb: removed setting of environment

-2004-04-12 21:09 jimweirich

- * Rakefile, lib/rubygems.rb, lib/rubygems/cache.rb,

- lib/rubygems/installer.rb, packages/sources/.cvsignore,

- scripts/runtest.rb, test/.cvsignore, test/bogussources.rb,

- test/test_format.rb, test/test_gempaths.rb,

- test/test_remote_installer.rb, test/test_validator.rb: Added

- test/temp to the clobber list. Broke out tests into inline to

- avoid test dependencies on rubygem.

-2004-04-12 07:52 chadfowler

- * lib/: rubygems.rb, rubygems/installer.rb,

- rubygems/remote_installer.rb: Cleaning up output strings wrt

- formating of "gem (version)".

-2004-04-12 07:41 chadfowler

- * lib/rubygems/installer.rb: Gavin Sinclair's uninstall bug.

-2004-04-11 15:26 jimweirich

- * test/data/one/: .cvsignore, one-ruby-0.0.1.gem: removed

- one-ruby*.gem from source control. This gem is automatically

- generated in testing.

-2004-04-11 10:50 chadfowler

- * bin/gem: Gavin Sinclair's test code enhancements

-2004-04-11 07:50 chadfowler

- * bin/gem, lib/rubygems/installer.rb,

- lib/rubygems/remote_installer.rb, lib/rubygems/specification.rb,

- test/insure_session.rb, test/test_remote_installer.rb,

- test/data/one/one-ruby-0.0.1.gem: Gavin Sinclair patches to make

- installer return types less ambiguous.

-2004-04-09 10:29 chadfowler

- * lib/rubygems/installer.rb, test/data/one/one-ruby-0.0.1.gem: gem

- -u input validation patch by Ville Aine

-2004-04-07 07:49 chadfowler

- * bin/gem, lib/rubygems/cache.rb, test/data/one/one-ruby-0.0.1.gem:

- Finally have passing tests.

-2004-04-07 07:24 chadfowler

- * lib/rubygems/remote_installer.rb,

- test/data/one/one-ruby-0.0.1.gem: Allow default option to work on

- remote dependency prompt.

-2004-04-07 07:05 chadfowler

- * lib/rubygems/remote_installer.rb, test/test_remote_installer.rb,

- test/data/one/one-ruby-0.0.1.gem: Applied George Marrows' patch

-2004-04-07 06:23 chadfowler

- * bin/gem, test/data/one/one-ruby-0.0.1.gem: No longer "seeing"

- double on remote searches

-2004-04-05 07:39 chadfowler

- * Rakefile, test/test_remote_installer.rb,

- test/data/one/one-ruby-0.0.1.gem: remote_installer tests aren't

- completely hosed anymore.

-2004-04-05 06:16 chadfowler

- * Rakefile, test/data/one/one-ruby-0.0.1.gem: Rake target for

- running all tests (unit + functional) "alltests"

-2004-04-05 00:48 jimweirich

- * test/: insure_session.rb, data/one/README.one,

- data/one/one-ruby-0.0.1.gem, data/one/one.gemspec,

- data/one/lib/one.rb: added for functional tests

-2004-04-05 00:48 jimweirich

- * test/functional.rb: Moved session gem detection to insure_session

- file. Modified functional tests to use gem command. Removed

- some directory stuff because rake guarantees the starting

- directory. Added test_info functional test. Added test_build

- functional test. Added assert status.

-2004-04-05 00:48 jimweirich

- * lib/rubygems/remote_installer.rb: Changed exceptions to inherit

-2004-04-05 00:48 jimweirich

- * bin/gem: Changed Installer to RemoteInstaller in rubygems-info.

-2004-04-05 00:48 jimweirich

- * Rakefile: Added generated test gem to clobber list. Added

- functional test target to rakefile.

-2004-04-04 21:17 chadfowler

- * packages/sources/lib/sources.rb: Added gems mirror at

- http://gems.chadfowler.com

-2004-04-04 20:51 chadfowler

- * bin/gem, lib/rubygems/remote_installer.rb, test/functional.rb:

- More improved error messages (don't show stack trace when using

-2004-04-04 20:43 chadfowler

- * lib/rubygems/cache.rb: Only read specs that end in "gemspec".

- The code doesn't handle non-gemspecs very well at all.

-2004-04-04 20:15 chadfowler

- * test/mock/gems/specifications/sources-0.0.1.gemspec: [no log

-2004-04-04 20:09 chadfowler

- * test/mock/gems/gems/sources-0.0.1/lib/sources.rb: Rearranging

-2004-04-04 20:02 chadfowler

- * bin/gem, lib/rubygems/remote_installer.rb, test/bogussources.rb,

- test/functional.rb: Better error messages on unresolvable host.

-2004-04-04 12:50 chadfowler

- * redist/session.gem, test/bogussources.rb, test/functional.rb:

- Added the beginnings of a functional test suite.

-2004-04-03 22:02 chadfowler

- * lib/rubygems/validator.rb: Just had to explicitly rescue

- VerificationError. All is well.

-2004-04-03 22:01 chadfowler

- * lib/rubygems/validator.rb: Mauricio fixed a problem with alien

- (just failed to update it when we changed the gem directory), but

- now there's another issue I can't find. Anyway, this fix is

- obviously needed. But alien is broken anyway.

-2004-04-03 21:57 chadfowler

- * install.rb, lib/rubygems/builder.rb: Batsman's bug report and

- code for the bugs I introduced today. :)

-2004-04-03 09:50 chadfowler

- * lib/rubygems/specification.rb: Defaulting a spec's require_path

- to [] to avoid downstream errors.

-2004-04-03 09:06 chadfowler

- * lib/rubygems/builder.rb, test/test_builder.rb: builder now

- validates the gemspec.

-2004-04-03 08:48 chadfowler

- * lib/rubygems/specification.rb, test/test_specification.rb: Added

- checking for gem specs to make sure they have all required

-2004-04-03 08:06 chadfowler

- * gemspecs/rublog.gemspec: My original rublog gem was broken, in

- that it didn't have a require_path.

-2004-04-02 07:48 chadfowler

- * lib/rubygems/remote_installer.rb: Prompt for installation of

- For now, there is a puts/gets in the middle of

- remote_installer.rb This should probably be cleaned up later

- (return control flow to the gem program to install the

- dependencies, for example.

-2004-04-02 07:37 chadfowler

- * TODO: [no log message]

-2004-04-02 07:34 chadfowler

- * test/: simple_gem.rb, test_format.rb: Some things I forgot to cvs

-2004-04-02 07:29 chadfowler

- * example/: test.gemspec, lib/test.rb, lib/test/wow.rb: Removing

- example directory in favor of "examples" directory (just better

-2004-04-02 07:26 chadfowler

- * test/test_all.rb: Removed test_all.rb. Rake is obviously a

- better way to do it.

-2004-03-31 19:13 chadfowler

- * lib/rubygems/format.rb, lib/rubygems/installer.rb,

- lib/rubygems/validator.rb, test/test_all.rb,

- test/test_validator.rb: More tests and refactoring to support

-2004-03-30 02:41 rich

- * lib/rubygems/installer.rb: allow passing parameters to extconf.rb

- ruby -i blah.gem --local -- --with-option

- everything past the -- will go to the extconf.rb...just like

-2004-03-30 02:34 rich

- * lib/rubygems/: installer.rb, specification.rb: very initial

- capability to build source gems. this only lets you build native

- extensions so long as you do not have to specify --with-

-2004-03-29 08:31 rich

- * install.rb: switched migration of old gems to new ./gems subdir

- to use FileUtils rather than ftools...hope to fix reported win32

-2004-03-29 01:04 rich

- * lib/rubygems/doc_manager.rb: fixed bug in pathing based on new

- directory structure

-2004-03-29 01:03 rich

- * lib/rubygems/remote_installer.rb: fixed bug in default for proxy

- (should default to nil not true)

-2004-03-29 01:03 rich

- * bin/gem: updated with patch to allow for config file with minor

- difference from gavin's patch which passes a nil to the

- RemoteInstaller if the proxy does not exist

-2004-03-28 23:22 rich

- * install.rb: added code to migrate gems if they are in the old

- directory structure

-2004-03-28 21:30 rich

- * install.rb, lib/rubygems.rb, lib/rubygems/installer.rb,

- lib/rubygems/specification.rb: changed path of installed gems to

- ruby/gems/1.8/gems

- which cleans up the root.

-2004-03-28 18:53 chadfowler

- * test/test_all.rb: This is the file to run for all of the tests.

- test_remote_installer is commented out for now. The open URI

- patch that George gave us makes the code a lot nicer to look at,

- but a little harder to test.

-2004-03-28 18:50 chadfowler

- * lib/rubygems/remote_installer.rb, test/test_cache.rb,

- test/test_remote_installer.rb: Added some tests for cache search

-2004-03-28 12:19 chadfowler

- * bin/gem, lib/rubygems/validator.rb, test/test_validator.rb: Some

- tests for the validator.

- Made the validator more testable.

-2004-03-28 09:30 chadfowler

- * bin/gem, lib/rubygems/validator.rb: Fixed a problem with false

- alarms in the validator.

-2004-03-27 08:23 chadfowler

- * bin/gem: No longer have an option to pass http proxy host into

- the gem program. Only reads it from the environment. This is

- because George's patch (and open-uri) work this way, and I'm lazy

-2004-03-27 08:17 chadfowler

- * lib/rubygems/remote_installer.rb: George Marrows' nice patch to

- remove a bunch of code from remote_installer.

- Our remote_installer tests are failing. We really need to start

- paying attention to the test directory. :(`

-2004-03-24 23:26 jimweirich

- * install.rb: Do not install commands ending in ~.

-2004-03-24 23:25 jimweirich

- * lib/rubygems/specification.rb: Changed executables from accessor

- to writer to avoid redefinition.

-2004-03-21 21:10 jimweirich

- * bin/gem: fixed uninitialized directory option

-2004-03-21 15:34 jimweirich

- * bin/gem: removed carriage returns that screwed up the #! line

-2004-03-21 09:02 chadfowler

- * bin/gem: Gavin's bin/gem refactoring.

-2004-03-20 17:03 jimweirich

- * bin/gem: added wrapping to gem listing

-2004-03-20 12:22 chadfowler

- * install.rb: More cleaning by Gavin Sinclair

-2004-03-20 12:08 chadfowler

- * examples/application/an-app.gemspec,

- examples/application/bin/myapp,

- examples/application/lib/somefunctionality.rb, lib/rubygems.rb,

- lib/rubygems/installer.rb, lib/rubygems/specification.rb: Added

- functionality for installing applications into the system bindir.

- Needs cleaning and refactoring.

-2004-03-20 07:53 chadfowler

- * bin/gem: [no log message]

-2004-03-19 23:03 chadfowler

- * bin/gem: More intuitive default.

-2004-03-19 10:45 chadfowler

- * bin/gem: * Some minor rearranging of the test stuff so that

- installation errors will also abort the test run * Don't try to

- run tests if none are included with the gem

-2004-03-18 22:27 chadfowler

- * bin/gem, example/lib/test.rb, lib/rubygems/cache.rb,

- lib/rubygems/specification.rb: * Preliminary support for: gem -i

- blah-0.0.1.gem --run-tests Needs to be cleaned up considerably.

- * Introduction of new gemspec metadata "unit_test_suite", which

- will be require'd in order to load all unit tests

-2004-03-17 09:33 chadfowler

- * bin/gem: Applied Gavin Sinclair's patch to make help output

-2004-03-16 21:55 chadfowler

- * bin/gem: Added --remote-list option for gem command to display

- all gems on server.

-2004-03-16 21:50 chadfowler

- * bin/gem, doc/UserDoc.html: Fixed --help case inconsistencies and

- documentation typos as per Scott Harper's email.

-2004-03-16 21:41 chadfowler

- * bin/gem: --list and --search display are the same.

-2004-03-16 21:33 chadfowler

- * bin/gem: Implemented some of Scott Harper's search suggestions:

- case insensitive sort of returned gems and display description

- with gem name in search results.

-2004-03-16 21:20 chadfowler

- * bin/gem, lib/rubygems/remote_installer.rb: http_proxy option

-2004-03-15 07:19 chadfowler

- * lib/rubygems/remote_installer.rb: Installation is now case

- insensitive (like search)

-2004-03-15 07:07 chadfowler

- * TODO, bin/gem, lib/rubygems/remote_installer.rb: Better error

- messages. updated TODO list.

-2004-03-14 21:02 chadfowler

- * bin/gem, lib/rubygems/remote_installer.rb: --dir didn't work with

- remote-install. Now it does.

-2004-03-14 17:48 rich

- * bin/gem: fixed uninstall bug

-2004-03-14 17:18 rich

- * lib/rubygems/doc_manager.rb: changed to remove <drive>: on

-2004-03-14 16:15 rich

- * install.rb: fixed typo

-2004-03-14 16:13 rich

- * install.rb: generate cmd files

-2004-03-14 16:13 rich

- * bin/: gem.cmd, gem_server.cmd: now generate cmd files

-2004-03-14 15:52 chadfowler

- * bin/gem: Fixed a small bug with --gen-rdoc and the remote

-2004-03-14 15:38 chadfowler

- * lib/rubygems.rb: Back to version 1.0 ;)

-2004-03-14 15:36 chadfowler

- * lib/rubygems.rb: Updated rubygemsversion

-2004-03-14 15:31 chadfowler

-2004-03-14 15:24 rich

- * README: initial readme

-2004-03-14 15:12 rich

- * doc/UserDoc.html: updated w/doc on documentation ;-)

-2004-03-14 15:01 rich

- * gemspecs/jabber4r.gemspec: added jabber4r gemspec

-2004-03-14 14:58 rich

- * bin/gem_server: change the documentation path to /

-2004-03-14 14:57 rich

- * install.rb: remove installing .rb files from ./bin

-2004-03-14 14:32 rich

- * doc/: DevDoc.txt, GemSpecification.txt, UserDoc.html,

- UserDoc.txt: updated with latest docs

-2004-03-14 12:05 chadfowler

- * test/test_remote_installer.rb: Fixed tests.

-2004-03-14 11:31 chadfowler

- * lib/rubygems/specification.rb: Fixed bug that would manifest

- itself if a gem creator put apostrophes/single-quotes in the gem

-2004-03-14 00:04 rich

- * doc/: UserDoc.html, UserDoc.txt: finished user's guide

-2004-03-13 21:48 rich

- * doc/: DevDoc.html, UserDoc.html, UserDoc.txt: updated user's

- guide...will finish section on ruby's library mgt soon ;-)

-2004-03-13 20:48 chadfowler

- * doc/DevDoc.txt: Added documentation on making and distributing

-2004-03-13 20:20 chadfowler

- * TODO: [no log message]

-2004-03-13 19:51 rich

- * doc/: DevDoc.html, DevDoc.txt, GemSpecification.html,

- GemSpecification.txt, UserDoc.html, UserDoc.txt, doc.css,

- makedoc.rb: added these doc (wiki) files from

- http://rubygems.rubyforge.org/

-2004-03-13 17:56 chadfowler

- * TODO, gemspecs/README, gemspecs/cgikit-1.1.0.gemspec,

- gemspecs/linguistics.gemspec, gemspecs/ook.gemspec,

- gemspecs/progressbar.gemspec, gemspecs/redcloth.gemspec,

- gemspecs/rublog.gemspec, gemspecs/ruby-doom.gemspec,

- gemspecs/rubyjdwp.gemspec, gemspecs/statistics.gemspec: Added

- some gemspecs for actual RAA packages.

-2004-03-13 14:35 chadfowler

- * TODO, lib/rubygems/remote_installer.rb: Preliminary HTTP Proxy

- support. Untested.

-2004-03-13 09:11 chadfowler

- * packages/sources/lib/sources.rb: Changed to point to rubyforge

-2004-03-12 22:40 rich

- * bin/generate_yaml_index.rb: generates a yaml index for a gems

-2004-03-12 22:02 chadfowler

- * bin/gem_server: No longer serving gem specs.

-2004-03-12 21:42 chadfowler

- * TODO, bin/gem_server.cgi: We decided to trash gem_server.cgi in

- favor of the static content generator Rich is working on.

-2004-03-12 21:15 chadfowler

- * TODO: [no log message]

-2004-03-12 20:11 chadfowler

- * bin/gem, lib/rubygems/installer.rb,

- lib/rubygems/remote_installer.rb: Basic search funtionality in.

- Slight refactoring of Installer and RemoteInstaller

-2004-03-12 18:28 chadfowler

- * TODO: [no log message]

-2004-03-12 16:37 chadfowler

- * TODO: [no log message]

-2004-03-12 16:14 chadfowler

- * TODO: More TODO items

-2004-03-08 13:50 chadfowler

- * TODO, bin/gem_server, example/test.gemspec: Use rdoc templates

- for HTML. Nearly XHTML compliant.

-2004-03-08 08:21 chadfowler

- * TODO: Added TODO list

-2004-03-08 08:12 chadfowler

- * lib/rubygems/validator.rb: Fixed a small (but crippling) bug in

-2004-01-24 13:49 chadfowler

- * bin/gem, lib/rubygems.rb, lib/rubygems/cache.rb,

- lib/rubygems/validator.rb, lib/rubygems/version.rb: More cleanup.

-2004-01-24 13:29 chadfowler

- * bin/gem, lib/rubygems/remote_installer.rb: A little cleaning of

- (Remote)Installer inconsistencies

-2004-01-24 13:23 chadfowler

- * bin/gem: Removed the weird instance variable thing we had going

-2004-01-07 17:34 chadfowler

- * bin/gem: removed old cruft

-2003-12-24 11:32 chadfowler

- * lib/rubygems/validator.rb: Gem validation was returning false

- negatives (corrupted gems were not reporting their corruption).

-2003-12-18 14:18 chadfowler

- * lib/rubygems/cache.rb: Lyle noticed some out of date rdoc

- documentation. Thanks Lyle!

-2003-12-03 08:05 chadfowler

- * install.rb: Gavin's patch for installing the files in bin/ on

- rubygems installation.

-2003-11-30 00:36 chadfowler

- * lib/rubygems/specification.rb: Little warnings adjustment

-2003-11-29 17:27 jimweirich

- * Rakefile: added Rakefile to package

-2003-11-29 16:23 jimweirich

- * lib/rubygems/specification.rb: Removed defined? and initialized

-2003-11-29 16:08 jimweirich

- * lib/rubygems/specification.rb: Initialized @loaded and check

- defined?(@platform) to silence some -w warnings.

-2003-11-29 09:26 rich

- * bin/gem_server, lib/rubygems/doc_manager.rb: updated to support

- /doc URL to generate list of installed gems w/doc link for rdoc

-2003-11-29 08:30 rich

- * lib/rubygems/doc_manager.rb: minor format change of error message

-2003-11-29 08:29 rich

- * bin/gem, lib/rubygems/builder.rb, lib/rubygems/doc_manager.rb,

- lib/rubygems/installer.rb: instantiates DocManager now. errors

- out on no install of RDoc. warns if .gemspec does not specify

- having rdoc, but rdoc is generated

-2003-11-29 02:13 rich

- * bin/gem, lib/rubygems.rb, lib/rubygems/doc_manager.rb,

- lib/rubygems/format.rb, lib/rubygems/installer.rb,

- lib/rubygems/specification.rb: added capability to generate rdoc

- on install of gem (--gen-rdoc). this doc is placed in

- Gem.dir+doc+gem.full_name fixed but in installer when moving to

- format (not calling each) added doc manager to add/remove

- documenatation (right now only rdoc)

-2003-11-29 01:28 rich

- * lib/rubygems/specification.rb: should not define the attr_readers

- for requirements/dependencies so undef is unnecessary

-2003-11-29 00:12 jimweirich

- * lib/rubygems/specification.rb: Undefing dependencies and

- requirements removes warning when used with -w.

-2003-11-29 00:12 jimweirich

- * lib/rubygems.rb: Using defined?($GEM_PATH) avoids warning when

- used with -w switch.

-2003-11-28 15:58 chadfowler

- * bin/gem, example/test.gemspec, lib/rubygems.rb,

- lib/rubygems/installer.rb, lib/rubygems/validator.rb,

- lib/rubygems/format.rb: Separated gem file reading into a

- separate class/file.

-2003-11-28 15:20 rich

- * lib/rubygems/specification.rb: added has_rdoc?/has_rdoc methods

- ... will be used to autogenerate rdoc

-2003-11-28 12:30 chadfowler

- * lib/rubygems/validator.rb: Rdoc added

-2003-11-28 11:51 chadfowler

- * bin/gem, lib/rubygems.rb, lib/rubygems/validator.rb: A little

- rearranging of the validation/alien code. It's still ugly, but

- at least it's in its own file now. :)

-2003-11-28 11:40 chadfowler

- * bin/gem: Removed a little cruft.

-2003-11-27 11:04 chadfowler

- * bin/gem: Print success message for each gem *not* containing

-2003-11-27 11:00 chadfowler

- * bin/gem, lib/rubygems/installer.rb: Preliminary support for gem

- directory validation (--alien). Looks for bad or missing gem

- files, missing spec files, files installed that aren't part of

- the gem, checksum mismatches, etc.

- Very ugly code. Very ugly output. Work in progress.

-2003-11-24 11:58 rich

- * lib/rubygems/specification.rb: change full_name to include

-2003-11-24 09:15 chadfowler

- * bin/gem: Option for HTTP Proxy server for remote-install. Not

-2003-11-23 20:22 chadfowler

- * lib/rubygems/builder.rb: Removed a stray \" in builder's success

-2003-11-23 20:16 chadfowler

- * lib/rubygems/specification.rb: Leaving escape in but commenting

- out its functionality because it hosed some other things up.

- Need to revisit this for the case where:

- s.summary = "Chad's Thing" # It's the apostrophe

-2003-11-23 20:08 chadfowler

- * lib/rubygems/specification.rb: Escape quotes to avoid invalid

- gemspecs in the #{Gem.dir}/specifications directory

-2003-11-23 19:21 chadfowler

- * bin/gem: Less ugly error message on file IO problems.

-2003-11-22 22:34 chadfowler

- * bin/gem: Very simple support for validating a gem. Will probably

- move this into the libs eventually.

-2003-11-22 20:53 chadfowler

- * example/test.gemspec, lib/rubygems/builder.rb: Generate MD5

- checksum for gem and store it in the file. Will be used to

- validate gem file before installation.

-2003-11-22 13:58 chadfowler

- * install.rb, lib/rubygems/remote_installer.rb,

- packages/sources/sources.gemspec,

- packages/sources/lib/sources.rb: remote-install sources are now

- installed as a ruby gem at the time of rubygems installation.

- sources gemspec included in the rubygems distribution.

-2003-11-22 12:52 chadfowler

- * bin/gem: Allow gem info by --version

-2003-11-22 11:50 chadfowler

- * lib/: rubygems.rb, rubygems/cache.rb: Fixed the bug I introduced

- by fixing Rich's bug with gem cache caching. ;)

- Gem::Cache now has a #refresh! method.

-2003-11-22 10:16 chadfowler

- * bin/gem, lib/rubygems.rb, lib/rubygems/installer.rb,

- lib/rubygems/remote_installer.rb: - Fixed bug in Gem.cache

- (though we may want to revisit it for in-memory caching - Command

- line configurable version for uninstall

-2003-11-22 00:28 rich

- * lib/rubygems/cache.rb: rdoc'd search method

-2003-11-22 00:24 rich

- * bin/gem, lib/rubygems/cache.rb, lib/rubygems/version.rb,

- test/test_version_comparison.rb: removed search_by_name because

- search does the same thing. version::requirement was updated to

- that if you did not specific a version operation, it assumes an =

- sign. updated tests accordingly

-2003-11-21 23:58 rich

- * lib/rubygems/: cache.rb, installer.rb: allow version to be

- specified in uninstall (if called programatically)

-2003-11-21 23:52 rich

- * lib/: rubygems.rb, rubygems/cache.rb, rubygems/installer.rb,

- rubygems/specification.rb: > moved all searching into cache..and

- now search by name/version and return an

- ordered list (.last == highest version).

- > modified uninstaller to allow selecting a specific version to

- multiple versions are installed.

- > implemented comparison function on specification.

- > changed require_gem to use new search of cache function

-2003-11-21 21:06 chadfowler

- * bin/gem, lib/rubygems/remote_installer.rb: Added ability to

- specify optional version requirement for remote installations

-2003-11-21 20:25 chadfowler

- * test/test_remote_installer.rb: Removed carriage returns

-2003-11-21 19:04 chadfowler

- * bin/gem_server: Converted from getopts to optparse.

-2003-11-21 18:31 rich

- * lib/rubygems.rb: changed the order in which operations are

- performed in require_gem. it now requires dependent gems prior

- to adding the require_paths to a gem. otherwise we could have

- had a LoadError on a dependent gem but the paths were already

- added...potential problem

-2003-11-21 18:21 rich

- * lib/rubygems/installer.rb: updated to ensure

- (specifications/cache) directories exist for a provided path

-2003-11-21 18:01 rich

- * lib/rubygems/specification.rb: updated rdoc

-2003-11-21 17:59 rich

- * bin/gem, lib/rubygems/builder.rb, lib/rubygems/installer.rb,

- lib/rubygems/specification.rb: fixed various bugs with the

- $GEM_PATH stuff, specifically on uninstall. Also, changed to

- allow specifying a directory on install (--dir) and force install

- (--force). Changed the builder generated ruby header to use

-2003-11-21 07:03 chadfowler

- * lib/: rubygems.rb, rubygems/cache.rb,

- rubygems/remote_installer.rb: Remote installation of dependencies

- now works. It downloads all dependent gems or errors out.

- Fixed bug in require_gem. Wrong call to cache.

-2003-11-21 00:59 rich

- * bin/gem, example/test.gemspec, lib/rubygems.rb,

- lib/rubygems/cache.rb, lib/rubygems/installer.rb,

- lib/rubygems/specification.rb: added capability to support

- multiple paths $GEM_PATH in Ruby and RUBY_GEMS in the ARGV. Lots

- of changes were needed to support this. also added the --force

- and --dir options to gem installtion

-2003-11-20 22:50 chadfowler

- * bin/gem: Switched to optparse. Not a whole lot gained, but it

- seems to be the way Ruby is going. It's nice not to have to do

- the "when" stuff, I guess.

-2003-11-19 23:41 chadfowler

- * lib/rubygems/: installer.rb, remote_installer.rb: Added

- chadfowler.com to the hardcoded remote install list.

- Fixed a dangling YAML.load that broke uninstall.

-2003-11-19 22:56 rich

- * lib/rubygems.rb: fixed bug in loading rubygems

-2003-11-19 22:51 chadfowler

- * bin/: gem_server, gem_server.cgi: require 'yaml' :)

-2003-11-19 22:44 rich

- * lib/: rubygems.rb, rubygems/cache.rb, rubygems/specification.rb:

- changed the format of stuff stored in the spec directory to ruby

- instead of YAML. This allows us to not have to load yaml in

- 'require_gem'. switched the specification list to a Cache

-2003-11-19 21:56 rich

- * lib/rubygems/installer.rb: write the spec file in ruby and not in

- yaml format (in the spec dir)

-2003-11-19 20:32 rich

- * lib/rubygems/specification.rb: added to_ruby method to generate a

- ruby string that can be eval'ed in to build a Gem Specification

-2003-11-17 21:37 jimweirich

- * bin/: gem_server, gem_server.cgi: removed carriage returns

-2003-11-17 21:19 chadfowler

- * install.rb: Accidentally left some junk in the file.

-2003-11-17 19:50 dblack

- * test/test_version_comparison.rb: * Test cases for Version.rb

-2003-11-17 19:50 dblack

- * lib/rubygems/version.rb: * Split off tests into

- rubygems/tests/test_version_comparison.rb

-2003-11-17 12:37 chadfowler

- * install.rb: Create File.join(Config::CONFIG['libdir'], "ruby",

- "gems") + "specifications" and + "cache" during installation.

- Need to remove this from rubygems.rb and replace with

- ensure_directory call.

-2003-11-17 12:29 rich

- * lib/rubygems/version.rb: rdoc added

-2003-11-17 11:31 rich

- * lib/rubygems/specification.rb: rdoc added

-2003-11-17 10:38 rich

- * lib/rubygems/: cache.rb, installer.rb: made rdoc comments and

- renamed some variables

-2003-11-17 08:48 dblack

- * lib/rubygems/version.rb: * Added stricter checking of incoming

- Requirement string

- * Added unit tests at end of file

-2003-11-17 07:32 chadfowler

- * bin/: gem_server, gem_server.cgi: Refactored gem_server program

- and added an equivalent CGI version.

-2003-11-17 00:14 rich

- * lib/: rubygems.rb, rubygems/builder.rb, rubygems/cache.rb: added

- rdoc documentation

-2003-11-16 17:15 chadfowler

- * bin/: gem.cmd, gem_server.cmd: Added some batch files for Windows

-2003-11-16 17:08 rich

- * install.rb, bin/gem, bin/gem_server, example/test.gemspec,

- example/lib/test.rb, example/lib/test/wow.rb, lib/rubygems.rb,

- lib/rubygems/builder.rb, lib/rubygems/cache.rb,

- lib/rubygems/installer.rb, lib/rubygems/remote_installer.rb,

- lib/rubygems/specification.rb, lib/rubygems/version.rb,

- test/test_remote_installer.rb: Initial import developed at

- Rich Kilmer Chad Fowler David Black Paul Brannon Jim Weirich

-2003-11-16 17:08 rich

- * install.rb, bin/gem, bin/gem_server, example/test.gemspec,

- example/lib/test.rb, example/lib/test/wow.rb, lib/rubygems.rb,

- lib/rubygems/builder.rb, lib/rubygems/cache.rb,

- lib/rubygems/installer.rb, lib/rubygems/remote_installer.rb,

- lib/rubygems/specification.rb, lib/rubygems/version.rb,

- test/test_remote_installer.rb: Initial revision

-indent-tabs-mode: t

-# -*- coding: utf-8 -*-

-=== 1.3.6 / 2010-02-17

-http://rubygems.org is now the default source for downloading gems.

-You may have sources set via ~/.gemrc, so you should replace

-http://gems.rubyforge.org with http://rubygems.org

-http://gems.rubyforge.org will continue to work for the forseeable future.

- * Added `gem push` and `gem owner` for interacting with modern/Gemcutter

- * `gem dep` now supports --prerelease.

- * `gem fetch` now supports --prerelease.

- * `gem server` now supports --bind. Patch #27357 by Bruno Michel.

- * `gem rdoc` no longer overwrites built documentation. Use --overwrite

- force rebuilding. Patch #25982 by Akinori MUSHA.

-* Captial letters are now allowed in prerelease versions.

-* Development deps are no longer added to rubygems-update gem so older

- versions can update sucessfully.

- * Prerelease gems can now depend on non-prerelease gems.

- * Development dependencies are ignored unless explicitly needed. Bug #27608

- * `gem which` now fails if no paths were found. Adapted patch #27681 by

- * `gem server` no longer has invalid markup. Bug #27045 by Eric Young.

- * `gem list` and friends show both prerelease and regular gems when

- --prerelease --all is given

-* Gem::Format no longer crashes on empty files. Bug #27292 by Ian Ragsdale.

-* Gem::GemPathSearcher handles nil require_paths. Patch #27334 by Roger Pack.

-* Gem::RemoteFetcher no longer copies the file if it is where we want it.

- Patch #27409 by Jakub Šťastný.

-Deprecation Notices:

-* lib/rubygems/timer.rb has been removed.

-* Gem::Dependency#version_requirements is deprecated and will be removed on or

- after August 2010.

-* Bulk index update is no longer supported.

-* Gem::manage_gems was removed in 1.3.3.

-* Time::today was removed in 1.3.3.

-=== 1.3.5 / 2009-07-21

-* Fix use of prerelease gems.

-* Gem.bin_path no longer escapes path with spaces. Bug #25935 and #26458.

-Deprecation Notices:

-* Bulk index update is no longer supported (the code currently remains, but not

-* Gem::manage_gems was removed in 1.3.3.

-* Time::today was removed in 1.3.3.

-=== 1.3.4 / 2009-05-03

-* Fixed various warnings

-* Gem::ruby_version works correctly for 1.8 branch and trunk

-* Prerelease gems now show up in `gem list` and can be used

-* Fixed option name for `gem setup --format-executable`

-* RubyGems now matches Ruby > 1.9.1 gem paths

-* Gem::RemoteFetcher#download now works for explicit Windows paths across

- drives. Bug #25882 by Lars Christensen

-* Fix typo in Gem::Requirement#parse. Bug #26000 by Mike Gunderloy.

-Deprecation Notices:

-* Bulk index update is no longer supported (the code currently remains, but not

-* Gem::manage_gems was removed in 1.3.3.

-* Time::today was removed in 1.3.3.

-=== 1.3.3 / 2009-05-04

-* `gem server` allows port names (from /etc/services) with --port.

-* `gem server` now has search that jumps to RDoc. Patch #22959 by Vladimir

-* `gem spec` can retrieve single fields from a spec (like `gem spec rake

-* Gem::Specification#has_rdoc= is deprecated and ignored (defaults to true)

-* RDoc is now generated regardless of Gem::Specification#has_rdoc?

-* `gem clean` now cleans up --user-install gems. Bug #25516 by Brett

-* Gem.bin_path now escapes paths with spaces.

-* Rake extension builder uses explicit correctly loads rubygems when invoking

-* Prerelease versions now match "~>" correctly. Patch #25759 by Yossef

-* Check bindir for executables, not root when validating. Bug reported by

-* Remove Time.today, no way to override it before RubyGems loads. Bug #25564

- by Emanuele Vicentini

-* Raise Gem::Exception for #installation_path when not installed. Bug #25741

-* Don't raise in Gem::Specification#validate when homepage is nil. Bug #25677

-* Uninstall executables from the correct directory. Bug #25555 by Brett

-* Raise Gem::LoadError if Kernel#gem fails due to previously-loaded gem. Bug

- reported by Alf Mikula.

-Deprecation Notices:

-* Gem::manage_gems has been removed.

-* Time::today has been removed early. There was no way to make it warn and be

- easy to override with user code.

-=== 1.3.2 / 2009-04-15

-Select New Features:

-* RubyGems now loads plugins from rubygems_plugin.rb in installed gems.

- This can be used to add commands (See Gem::CommandManager) or add

- install/uninstall hooks (See Gem::Installer and Gem::Uninstaller).

-* Gem::Version now understands prerelease versions using letters. (eg.

- '1.2.1.b') Thanks to Josh Susser, Alex Vollmer and Phil Hagelberg.

-* RubyGems now includes a Rake task for creating gems which replaces rake's

- Rake::GemPackageTask. See Gem::PackageTask.

-* Gem::find_files now returns paths in $LOAD_PATH.

-* Added Gem::promote_load_path for use with Gem::find_files

-* Added Gem::bin_path to make finding executables easier. Patch #24114 by

-* Various improvements to build arguments for installing gems.

-* `gem contents` added --all and --no-prefix.

-* Gem::Specification

- * #validate strips directories and errors on not-files.

- * #description no longer removes newlines.

- * #name must be a String.

- * FIXME and TODO are no longer allowed in various fields.

- * Added support for a license attribute. Feature #11041 (partial).

- * Removed Gem::Specification::list, too much process growth. Bug #23668 by

-* `gem generate_index`

- * Can now generate an RSS feed.

- * Modern indicies can now be updated incrementally.

- * Legacy indicies can be updated separately from modern.

-* Better gem activation error message. Patch #23082.

-* Kernel methods are now private. Patch #20801 by James M. Lawrence.

-* Fixed various usability issues with `gem check`.

-* `gem update` now rescues InstallError and continues. Bug #19268 by Gabriel

-* Allow 'https', 'file' as a valid schemes for --source. Patch #22485.

- * Now removes existing path before installing. Bug #22837.

- * Uses Gem::bin_path in executable stubs to work around Kernel#load bug in

- * Correctly handle build args (after --) via the API. Bug #23210.

- * `gem install --no-user-install` now works. Patch #23573 by Alf Mikula.

- * `gem uninstall` can now uninstall from ~/.gem. Bug #23760 by Roger Pack.

- * Clarify RubyGems RDoc installation location. Bug #22656 by Gian Marco

- * Allow setup to run from read-only location. Patch #21862 by Luis Herrera.

- * Fixed overwriting ruby executable when BASERUBY was not set. Bug #24958

- by Michael Soulier.

- * Ensure we're in a RubyGems dir when installing.

- * Deal with extraneous quotation mark when autogenerating .bat file on MS

- Windows. Bug #22712.

-Deprecation Notices:

-* Gem::manage_gems has been removed.

-* Time::today will be removed in RubyGems 1.4.

-Special thanks to Chad Wooley for backwards compatibility testing and Luis

-Lavena and Daniel Berger for continuing windows support.

-=== 1.3.1 / 2008-10-28

-* Disregard ownership of ~ under Windows while creating ~/.gem. Fixes

- issues related to no uid support under Windows.

-* Fix requires for Gem::inflate, Gem::deflate, etc.

-* Make Gem.dir respect :gemhome value from config. (Note: this feature may be

- removed since it is hard to implement on 1.9.)

-* Kernel methods are now private. Patch #20801 by James M. Lawrence.

-* Gem::location_of_caller now behaves on Windows. Patch by Daniel Berger.

-* Silence PATH warning.

-Deprecation Notices:

-* Gem::manage_gems will be removed on or after March 2009.

-=== 1.3.0 / 2008-09-25

-* RubyGems doesn't print LOCAL/REMOTE titles for `gem query` and friends if

- stdout is not a TTY, except with --both.

-* Added Gem.find_files, allows a gem to discover features provided by other

-* Added pre/post (un)install hooks for packagers of RubyGems. (Not for gems

-* RubyGems now installs gems into ~/.gem if GEM_HOME is not writable. Use

- --no-user-install command-line switch to disable this behavior.

-* Fetching specs for update now uses If-Modified-Since requests.

-* RubyGems now updates the ri cache when the rdoc gem is installed and

- documentation is generated.

-Deprecation Notices:

-* Gem::manage_gems now warns when called. It will be removed on or after March

-* RubyGems 1.3.0+ now updates when no previous rubygems-update is installed.

- Bug #20775 by Hemant Kumar.

-* RubyGems now uses the regexp we already have for `gem list --installed`. Bug

- #20876 by Nick Hoffman.

-* Platform is now forced to Gem::Platform::RUBY when nil or blank in the

- indexer. Fixes various uninstallable gems.

-* Handle EINVAL on seek. Based on patch in bug #20791 by Neil Wilson.

-* Fix HTTPS support. Patch #21072 by Alex Arnell.

-* RubyGems now loads all cache files even if latest has been loaded. Bug

- #20776 by Uwe Kubosch.

-* RubyGems checks for support of development dependencies for #to_ruby. Bug

- #20778 by Evan Weaver.

-* Now specifications from the future can be loaded.

-* Binary script uninstallation fixed. Bug #21234 by Neil Wilson.

-* Uninstallation with -i fixed. Bug #20812 by John Clayton.

-* Gem::Uninstaller#remove_all now calls Gem::Uninstaller#uninstall_gem so hooks

- get called. Bug #21242 by Neil Wilson.

-* Gem.ruby now properly escaped on windows. Fixes problem with extension

-* `gem lock --strict` works again. Patch #21814 by Sven Engelhardt.

-* Platform detection for Solaris was improved. Patch #21911 by Bob Remeika.

-Other Changes Include:

-* `gem help install` now describes _version_ argument to executable stubs

-* `gem help environment` describes environment variables and ~/.gemrc and

-* On-disk gemspecs are now read in UTF-8 and written with a UTF-8 magic comment

- * If the SETUP_OPTIONS environment variable is set, pass its contents as

- arguments to setup.rb

-* lib/rubygems/platform.rb

- * Remove deprecated constant warnings and really deprecate them. (WIN32,

-* lib/rubygems/remote_fetcher.rb

- * Now uses ~/.gem/cache if the cache dir in GEM_HOME is not writable.

-* lib/rubygems/source_index.rb

- * Deprecate options to 'search' other than Gem::Dependency instances and

- issue warning until November 2008.

- * --destdir folder structure now built using Pathname, so it works for

- Windows platforms.

- * Fixes to run tests when under test/rubygems/. Patch by Yusuke ENDOH

- [ruby-core:17353].

-* test/test_ext_configure_builder.rb

- * Locale-free patch by Yusuke Endoh [ruby-core:17444].

-=== 1.2.0 / 2008-06-21

-* RubyGems no longer performs bulk updates and instead only fetches the gemspec

- files it needs. Alternate sources will need to upgrade to RubyGems 1.2 to

- allow RubyGems to take advantage of the new metadata updater. If a pre 1.2

- remote source is in the sources list, RubyGems will revert to the bulk update

- code for compatibility.

-* RubyGems now has runtime and development dependency types. Use

- #add_development_dependency and #add_runtime_dependency. All typeless

- dependencies are considered to be runtime dependencies.

-* RubyGems will now require rubygems/defaults/operating_system.rb and

- rubygems/defaults/#{RBX_ENGINE}.rb if they exist. This allows packagers and

- ruby implementers to add custom behavior to RubyGems via these files. (If

- the RubyGems API is insufficient, please suggest improvements via the

-* /etc/gemrc (and windows equivalent) for global settings

-* setup.rb now handles --vendor and --destdir for packagers

-* `gem stale` command that lists gems by last access time

-* File modes from gems are now honored, patch #19737

-* Marshal Gem::Specification objects from the future can now be loaded.

-* A trailing / is now added to remote sources when missing, bug #20134

-* Gems with legacy platforms will now be correctly uninstalled, patch #19877

-* `gem install --no-wrappers` followed by `gem install --wrappers` no longer

- overwrites executables

-* `gem pristine` now forces reinstallation of gems, bug #20387

-* RubyGems gracefully handles ^C while loading .gemspec files from disk, bug

-* Paths are expanded in more places, bug #19317, bug #19896

-* Gem::DependencyInstaller resets installed gems every install, bug #19444

-* Gem.default_path is now honored if GEM_PATH is not set, patch #19502

-Other Changes Include:

- * stub files created by RubyGems 0.7.x and older are no longer removed. When

- upgrading from these ancient versions, upgrade to 1.1.x first to clean up

- * RDoc is no longer required until necessary, patch #20414

- * Now completely matches the output of `gem generate_index` and

- has correct content types

- * Refreshes from source directories for every hit. The server will no longer

- need to be restarted after installing gems.

-* `gem query --details` and friends now display author, homepage, rubyforge url

- and installed location

-* `gem install` without -i no longer reinstalls dependencies if they are in

- GEM_PATH but not in GEM_HOME

-* Gem::RemoteFetcher now performs persistent connections for HEAD requests,

-=== 1.1.1 / 2008-04-11

-* Gem.prefix now returns non-nil only when RubyGems was installed outside

- sitelibdir or libdir.

-* The `gem server` gem list now correctly links to gem details.

-* `gem update --system` now passes --no-format-executable to setup.rb.

-* Gem::SourceIndex#refresh! now works with multiple gem repositories.

-* Downloaded gems now go into --install-dir's cache directory.

-* Various fixes to downloading gem metadata.

-* `gem install --force` now ignores network errors too.

-* `gem pristine` now rebuilds extensions.

-* `gem update --system` now works on virgin Apple ruby.

-* Gem::RemoteFetcher handles Errno::ECONNABORTED.

-* Printing of release notes fixed.

-=== 1.1.0 / 2008-03-29

-* RubyGems now uses persistent connections on index updates. Index updates are

-* RubyGems only updates from a latest index by default, cutting candidate gems

- for updates to roughly 1/4 (at present). Index updates are even faster

- * `gem list -r` may only show the latest version of a gem, add --all to see

-* `gem spec` now extracts specifications from .gem files.

-* `gem query --installed` to aid automation of checking for gems.

-* RubyGems works with both Config and RbConfig now.

-* Executables are now cleaned upon uninstall.

-* You can now uninstall from a particular directory.

-* Updating from non-default sources fixed.

-* Executable stubs now use ruby install name in shebang.

-* `gem unpack` checks every directory in Gem.path now.

-* `gem install` now exits with non-zero exit code when appropriate.

-* `gem update` only updates gems that need updates.

-* `gem update` doesn't force remote-only updates.

-* `gem update` handles dependencies properly when updating.

-* Gems are now loaded in Gem.path order.

-* Gem stub scripts on windows now work outside Gem.bindir.

-* `gem sources -r` now works without network access.

-Other Changes Include:

-* RubyGems now requires Ruby > 1.8.3.

-* Release notes are now printed upon installation.

-* `gem env path` now prints a usable path.

-* `gem install` reverts to local-only installation upon network error.

-* Tar handling code refactoring and cleanup.

-* Gem::DependencyInstaller's API has changed.

-For a full list of changes to RubyGems, see the ChangeLog file.

-=== 1.0.1 / 2007-12-20

-* Installation on Ruby 1.8.3 through 1.8.5 fixed

-* `gem build` on 1.8.3 fixed

-Other Changes Include:

-* Since RubyGems 0.9.5, RubyGems is no longer supported on Ruby 1.8.2 or older,

- this is official in RubyGems 1.0.1.

-=== 1.0.0 / 2007-12-20

-Major New Features Include:

-* RubyGems warns about various problems with gemspecs during gem building

-* More-consistent versioning for the RubyGems software

-Other Changes Include:

-* Fixed various bugs and problems with installing gems on Windows

-* Fixed using `gem server` for installing gems

-* Various operations are even more verbose with --verbose

-* Built gems are now backwards compatible with 0.9.4

-* Improved detection of RUBYOPT loading rubygems

-* `ruby setup.rb` now has a --help option

-* Gem::Specification#bindir is now respected on installation

-* Executable stubs can now be installed to match ruby's name, so if ruby is

- installed as 'ruby18', foo_exec will be installed as 'foo_exec18'

-* `gem unpack` can now unpack into a specific directory with --target

-* OpenSSL is no longer required by default

-Deprecations and Deletions:

-* Kernel#require_gem has been removed

-* Executables without a shebang will not be wrapped in a future version, this

- may cause such executables to fail to operate on installation

-* Gem::Platform constants other than RUBY and CURRENT have been removed

-* Gem::RemoteInstaller was removed

-* Gem::Specification#test_suite_file and #test_suite_file= are deprecated in

- favor of #test_file and #test_file=

-* Gem::Specification#autorequire= has been deprecated

-* Time::today will be removed in a future version

-=== 0.9.5 / 2007-11-19

-Major New Features Include:

-* Automatic installation of platform gems

-* New bandwidth and memory friendlier index file format

-* "Offline" mode (--no-update-sources)

-* Bulk update threshold can be specified (-B, --bulk-threshold)

-* New `gem fetch` command

-* `gem` now has "really verbose" output when you specify -v

-* Improved stubs and `gem.bat` on mswin, including better compatiblity

- with the One-Click Installer.

-Other Changes Include:

-* Time::today is deprecated and will be removed at a future date

-* Gem::manage_gems is deprecated and will be removed at a future date

-* `gem install --include-dependencies` (-y) is now deprecated since it is the

- default, use --ignore-dependencies to turn off automatic dependency

-* Multi-version diamond dependencies only are installed once

-* Processing a YAML bulk index update takes less memory

-* `gem install -i` makes sure all depenencies are installed

-* `gem update --system` reinstalls into the prefix it was originally installed

-* `gem update --system` respects --no-rdoc and --no-ri flags

-* HTTP basic authentication support for proxies

-* Gem::Specification#platforms should no longer be a String, use

- Gem::Platform::CURRENT when building binary gems instead

-* `gem env` has more diagnostic information

-* require 'rubygems' loads less code

-* sources.gem is gone, RubyGems now uses built-in defaults

-* `gem install --source` will no longer add --source by default, use `gem

- sources --add` to make it a permanent extra source

-* `gem query` (list) no longer prints details by default

-* Exact gem names are matched in various places

-* mkrf extensions are now supported

-* A gem can depend on a specific RubyGems version

-* `gem_server` is now `gem server`

-* `gemlock` is now `gem lock`

-* `gem_mirror` is now `gem mirror`

-* `gemwhich` is now `gem which`

-* `gemri` is no longer included with RubyGems

-* `index_gem_repository.rb` is now `gem generate_index`

-* `gem` performs more validation of parameters

-* Custom rdoc styles are now supported

-* Gem indexer no longer removes quick index during index creation

-* Kernel#require only rescues a LoadError for the file being required now

-* `gem dependencies` can now display some information for remote gems

-* Updating RubyGems now works with RUBYOPT=-rubygems

-=== 0.9.4 / 2007-05-23

-If you are experiencing problems with the source index (e.g. strange

-"No Method" errors), or problems with zlib (e.g. "Buffer Error"

-messsage), we recommend upgrading to RubyGems 0.9.4.

-* Several people have been experiencing problems with no method errors

- on the source index cache. The source index cache is now a bit more

- self healing. Furthermore, if the source index cache is

- irreparable, then it is automatically dropped and reloaded.

-* The source cache files may now be dropped with the "gem sources

- --clear-all" command. (This command may require root is the system

- source cache is in a root protected area).

-* Several sub-commands were accidently dropped from the "gem" command.

- These commands have been restored.

-=== 0.9.3 / 2007-05-10

-The ZLib library on Windows will occasionally complains about a buffer error

-when unpacking gems. The Gems software has a workaround for that problem, but

-the workaround was only enabled for versions of ZLib 1.2.1 or earlier. We

-have received several reports of the error occuring with ZLib 1.2.3, so we

-have permanently enabled the work around on all versions.

-=== 0.9.2 / 2007-02-05

-* The "unpack" command now works properly.

-* User name and password are now passed properly to the authenticating

- proxy when downloading gems.

-=== 0.9.1 / 2007-01-16

-=== 0.9.0 / 2006-06-28

-Finally, the much anticipated RubyGems version 0.9.0 is now available.

-This release includes a number of new features and bug fixes. The

-number one change is that we can now download the gem index

-incrementally. This will greatly speed up the gem command when only a

-few gems are out of date.

-Major Enhancments include:

-* The gem index is now downloaded incrementally, only updating entries

- that are out of date. If more than 50 entries are out of date, we

- revert back to a bulk download.

-* Several patches related to allowing RubyGems to work with

- authenticating proxies (from Danie Roux and Anatol Pomozov). Just

- put the user and password in the proxy URL (e.g. -p

- http://user:password@proxy.address.com:8080) or use the

- HTTP_PROXY_USER and HTTP_PROXY_PASS environment variables.

-* The gem unpack command can now accept a file path rather than just a

-* Both RI and RDOC documents are now generated by default.

-* A gemri command is included to read gem RI docs (only needed for

- Ruby 1.8.4 or earlier).

-Minor enhancements include:

-* Verison 0.0.0 is now a valid gem version.

-* Better detection of missing SSL functionality.

-* SSL is not required if the security policy does not require

- signature checking.

-* Rake built extensions are now supported (Tilman Sauerbeck).

-* Several autorequire bug fixes.

-* --traceback is now an alias for --backtrace (I can never remember

-* SAFE=1 compatibility fixes.

-* .rbw is now a supported suffix for RubyGem's custom require.

-* Several Ruby 1.9 compatibility fixes (Eric Hodel).

-* Added dashes to gemspecs generated in Ruby 1.8.3. This solves some

- cross-Ruby version compatibility issues.

-* Fixed bug where the wrong executables could be uninstalled (Eric

-* Fixed bug where gem unpack occasionally unpacked the wrong gem.

-* Fixed bug where a fatal error occured when permissions on .gemrc

- were too restrictive (reported by Luca Pireddu).

-* Fixed prefix handling for native expressions (patch by Aaron Patterson).

-* Fixed several Upgrade => Update typos.

-=== 0.8.11 / 2005-07-13

-* -y is a synonym for --include-dependencies.

-* Better handling of errors in the top level rescue clause.

-* Package list command (e.g. gem inspect GEM).

-* .gemrc now allows cvsrc-like options to set defaults per subcommand.

-* The autorequire gem spec field will now accept a list.

-* Substituted Time for Date in specs, increasing performance

-* Fixed reported bug of gem directories ending in "-" (reported by

-* Fixed but in installer that caused dependency installation to not

-* Added Paul Duncan's gem signing patch.

-* Added Mark Hubbart's Framework patch (for better integration with OS

-* Added David Glasser's install-from-mirror patch.

-* Additional internal structural cleanup and test reorganization.

-=== 0.8.10 / 2005-03-27

-* In multi-user environments, it is common to supply mulitple versions of gems

- (for example Rails), allowing individual users to select the version of the

- gem they desire. This allows a user to be insulated from updates to that

- gem. RubyGems 0.8.10 fixes a problem where gems could occasionally become

- confused about the current versions of libraries selected by the user.

-* The other annoying bug is that if there are any existing rubygems-update gems

- installed, then the "gem update --system" command will download a new

- update, but install the latest update prior to the download.

-=== 0.8.8 / 2005-03-14

-* Moved the master definition of class Requirement back under version.

- Kept the body of Requirement under Gem.

-=== 0.8.7 / 2005-03-14

-Even though it has only been a few weeks since that last release,

-there are quite a number of new features in 0.8.7. A complete list of

-new features will be given below, but here is a summary of the hot

-* The bug that prevented some users from installing rails has been

- squashed. A big thanks to Bill Guindon (aGorilla) for helping track

-There are several new commands available on the gem command:

-* gem cleanup GEMNAME -- Cleanup (uninstall) all the old versions of

- gem. If the gem name is omitted, the entire repository is cleaned.

-* gem dependency GEMNAME -- Show the dependencies for the named gems.

- This is really helpful when trying to figure out what gem needs what

-There changes to the existing commands as well.

-* gem uninstall is much smarter about removing gems from the

- repository. Lists of gems are now uninstalled in proper dependency

- order (ie. if A depends on B, A is uninstalled first). Also,

- warnings about broken dependencies occur only when removing the

- *last* gem that supports a dependency is removed.

-Both gem install and gem uninstall support some new command line

-options that can reduce the amount of yes/no queries given the user.

-For install we have:

-* --ignore-dependencies -- Only install requests gems, no

- dependendecies are automatically installed.

-* --include-dependencies -- Automatically install dependencies,

- without confirmation.

-For gem uninstall, the new options are:

-* --all -- Uninstall all matching gems without confirmation.

-* --ignore-dependencies -- Uninstall, even if dependencies are broken.

-* --executables -- Remove executables without confirmation

-Under general cleanup, gems will not, by default, run RDoc on packages

-that do not have the RDoc flag set.

-And finally there is a new library file 'gemconfigure' to aid in

-writing version sensitive applications (without undue dependencies on

-RubyGems); and 'gemwhich', a short script to locate libraries in the

-file system. You can read more about them here:

-* gemconfigure: http://docs.rubygems.org/read/chapter/4#page73

-* gemwhich: http://docs.rubygems.org/read/chapter/17

-=== 0.8.6 / 2005-02-27

-* Fixed a small bug with shebang construction

-=== 0.8.5 / 2005-02-26

-Do you know how you used to dread getting the following message while

- Updating Gem source index for: http://gems.rubyforge.org

-It could take up to 30 seconds (on my machine, even worse on others) for

-that crazy source index to update.

-This latest release of RubyGems speeds that wait time up considerably.

-The following table gives the following times for installing RedCloth

-with a required source index update on three system we had available to

-us. No RDoc generation was included in the following times.

- RubyGems Linux Mac OSX Windows

- 0.8.4 33 secs 73 secs 58 secs

- 0.8.5 8 secs 14 secs 21 secs

-The new caching code is at least 3x faster than previous versions. Woo

-=== 0.8.4 / 2005-01-01

-* Rubygems 0.8.3's installer was broken unless you already had an older

- version of RubyGems installed. That's fixed.

-* Change in the way Gem::Specification internally deals with lazy attributes

- and defaults, bringing (with some loadpath_manager changes) a fairly

- significant increase in speed.

-* Support for lower-cased Gem file names (for you, Paul Duncan :)

-* Erik Veenstra's patch for making Gem versions sortable.

-=== 0.8.3 / 2004-12-07

-No real earth shattering news here, but there were a number of really

-annoying issues involving other libraries that RubyGems depends upon.

-0.8.3 contains some workarounds for these issues. In particular:

-* Added workaround for the null byte in Dir string issue. (see

- http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/121702).

- (Thanks to Mauricio Fernández for the quick response on this one).

-* Added workaround for old version of Zlib on windows that caused

- Ruwiki to fail to install. (see

- http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/121770)

-* Added workaround for large YAML file issues. (We dynamically cut

- down the size of the source index YAML file and seem to have worked

- around immediate issues.

-There has been some minor usability enhancements and changes ...

-* A user specific source index cache can be used when the site-wide

- cache is unwritable (i.e. because you are running as a non-admin).

- This *greatly* speeds up gem commands run in non-admin mode when the

- site-wide cache is out of date.

-* The gem command now used an HTTP HEAD command to detect if the

- server's source index needs to be downloaed.

-* gem check gemname --test will run unit tests on installed gems that

-* Multiple gem names are allowed on the gem install command line.

- This means you can do:

- gem install rake rails needle postgres-pr pimki

- (Ok, you get the idea)

-* Multiple authors my be specified in a Gem spec.

-* Switched to using setup.rb (rather than a custom install script) for

- the installation of RubyGems itself. If you have installed RubyGems

- before, double check the installation instructions and make sure you

- use setup.rb instead of install.rb.

-* Ryan Davis has provided a patch so you can use an env variable

- (GEM_SKIP), to tell loadpath_manager not to load gems of those

- names. This was useful for him while testing libs that he had in

-=== 0.8.1 / 2009-09-14

-* Quick release to capture some bug fixes.

-=== 0.8.0 / 2009-09-12

-* Remove need for library stubs. Set the RUBYOPT environment variable to

- include "rrubygems", and a normal require will find gem files. Continue to

- use 'require_gem gem_name, version' to specify gem versions.

-* Deprecated "test_suite_file" gemspec attribute in favor of "test_files" array.

-* Generates rdoc by default on installs.

-* Adopted tar/gzip file format, thanks to Mauricio Fernandez.

-* "gem rdoc" allows generation of rdoc after gem installation (will add a "gem

-* Application stubs can now accept an optional parameter of _VERSION_ that will

- run an arbitrary version of the application requested.

-* Various bug fixes

-* Various platform-independency improvements

-* "gem spec --all" displays spec info for all installed version of a given gem.

-* Dynamic caching of sources

-* Support for user-definable sources on the command line (thanks Assaph Mehr)

-* More intelligent support for platform-dependent gems. Use Platform::CURRENT

- when building a gem to set its platform to the one you're building on.

- Installation displays a choice of platform-dependent gems, allowing the user

-* Added "gem unpack" for "unpacking" a gem to the current directory

-=== 0.7.0 / 2004-07-09

-=== 0.6.0 / 2004-06-08

-* Collapse output of --search and --list (and gem_server) operations so that

- each gem is listed only once, with each of its versions listed on the same

-* bin/gem: new --upgrade-all option allows one to upgrade every installed gem

-* new #required_ruby_version attribute added to gem specification for

- specifying a dependency on which version of ruby the gem needs. Format it

- accepts is the same as the Gem::Version::Requirement format:

- spec.required_ruby_version = "> 1.8.0"

-* --install-stub defaults to true, so library stubs are created

-=== 0.5.0 / 2004-06-06

-* Jim added the ability to specify version constraints to avoid API

- incompatibilities. This has been the subject of much debate for the past

- couple of months, with many ideas and code contributed by Eivind Eklund and

- Mauricio Fernandez. The following set of assertions shows how it works:

- assert_inadequate("1.3", "~> 1.4")

- assert_adequate( "1.4", "~> 1.4")

- assert_adequate( "1.5", "~> 1.4")

- assert_inadequate("2.0", "~> 1.4") # This one is key--the new operator

- # disallows major version number

-* Group gem search output when multiple versions exist for a given gem:

- activerecord (0.7.8, 0.7.7, 0.7.6, 0.7.5)

- Implements the ActiveRecord pattern for ORM.

-* Add arbitrary RDoc-able files via gemspec (not just Ruby source files) for

- people who have, for example, README.rdoc in their distributions. Add to

- gemspec via: spec.extra_rdoc_files = ["list", "of", "files"]. Ruby files are

- automatically included.

-* Some small bug fixes

-=== 0.4.0 / 2004-05-31

-* Minor bug fixes including Windows compatability issues

-=== 0.3.0 / 2004-04-30

-* Cleanup of command-line arguments and handling. Most commands accept a

- --local or --remote modifier.

-* Creation of Application Gems (packages that include executable programs).

- See http://rubygems.rubyforge.org/wiki/wiki.pl?DeveloperGuide for information

-* Basic functionality for installing binary gems from source (:extensions

- property of gem specification holds an array of paths to extconf.rb files to

- be used for compilation)

-* Install library "stub" allowing a normal 'require' to work (which then does

- the rubygems require and 'require_gem'

-* --run-tests runs the test suite specified by the "test_suite_file" property

- of a gem specification

-* HTTP Proxy support works. Rewrite of HTTP code.

-* Unit and functional tests added (see Rakefile).

-* Prompt before remote-installing dependencies during gem installation.

-* Config file for storing preferences for 'gem' command usage.

-* Generally improved error messages (still more work to do)

-* Rearranged gem directory structure for cleanliness.

-=== 0.2.0 / 2004-03-14

-* Initial public release

-RubyGems is copyrighted free software by Chad Fowler, Rich Kilmer, Jim

-Weirich and others. You can redistribute it and/or modify it under

-either the terms of the GPL (see the GPL.txt file), or the conditions

- 1. You may make and give away verbatim copies of the source form of the

- software without restriction, provided that you duplicate all of the

- original copyright notices and associated disclaimers.

- 2. You may modify your copy of the software in any way, provided that

- you do at least ONE of the following:

- a) place your modifications in the Public Domain or otherwise

- make them Freely Available, such as by posting said

- modifications to Usenet or an equivalent medium, or by allowing

- the author to include your modifications in the software.

- b) use the modified software only within your corporation or

- c) rename any non-standard executables so the names do not conflict

- with standard executables, which must also be provided.

- d) make other distribution arrangements with the author.

- 3. You may distribute the software in object code or executable

- form, provided that you do at least ONE of the following:

- a) distribute the executables and library files of the software,

- together with instructions (in the manual page or equivalent)

- on where to get the original distribution.

- b) accompany the distribution with the machine-readable source of

- c) give non-standard executables non-standard names, with

- instructions on where to get the original software distribution.

- d) make other distribution arrangements with the author.

- 4. You may modify and include the part of the software into any other

- software (possibly commercial).

- 5. The scripts and library files supplied as input to or produced as

- output from the software do not automatically fall under the

- copyright of the software, but belong to whomever generated them,

- and may be sold commercially, and may be aggregated with this

- 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR

- IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

-* http://rubygems.org/

-* http://docs.rubygems.org/

-* http://rubygems.rubyforge.org/

-* http://rubyforge.org/projects/rubygems

-RubyGems is a package management framework for Ruby.

-This gem is an update for the RubyGems software. You must have an

-installation of RubyGems before this update can be applied.

-See Gem for information on RubyGems (or `ri Gem`)

-To upgrade to the latest RubyGems, run:

- $ gem update --system # you might need to be an administrator or root

-NOTE: RubyGems 1.1 and 1.2 have problems upgrading when there is no

-rubygems-update installed. You will need to use the following instructions

-if you see "Nothing to update".

-If you have an older version of RubyGems installed, then you can still

-do it in two steps:

- $ gem install rubygems-update # again, might need to be admin/root

- $ update_rubygems # ... here too

-If you don't have any RubyGems install, there is still the pre-gem approach to

-getting software, doing it manually:

-1. Download from: http://rubyforge.org/frs/?group_id=126

-2. Unpack into a directory and cd there

-3. Install with: ruby setup.rb # you may need admin/root privilege

-For more details and other options, see:

- ruby setup.rb --help

-encsrcdir = @srcdir@

-exec_prefix = @exec_prefix@

-top_srcdir = $(encsrcdir:/enc=)

-srcdir = $(top_srcdir)

-hdrdir = $(srcdir)/include

-arch_hdrdir = $(EXTOUT)/include/$(arch)

-ENCSODIR = $(EXTOUT)/$(arch)/enc

-TRANSSODIR = $(ENCSODIR)/trans

-BUILTIN_ENCS = ascii.c us_ascii.c\

-BUILTIN_TRANSES = newline.trans

-RUBY_SO_NAME = @RUBY_SO_NAME@

-LIBRUBY = @LIBRUBY@

-LIBRUBYARG_SHARED = @LIBRUBYARG_SHARED@

-LIBRUBYARG_STATIC = $(LIBRUBYARG_SHARED)

-OUTFLAG = @OUTFLAG@$(empty)

-COUTFLAG = @COUTFLAG@$(empty)

-CFLAGS = $(CCDLFLAGS) @CFLAGS@ @ARCH_FLAG@

-optflags = @optflags@

-debugflags = @debugflags@

-warnflags = @warnflags@

-CCDLFLAGS = @CCDLFLAGS@

-INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(top_srcdir)

-CPPFLAGS = @CPPFLAGS@ -DONIG_ENC_REGISTER=rb_enc_register

-LDFLAGS = @LDFLAGS@

-LDSHARED = @LDSHARED@

-ldflags = $(LDFLAGS)

-dldflags = @DLDFLAGS@

-archflag = @ARCH_FLAG@

-DLDFLAGS = $(ldflags) $(dldflags) $(archflag)

-WORKDIRS = $(ENCSODIR) $(TRANSSODIR) enc enc/trans

-MAKEDIRS = @MAKEDIRS@

- $(MAKEDIRS) $(WORKDIRS)

-distclean: clean clean-srcs

-realclean: distclean

-/**********************************************************************

- ascii.c - Oniguruma (regular expression library)

-**********************************************************************/

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * 1. Redistributions of source code must retain the above copyright

- * notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- * notice, this list of conditions and the following disclaimer in the

- * documentation and/or other materials provided with the distribution.

- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

-#include "regenc.h"

-OnigEncodingDefine(ascii, ASCII) = {

- onigenc_single_byte_mbc_enc_len,

- "ASCII-8BIT",/* name */

- 1, /* max byte length */

- 1, /* min byte length */

- onigenc_is_mbc_newline_0x0a,

- onigenc_single_byte_mbc_to_code,

- onigenc_single_byte_code_to_mbclen,

- onigenc_single_byte_code_to_mbc,

- onigenc_ascii_mbc_case_fold,

- onigenc_ascii_apply_all_case_fold,

- onigenc_ascii_get_case_fold_codes_by_str,

- onigenc_minimum_property_name_to_ctype,

- onigenc_ascii_is_code_ctype,

- onigenc_not_support_get_ctype_code_range,

- onigenc_single_byte_left_adjust_char_head,

- onigenc_always_true_is_allowed_reverse_match

-ENC_ALIAS("BINARY", "ASCII-8BIT")

-ENC_REPLICATE("IBM437", "ASCII-8BIT")

-ENC_ALIAS("CP437", "IBM437")

-ENC_REPLICATE("IBM737", "ASCII-8BIT")

-ENC_ALIAS("CP737", "IBM737")

-ENC_REPLICATE("IBM775", "ASCII-8BIT")

-ENC_ALIAS("CP775", "IBM775")

-ENC_REPLICATE("CP850", "ASCII-8BIT")

-ENC_ALIAS("IBM850", "CP850")

-ENC_REPLICATE("IBM852", "ASCII-8BIT")

-ENC_REPLICATE("CP852", "IBM852")

-ENC_REPLICATE("IBM855", "ASCII-8BIT")

-ENC_REPLICATE("CP855", "IBM855")

-ENC_REPLICATE("IBM857", "ASCII-8BIT")

-ENC_ALIAS("CP857", "IBM857")

-ENC_REPLICATE("IBM860", "ASCII-8BIT")

-ENC_ALIAS("CP860", "IBM860")

-ENC_REPLICATE("IBM861", "ASCII-8BIT")

-ENC_ALIAS("CP861", "IBM861")

-ENC_REPLICATE("IBM862", "ASCII-8BIT")

-ENC_ALIAS("CP862", "IBM862")

-ENC_REPLICATE("IBM863", "ASCII-8BIT")

-ENC_ALIAS("CP863", "IBM863")

-ENC_REPLICATE("IBM864", "ASCII-8BIT")

-ENC_ALIAS("CP864", "IBM864")

-ENC_REPLICATE("IBM865", "ASCII-8BIT")

-ENC_ALIAS("CP865", "IBM865")

-ENC_REPLICATE("IBM866", "ASCII-8BIT")

-ENC_ALIAS("CP866", "IBM866")

-ENC_REPLICATE("IBM869", "ASCII-8BIT")

-ENC_ALIAS("CP869", "IBM869")

-ENC_REPLICATE("Windows-1258", "ASCII-8BIT")

-ENC_ALIAS("CP1258", "Windows-1258")

-ENC_REPLICATE("GB1988", "ASCII-8BIT")

-ENC_REPLICATE("macCentEuro", "ASCII-8BIT")

-ENC_REPLICATE("macCroatian", "ASCII-8BIT")

-ENC_REPLICATE("macCyrillic", "ASCII-8BIT")

-ENC_REPLICATE("macGreek", "ASCII-8BIT")

-ENC_REPLICATE("macIceland", "ASCII-8BIT")

-ENC_REPLICATE("macRoman", "ASCII-8BIT")

-ENC_REPLICATE("macRomania", "ASCII-8BIT")

-ENC_REPLICATE("macThai", "ASCII-8BIT")

-ENC_REPLICATE("macTurkish", "ASCII-8BIT")

-ENC_REPLICATE("macUkraine", "ASCII-8BIT")

-/**********************************************************************

- big5.c - Oniguruma (regular expression library)