* sprintf.c (rb_str_format): allow %c to print one character

  string (e.g. ?x).

* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
  basename and pid.  [ruby-talk:196272]
* parse.y (do_block): remove -> style block.

* parse.y (parser_yylex): remove tLAMBDA_ARG.

* eval.c (rb_call0): binding for the return event hook should have
  consistent scope.  [ruby-core:07928]

* eval.c (proc_invoke): return behavior should depend whether it
  is surrounded by a lambda or a mere block.

* eval.c (formal_assign): handles post splat arguments.

* eval.c (rb_call0): ditto.

* st.c (strhash): use FNV-1a hash.

* parse.y (parser_yylex): removed experimental ';;' terminator.

* eval.c (rb_node_arity): should be aware of post splat arguments.

* eval.c (rb_proc_arity): ditto.

* parse.y (f_args): syntax rule enhanced to support arguments
  after the splat.

* parse.y (block_param): ditto for block parameters.

* parse.y (f_post_arg): mandatory formal arguments after the splat
  argument.

* parse.y (new_args_gen): generate nodes for mandatory formal
  arguments after the splat argument.

* eval.c (rb_eval): dispatch mandatory formal arguments after the
  splat argument.

* parse.y (args): allow more than one splat in the argument list.

* parse.y (method_call): allow aref [] to accept all kind of
  method argument, including assocs, splat, and block argument.

* eval.c (SETUP_ARGS0): prepare block argument as well.

* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]

* eval.c (error_line): print receivers true/false/nil specially.

* eval.c (rb_proc_yield): handles parameters in yield semantics.

* eval.c (nil_yield): gives LocalJumpError to denote no block
  error.

* io.c (rb_io_getc): now takes one-character string.

* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
  hashing algorithm.

* string.c (rb_str_aref): str[0] now returns 1 character string,
  instead of a fixnum.	[Ruby2]

* parse.y (parser_yylex): ?c now returns 1 character string,
  instead of a fixnum.	[Ruby2]

* string.c (rb_str_aset): no longer support fixnum insertion.

* eval.c (umethod_bind): should not update original class.
  [ruby-dev:28636]

* eval.c (ev_const_get): should support constant access from
  within instance_eval().  [ruby-dev:28327]

* time.c (time_timeval): should round for usec floating
  number.  [ruby-core:07896]

* time.c (time_add): ditto.

* dir.c (sys_warning): should not call a vararg function
  rb_sys_warning() indirectly.	[ruby-core:07886]

* numeric.c (flo_divmod): the first element of Float#divmod should
  be an integer. [ruby-dev:28589]

* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.

* 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.

* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
  typo fixed.  a patch from Florian Gross <florg at florg.net>.

* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
  event_hooks.	no guarantee for arbitrary hook deletion.
  [ruby-dev:28632]

* util.c (ruby_strtod): differ addition to minimize error.
  [ruby-dev:28619]

* util.c (ruby_strtod): should not raise ERANGE when the input
  string does not have any digits.  [ruby-dev:28629]

* eval.c (proc_invoke): should restore old ruby_frame->block.
  thanks to ts <decoux at moulon.inra.fr>.  [ruby-core:07833]
  also fix [ruby-dev:28614] as well.

* signal.c (trap): sig should be less then NSIG.  Coverity found
  this bug.  a patch from Kevin Tew <tewk at tewk.com>.
  [ruby-core:07823]

* math.c (math_log2): add new method inspired by
  [ruby-talk:191237].

* math.c (math_log): add optional base argument to Math::log().
  [ruby-talk:191308]

* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
  uninitialized array element.	a patch from Pat Eyler
  <rubypate at gmail.com>.  [ruby-core:07809]

* array.c (rb_ary_fill): initialize local variables first.  a
  patch from Pat Eyler <rubypate at gmail.com>.	 [ruby-core:07810]

* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
  type_tag.  a patch from Pat Eyler <rubypate at gmail.com>.
  [ruby-core:07808]

* ext/socket/socket.c (make_hostent_internal): accept ai_family
  check from Sam Roberts <sroberts at uniserve.com>.
  [ruby-core:07691]

* util.c (ruby_strtod): should not cut off 18 digits for no
  reason.  [ruby-core:07796]

* array.c (rb_ary_fill): internalize local variable "beg" to
  pacify Coverity.  [ruby-core:07770]

* pack.c (pack_unpack): now supports CRLF newlines.  a patch from
  <tommy at tmtm.org>.	[ruby-dev:28601]

* applied code clean-up patch from Stefan Huehner
  <stefan at huehner.org>.  [ruby-core:07764]

* lib/jcode.rb (String::tr_s): should have translated non
  squeezing character sequence (i.e. a character) as well.  thanks
  to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]

* ext/socket/socket.c: document update patch from Sam Roberts
  <sroberts at uniserve.com>.  [ruby-core:07701]

* lib/mathn.rb (Integer): need not to remove gcd2.  a patch from
  NARUSE, Yui <naruse at airemix.com>.	[ruby-dev:28570]

* parse.y (arg): too much NEW_LIST()

* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.

* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
  [ruby-dev:28585]

* parse.y (arg): use NODE_ARGSCAT for placeholder.

* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
  mathew <meta at pobox.com>.  [ruby-core:07738]

* variable.c (rb_const_set): raise error when no target klass is
  supplied.  [ruby-dev:28582]

* prec.c (prec_prec_f): documentation patch from
  <gerardo.santana at gmail.com>.  [ruby-core:07689]

* bignum.c (rb_big_pow): second operand may be too big even if
  it's a Fixnum.  [ruby-talk:187984]

* README.EXT: update symbol description.  [ruby-talk:188104]

* COPYING: explicitly note GPLv2.  [ruby-talk:187922]

* parse.y: remove some obsolete syntax rules (unparenthesized
  method calls in argument list).

* eval.c (rb_call0): insecure calling should be checked for non
  NODE_SCOPE method invocations too.

* eval.c (rb_alias): should preserve the current safe level as
  well as method definition.

* process.c (rb_f_sleep): remove RDoc description about SIGALRM
  which is not valid on the current implementation. [ruby-dev:28464]

 Thu Mar 23 21:40:47 2006  K.Kosako  <sndgk393 AT ybb.ne.jp>

* eval.c (method_missing): should support argument splat in
  super.  a bug in combination of super, splat and
  method_missing.  [ruby-talk:185438]

* configure.in: Solaris SunPro compiler -rapth patch from
  <kuwa at labs.fujitsu.com>.  [ruby-dev:28443]

* configure.in: remove enable_rpath=no for Solaris.
  [ruby-dev:28440]

* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
  of converting  OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
  String object.

* ruby.1: a clarification patch from David Lutterkort
  <dlutter at redhat.com>.  [ruby-core:7508]

* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
  directories.	a patch from Eric Hodel <drbrain at segment7.net>.
  [ruby-core:07423]

* eval.c (rb_clear_cache_by_class): clearing wrong cache.

* ext/extmk.rb: use :remove_destination to install extension libraries
  to avoid SEGV.  [ruby-dev:28417]

* eval.c (rb_thread_fd_writable): should not re-schedule output
  from KILLED thread (must be error printing).

* array.c (rb_ary_flatten_bang): allow specifying recursion
  level.  [ruby-talk:182170]

* array.c (rb_ary_flatten): ditto.

* gc.c (add_heap): a heap_slots may overflow.  a patch from Stefan
  Weil <weil at mail.berlios.de>.

* eval.c (rb_call): use separate cache for fcall/vcall
  invocation.

* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
  functions.

* eval.c (rb_mod_local): a new method to specify newly added
  visibility "local".

* eval.c (search_method): search for local methods which are
  visible only from the current class.

* class.c (rb_class_local_methods): a method to list local methods.

* object.c (Init_Object): add BasicObject class as a top level
  BlankSlate class.

* ruby.h (SYM2ID): should not cast to signed long.
  [ruby-core:07414]

* class.c (rb_include_module): allow module duplication.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 142 insertions, 132 deletions

diff --git a/sample/test.rb b/sample/test.rb
index 8003e8743f..e6a500c4b5 100644
--- a/sample/test.rb
+++ b/sample/test.rb
@@ -54,13 +54,13 @@ a = [*[]]; test_ok(a == [])
 a = [*[1]]; test_ok(a == [1])
 a = [*[1,2]]; test_ok(a == [1,2])
 
-a = *[]; test_ok(a == nil)
-a = *[1]; test_ok(a == 1)
-a = *[nil]; test_ok(a == nil)
-a = *[[]]; test_ok(a == [])
+a = *[]; test_ok(a == [])
+a = *[1]; test_ok(a == [1])
+a = *[nil]; test_ok(a == [nil])
+a = *[[]]; test_ok(a == [[]])
 a = *[1,2]; test_ok(a == [1,2])
-a = *[*[]]; test_ok(a == nil)
-a = *[*[1]]; test_ok(a == 1)
+a = *[*[]]; test_ok(a == [])
+a = *[*[1]]; test_ok(a == [1])
 a = *[*[1,2]]; test_ok(a == [1,2])
 
 a, = nil; test_ok(a == nil)
@@ -87,14 +87,14 @@ a, = *[*[1,2]]; test_ok(a == 1)
 
 *a = nil; test_ok(a == [nil])
 *a = 1; test_ok(a == [1])
-*a = []; test_ok(a == [[]])
-*a = [1]; test_ok(a == [[1]])
-*a = [nil]; test_ok(a == [[nil]])
-*a = [[]]; test_ok(a == [[[]]])
-*a = [1,2]; test_ok(a == [[1,2]])
-*a = [*[]]; test_ok(a == [[]])
-*a = [*[1]]; test_ok(a == [[1]])
-*a = [*[1,2]]; test_ok(a == [[1,2]])
+*a = []; test_ok(a == [])
+*a = [1]; test_ok(a == [1])
+*a = [nil]; test_ok(a == [nil])
+*a = [[]]; test_ok(a == [[]])
+*a = [1,2]; test_ok(a == [1,2])
+*a = [*[]]; test_ok(a == [])
+*a = [*[1]]; test_ok(a == [1])
+*a = [*[1,2]]; test_ok(a == [1,2])
 
 *a = *[]; test_ok(a == [])
 *a = *[1]; test_ok(a == [1])
@@ -127,18 +127,13 @@ a,b,*c = *[*[1,2]]; test_ok([a,b,c] == [1,2,[]])
 
 def f; yield nil; end; f {|a| test_ok(a == nil)}
 def f; yield 1; end; f {|a| test_ok(a == 1)}
-def f; yield []; end; f {|a| test_ok(a == [])}
-def f; yield [1]; end; f {|a| test_ok(a == [1])}
-def f; yield [nil]; end; f {|a| test_ok(a == [nil])}
-def f; yield [[]]; end; f {|a| test_ok(a == [[]])}
-def f; yield [*[]]; end; f {|a| test_ok(a == [])}
-def f; yield [*[1]]; end; f {|a| test_ok(a == [1])}
-def f; yield [*[1,2]]; end; f {|a| test_ok(a == [1,2])}
-
+def f; yield *[]; end; f {|a| test_ok(a == nil)}
 def f; yield *[1]; end; f {|a| test_ok(a == 1)}
 def f; yield *[nil]; end; f {|a| test_ok(a == nil)}
 def f; yield *[[]]; end; f {|a| test_ok(a == [])}
+def f; yield *[*[]]; end; f {|a| test_ok(a == nil)}
 def f; yield *[*[1]]; end; f {|a| test_ok(a == 1)}
+def f; yield *[*[1,2]]; end; f {|a| test_ok(a == 1)}
 
 def f; yield; end; f {|a,| test_ok(a == nil)}
 def f; yield nil; end; f {|a,| test_ok(a == nil)}
@@ -162,14 +157,14 @@ def f; yield *[*[1,2]]; end; f {|a,| test_ok(a == 1)}
 def f; yield; end; f {|*a| test_ok(a == [])}
 def f; yield nil; end; f {|*a| test_ok(a == [nil])}
 def f; yield 1; end; f {|*a| test_ok(a == [1])}
-def f; yield []; end; f {|*a| test_ok(a == [[]])}
-def f; yield [1]; end; f {|*a| test_ok(a == [[1]])}
-def f; yield [nil]; end; f {|*a| test_ok(a == [[nil]])}
-def f; yield [[]]; end; f {|*a| test_ok(a == [[[]]])}
-def f; yield [1,2]; end; f {|*a| test_ok(a == [[1,2]])}
-def f; yield [*[]]; end; f {|*a| test_ok(a == [[]])}
-def f; yield [*[1]]; end; f {|*a| test_ok(a == [[1]])}
-def f; yield [*[1,2]]; end; f {|*a| test_ok(a == [[1,2]])}
+def f; yield []; end; f {|*a| test_ok(a == [])}
+def f; yield [1]; end; f {|*a| test_ok(a == [1])}
+def f; yield [nil]; end; f {|*a| test_ok(a == [nil])}
+def f; yield [[]]; end; f {|*a| test_ok(a == [[]])}
+def f; yield [1,2]; end; f {|*a| test_ok(a == [1,2])}
+def f; yield [*[]]; end; f {|*a| test_ok(a == [])}
+def f; yield [*[1]]; end; f {|*a| test_ok(a == [1])}
+def f; yield [*[1,2]]; end; f {|*a| test_ok(a == [1,2])}
 
 def f; yield *[]; end; f {|*a| test_ok(a == [])}
 def f; yield *[1]; end; f {|*a| test_ok(a == [1])}
@@ -209,39 +204,39 @@ def r; return [*[]]; end; a = r(); test_ok(a == [])
 def r; return [*[1]]; end; a = r(); test_ok(a == [1])
 def r; return [*[1,2]]; end; a = r(); test_ok(a == [1,2])
 
-def r; return *[]; end; a = r(); test_ok(a == nil)
-def r; return *[1]; end; a = r(); test_ok(a == 1)
-def r; return *[nil]; end; a = r(); test_ok(a == nil)
-def r; return *[[]]; end; a = r(); test_ok(a == [])
-def r; return *[*[]]; end; a = r(); test_ok(a == nil)
-def r; return *[*[1]]; end; a = r(); test_ok(a == 1)
+def r; return *[]; end; a = r(); test_ok(a == [])
+def r; return *[1]; end; a = r(); test_ok(a == [1])
+def r; return *[nil]; end; a = r(); test_ok(a == [nil])
+def r; return *[[]]; end; a = r(); test_ok(a == [[]])
+def r; return *[*[]]; end; a = r(); test_ok(a == [])
+def r; return *[*[1]]; end; a = r(); test_ok(a == [1])
 def r; return *[*[1,2]]; end; a = r(); test_ok(a == [1,2])
 
-def r; return *[[]]; end; a = *r(); test_ok(a == nil)
+def r; return *[[]]; end; a = *r(); test_ok(a == [[]])
 def r; return *[*[1,2]]; end; a = *r(); test_ok(a == [1,2])
 
 def r; return; end; *a = r(); test_ok(a == [nil])
 def r; return nil; end; *a = r(); test_ok(a == [nil])
 def r; return 1; end; *a = r(); test_ok(a == [1])
-def r; return []; end; *a = r(); test_ok(a == [[]])
-def r; return [1]; end; *a = r(); test_ok(a == [[1]])
-def r; return [nil]; end; *a = r(); test_ok(a == [[nil]])
-def r; return [[]]; end; *a = r(); test_ok(a == [[[]]])
-def r; return [1,2]; end; *a = r(); test_ok(a == [[1,2]])
-def r; return [*[]]; end; *a = r(); test_ok(a == [[]])
-def r; return [*[1]]; end; *a = r(); test_ok(a == [[1]])
-def r; return [*[1,2]]; end; *a = r(); test_ok(a == [[1,2]])
-
-def r; return *[]; end; *a = r(); test_ok(a == [nil])
+def r; return []; end; *a = r(); test_ok(a == [])
+def r; return [1]; end; *a = r(); test_ok(a == [1])
+def r; return [nil]; end; *a = r(); test_ok(a == [nil])
+def r; return [[]]; end; *a = r(); test_ok(a == [[]])
+def r; return [1,2]; end; *a = r(); test_ok(a == [1,2])
+def r; return [*[]]; end; *a = r(); test_ok(a == [])
+def r; return [*[1]]; end; *a = r(); test_ok(a == [1])
+def r; return [*[1,2]]; end; *a = r(); test_ok(a == [1,2])
+
+def r; return *[]; end; *a = r(); test_ok(a == [])
 def r; return *[1]; end; *a = r(); test_ok(a == [1])
 def r; return *[nil]; end; *a = r(); test_ok(a == [nil])
 def r; return *[[]]; end; *a = r(); test_ok(a == [[]])
-def r; return *[1,2]; end; *a = r(); test_ok(a == [[1,2]])
-def r; return *[*[]]; end; *a = r(); test_ok(a == [nil])
+def r; return *[1,2]; end; *a = r(); test_ok(a == [1,2])
+def r; return *[*[]]; end; *a = r(); test_ok(a == [])
 def r; return *[*[1]]; end; *a = r(); test_ok(a == [1])
-def r; return *[*[1,2]]; end; *a = r(); test_ok(a == [[1,2]])
+def r; return *[*[1,2]]; end; *a = r(); test_ok(a == [1,2])
 
-def r; return *[[]]; end; *a = *r(); test_ok(a == [])
+def r; return *[[]]; end; *a = *r(); test_ok(a == [[]])
 def r; return *[1,2]; end; *a = *r(); test_ok(a == [1,2])
 def r; return *[*[1,2]]; end; *a = *r(); test_ok(a == [1,2])
 
@@ -260,7 +255,7 @@ def r; return [*[1,2]]; end; a,b,*c = r(); test_ok([a,b,c] == [1,2,[]])
 def r; return *[]; end; a,b,*c = r(); test_ok([a,b,c] == [nil,nil,[]])
 def r; return *[1]; end; a,b,*c = r(); test_ok([a,b,c] == [1,nil,[]])
 def r; return *[nil]; end; a,b,*c = r(); test_ok([a,b,c] == [nil,nil,[]])
-def r; return *[[]]; end; a,b,*c = r(); test_ok([a,b,c] == [nil,nil,[]])
+def r; return *[[]]; end; a,b,*c = r(); test_ok([a,b,c] == [[],nil,[]])
 def r; return *[1,2]; end; a,b,*c = r(); test_ok([a,b,c] == [1,2,[]])
 def r; return *[*[]]; end; a,b,*c = r(); test_ok([a,b,c] == [nil,nil,[]])
 def r; return *[*[1]]; end; a,b,*c = r(); test_ok([a,b,c] == [1,nil,[]])
@@ -316,36 +311,36 @@ a = loop do break [*[]]; end; test_ok(a == [])
 a = loop do break [*[1]]; end; test_ok(a == [1])
 a = loop do break [*[1,2]]; end; test_ok(a == [1,2])
 
-a = loop do break *[]; end; test_ok(a == nil)
-a = loop do break *[1]; end; test_ok(a == 1)
-a = loop do break *[nil]; end; test_ok(a == nil)
-a = loop do break *[[]]; end; test_ok(a == [])
-a = loop do break *[*[]]; end; test_ok(a == nil)
-a = loop do break *[*[1]]; end; test_ok(a == 1)
+a = loop do break *[]; end; test_ok(a == [])
+a = loop do break *[1]; end; test_ok(a == [1])
+a = loop do break *[nil]; end; test_ok(a == [nil])
+a = loop do break *[[]]; end; test_ok(a == [[]])
+a = loop do break *[*[]]; end; test_ok(a == [])
+a = loop do break *[*[1]]; end; test_ok(a == [1])
 a = loop do break *[*[1,2]]; end; test_ok(a == [1,2])
 
 *a = loop do break; end; test_ok(a == [nil])
 *a = loop do break nil; end; test_ok(a == [nil])
 *a = loop do break 1; end; test_ok(a == [1])
-*a = loop do break []; end; test_ok(a == [[]])
-*a = loop do break [1]; end; test_ok(a == [[1]])
-*a = loop do break [nil]; end; test_ok(a == [[nil]])
-*a = loop do break [[]]; end; test_ok(a == [[[]]])
-*a = loop do break [1,2]; end; test_ok(a == [[1,2]])
-*a = loop do break [*[]]; end; test_ok(a == [[]])
-*a = loop do break [*[1]]; end; test_ok(a == [[1]])
-*a = loop do break [*[1,2]]; end; test_ok(a == [[1,2]])
-
-*a = loop do break *[]; end; test_ok(a == [nil])
+*a = loop do break []; end; test_ok(a == [])
+*a = loop do break [1]; end; test_ok(a == [1])
+*a = loop do break [nil]; end; test_ok(a == [nil])
+*a = loop do break [[]]; end; test_ok(a == [[]])
+*a = loop do break [1,2]; end; test_ok(a == [1,2])
+*a = loop do break [*[]]; end; test_ok(a == [])
+*a = loop do break [*[1]]; end; test_ok(a == [1])
+*a = loop do break [*[1,2]]; end; test_ok(a == [1,2])
+
+*a = loop do break *[]; end; test_ok(a == [])
 *a = loop do break *[1]; end; test_ok(a == [1])
 *a = loop do break *[nil]; end; test_ok(a == [nil])
 *a = loop do break *[[]]; end; test_ok(a == [[]])
-*a = loop do break *[1,2]; end; test_ok(a == [[1,2]])
-*a = loop do break *[*[]]; end; test_ok(a == [nil])
+*a = loop do break *[1,2]; end; test_ok(a == [1,2])
+*a = loop do break *[*[]]; end; test_ok(a == [])
 *a = loop do break *[*[1]]; end; test_ok(a == [1])
-*a = loop do break *[*[1,2]]; end; test_ok(a == [[1,2]])
+*a = loop do break *[*[1,2]]; end; test_ok(a == [1,2])
 
-*a = *loop do break *[[]]; end; test_ok(a == [])
+*a = *loop do break *[[]]; end; test_ok(a == [[]])
 *a = *loop do break *[1,2]; end; test_ok(a == [1,2])
 *a = *loop do break *[*[1,2]]; end; test_ok(a == [1,2])
 
@@ -364,7 +359,7 @@ a,b,*c = loop do break [*[1,2]]; end; test_ok([a,b,c] == [1,2,[]])
 a,b,*c = loop do break *[]; end; test_ok([a,b,c] == [nil,nil,[]])
 a,b,*c = loop do break *[1]; end; test_ok([a,b,c] == [1,nil,[]])
 a,b,*c = loop do break *[nil]; end; test_ok([a,b,c] == [nil,nil,[]])
-a,b,*c = loop do break *[[]]; end; test_ok([a,b,c] == [nil,nil,[]])
+a,b,*c = loop do break *[[]]; end; test_ok([a,b,c] == [[],nil,[]])
 a,b,*c = loop do break *[1,2]; end; test_ok([a,b,c] == [1,2,[]])
 a,b,*c = loop do break *[*[]]; end; test_ok([a,b,c] == [nil,nil,[]])
 a,b,*c = loop do break *[*[1]]; end; test_ok([a,b,c] == [1,nil,[]])
@@ -382,29 +377,29 @@ r([]){next [*[]]}
 r([1]){next [*[1]]}
 r([1,2]){next [*[1,2]]}
 
-r(nil){next *[]}
-r(1){next *[1]}
-r(nil){next *[nil]}
-r([]){next *[[]]}
-r(nil){next *[*[]]}
-r(1){next *[*[1]]}
+r([]){next *[]}
+r([1]){next *[1]}
+r([nil]){next *[nil]}
+r([[]]){next *[[]]}
+r([]){next *[*[]]}
+r([1]){next *[*[1]]}
 r([1,2]){next *[*[1,2]]}
 
 def r(val); *a = yield(); test_ok(a == val, 2); end
 r([nil]){next}
 r([nil]){next nil}
 r([1]){next 1}
-r([[]]){next []}
-r([[1]]){next [1]}
-r([[nil]]){next [nil]}
-r([[[]]]){next [[]]}
-r([[1,2]]){next [1,2]}
-r([[]]){next [*[]]}
-r([[1]]){next [*[1]]}
-r([[1,2]]){next [*[1,2]]}
+r([]){next []}
+r([1]){next [1]}
+r([nil]){next [nil]}
+r([[]]){next [[]]}
+r([1,2]){next [1,2]}
+r([]){next [*[]]}
+r([1]){next [*[1]]}
+r([1,2]){next [*[1,2]]}
 
 def r(val); *a = *yield(); test_ok(a == val, 2); end
-r([]){next *[[]]}
+r([[]]){next *[[]]}
 r([1,2]){next *[1,2]}
 r([1,2]){next *[*[1,2]]}
 
@@ -422,7 +417,7 @@ r([1,nil,[]]){next [*[1]]}
 r([1,2,[]]){next [*[1,2]]}
 
 def r(val); a,b,*c = *yield(); test_ok([a,b,c] == val, 2); end
-r([nil,nil,[]]){next *[[]]}
+r([[],nil,[]]){next *[[]]}
 r([1,2,[]]){next *[1,2]}
 r([1,2,[]]){next *[*[1,2]]}
 
@@ -963,22 +958,22 @@ IterTest.new([2]).each2 {|x| test_ok(x == [2])}
 #IterTest.new([3]).each3 {|x| test_ok(x == 3)}
 IterTest.new([4]).each4 {|x| test_ok(x == 4)}
 IterTest.new([5]).each5 {|x| test_ok(x == 5)}
-IterTest.new([6]).each6 {|x| test_ok(x == [6])}
+IterTest.new([6]).each6 {|x| test_ok(x == 6)}
 #IterTest.new([7]).each7 {|x| test_ok(x == 7)}
 IterTest.new([8]).each8 {|x| test_ok(x == 8)}
 
-IterTest.new([[0]]).each0 {|x| test_ok(x == [0])}
-IterTest.new([[1]]).each1 {|x| test_ok(x == [1])}
-IterTest.new([[2]]).each2 {|x| test_ok(x == [[2]])}
+IterTest.new([[0]]).each0 {|x| test_ok(x == 0)}
+IterTest.new([[1]]).each1 {|x| test_ok(x == 1)}
+IterTest.new([[2]]).each2 {|x| test_ok(x == [2])}
 IterTest.new([[3]]).each3 {|x| test_ok(x == 3)}
-IterTest.new([[4]]).each4 {|x| test_ok(x == [4])}
-IterTest.new([[5]]).each5 {|x| test_ok(x == [5])}
-IterTest.new([[6]]).each6 {|x| test_ok(x == [[6]])}
+IterTest.new([[4]]).each4 {|x| test_ok(x == 4)}
+IterTest.new([[5]]).each5 {|x| test_ok(x == 5)}
+IterTest.new([[6]]).each6 {|x| test_ok(x == 6)}
 IterTest.new([[7]]).each7 {|x| test_ok(x == 7)}
-IterTest.new([[8]]).each8 {|x| test_ok(x == [8])}
+IterTest.new([[8]]).each8 {|x| test_ok(x == 8)}
 
-IterTest.new([[0,0]]).each0 {|x| test_ok(x == [0,0])}
-IterTest.new([[8,8]]).each8 {|x| test_ok(x == [8,8])}
+IterTest.new([[0,0]]).each0 {|*x| test_ok(x == [0,0])}
+IterTest.new([[8,8]]).each8 {|*x| test_ok(x == [8])}
 
 def m0(v)
   v
@@ -1018,7 +1013,7 @@ end
 block_test(NilClass)
 block_test(Proc){}
 
-def argument_test(state, proc, *args)
+def call_argument_test(state, proc, *args)
   x = state
   begin
     proc.call(*args)
@@ -1028,27 +1023,43 @@ def argument_test(state, proc, *args)
   test_ok(x,2)
 end
 
-argument_test(true, lambda{||})
-argument_test(false, lambda{||}, 1)
-argument_test(true, lambda{|a,|}, 1)
-argument_test(false, lambda{|a,|})
-argument_test(false, lambda{|a,|}, 1,2)
+def yield_argument_test(state, proc, *args)
+  x = state
+  begin
+    proc.yield(*args)
+  rescue ArgumentError
+    x = !x
+  end
+  test_ok(x,2)
+end
+
+call_argument_test(true, lambda{||})
+call_argument_test(false, lambda{||}, 1)
+call_argument_test(true, lambda{|a,|}, 1)
+call_argument_test(false, lambda{|a,|})
+call_argument_test(false, lambda{|a,|}, 1,2)
+
+yield_argument_test(true, lambda{||})
+yield_argument_test(true, lambda{||}, 1)
+yield_argument_test(true, lambda{|a,|}, 1)
+yield_argument_test(true, lambda{|a,|})
+yield_argument_test(true, lambda{|a,|}, 1,2)
 
 def get_block(&block)
   block
 end
 
 test_ok(Proc == get_block{}.class)
-argument_test(true, get_block{||})
-argument_test(true, get_block{||}, 1)
-argument_test(true, get_block{|a,|}, 1)
-argument_test(true, get_block{|a,|})
-argument_test(true, get_block{|a,|}, 1,2)
+yield_argument_test(true, get_block{||})
+yield_argument_test(true, get_block{||}, 1)
+yield_argument_test(true, get_block{|a,|}, 1)
+yield_argument_test(true, get_block{|a,|})
+yield_argument_test(true, get_block{|a,|}, 1,2)
 
-argument_test(true, get_block(&lambda{||}))
-argument_test(false, get_block(&lambda{||}),1)
-argument_test(true, get_block(&lambda{|a,|}),1)
-argument_test(false, get_block(&lambda{|a,|}),1,2)
+call_argument_test(true, get_block(&lambda{||}))
+call_argument_test(false, get_block(&lambda{||}),1)
+call_argument_test(true, get_block(&lambda{|a,|}),1)
+call_argument_test(false, get_block(&lambda{|a,|}),1,2)
 
 blk = get_block{11}
 test_ok(blk.class == Proc)
@@ -1062,8 +1073,8 @@ test_ok(lmd.to_proc.class == Proc)
 test_ok(lmd.clone.call == 44)
 test_ok(get_block(&lmd).class == Proc)
 
-test_ok(Proc.new{|a,| a}.call(1,2,3) == 1)
-argument_test(true, Proc.new{|a,|}, 1,2)
+test_ok(Proc.new{|a,| a}.yield(1,2,3) == 1)
+yield_argument_test(true, Proc.new{|a,|}, 1,2)
 
 test_ok(Proc.new{|&b| b.call(10)}.call {|x| x} == 10)
 test_ok(Proc.new{|a,&b| b.call(a)}.call(12) {|x| x} == 12)
@@ -1071,7 +1082,7 @@ test_ok(Proc.new{|a,&b| b.call(a)}.call(12) {|x| x} == 12)
 def test_return1
   Proc.new {
     return 55
-  }.call + 5
+  }.yield + 5
 end
 test_ok(test_return1() == 55)
 def test_return2
@@ -1090,7 +1101,7 @@ end
 def proc_return1
   proc_call{return 42}+1
 end
-test_ok(proc_return1() == 42)
+test_ok(proc_return1() == 43)
 def proc_return2
   proc_yield{return 42}+1
 end
@@ -1106,7 +1117,7 @@ def ljump_test(state, proc, *args)
   test_ok(x,2)
 end
 
-ljump_test(false, get_block{break})
+ljump_test(true, get_block{break})
 ljump_test(true, lambda{break})
 
 def exit_value_test(&block)
@@ -1149,11 +1160,11 @@ def test_b2
     block_get{break 21}.call
   end
 end
-test_ok(test_b2() == 22)
+test_ok(test_b2() == 21)
 
 def test_b3
   ljump_rescue(33) do
-    Proc.new{break 31}.call
+    Proc.new{break 31}.yield
   end
 end
 test_ok(test_b3() == 33)
@@ -1169,7 +1180,7 @@ def test_b5
     block_call(&b)
   end
 end
-test_ok(test_b5() == 55)
+test_ok(test_b5() == 54)
 
 def test_b6
   b = lambda{break 67}
@@ -1188,7 +1199,7 @@ def test_b7
     block_call(&b)
   end
 end
-test_ok(test_b7() == 77)
+test_ok(test_b7() == 78)
 
 def util_b8(&block)
   block_call(&block)
@@ -1220,7 +1231,7 @@ test_ok(test_b10() == 100)
 def test_b11
   ljump_rescue(111) do
     loop do
-      Proc.new{break 110}.call
+      Proc.new{break 110}.yield
       break 112
     end
   end
@@ -1238,7 +1249,7 @@ test_ok(test_b12() == 122)
 def test_b13
   ljump_rescue(133) do
     while true
-      Proc.new{break 130}.call
+      Proc.new{break 130}.yield
       break 131
     end
   end
@@ -1260,7 +1271,7 @@ end
 test_ok(test_b15{|e| break 155 } == 155)
 
 def marity_test(m)
-  method = self.method(m)
+  method = method(m)
   test_ok(method.arity == method.to_proc.arity, 2)
 end
 marity_test(:test_ok)
@@ -1421,7 +1432,6 @@ $good = true;
 for i in 4000..4096
   n1 = 1 << i;
   if (n1**2-1) / (n1+1) != (n1-1)
-    p i
     $good = false
   end
 end
@@ -1525,9 +1535,9 @@ test_ok($x.sub(/.*\.([^\.]+)$/, '<\&>') == "<a.gif>")
 # character constants(assumes ASCII)
 test_ok("a"[0] == ?a)
 test_ok(?a == ?a)
-test_ok(?\C-a == 1)
-test_ok(?\M-a == 225)
-test_ok(?\M-\C-a == 129)
+test_ok(?\C-a == "\1")
+test_ok(?\M-a == "\341")
+test_ok(?\M-\C-a == "\201")
 test_ok("a".upcase![0] == ?A)
 test_ok("A".downcase![0] == ?a)
 test_ok("abc".tr!("a-z", "A-Z") == "ABC")
@@ -1539,7 +1549,7 @@ $x = "abcdef"
 $y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
 $bad = false
 $x.each_byte {|i|
-  if i != $y.shift
+  if i.chr != $y.shift
     $bad = true
     break
   end
@@ -1927,7 +1937,7 @@ module M003; include M002; end
 module M002; include M001; end
 module M003; include M002; end
 
-test_ok(M003.ancestors == [M003, M002, M001])
+test_ok(M003.ancestors == [M003, M002, M001, M002])
 
 test_check "marshal"
 $x = [1,2,3,[4,5,"foo"],{1=>"bar"},2.5,fact(30)]