PageRenderTime 33ms CodeModel.GetById 18ms RepoModel.GetById 1ms app.codeStats 0ms

/patches/ruby/2.2.2/railsexpress/04-backported-bugfixes-222.patch

http://github.com/skaes/rvm-patchsets
Patch | 2465 lines | 2356 code | 109 blank | 0 comment | 0 complexity | 637bfe8b0faca130e45ee084bb9f43d6 MD5 | raw file
    

  1. diff --git a/ChangeLog b/ChangeLog
    2. 

  2. index 909c092..ae878d3 100644
    3. 

  3. --- a/ChangeLog
    4. 

  4. +++ b/ChangeLog
    5. 

  5. @@ -1,3 +1,254 @@
    6. 

  6. +Fri Jun 12 01:39:49 2015  Eric Wong  <e@80x24.org>
    7. 

  7. +
    8. 

  8. +	* ext/socket/ancdata.c: use RB_GC_GUARD instead of volatile
    9. 

  9. +	  [ruby-core:69419] [Feature #11198]
    10. 

  10. +
    11. 

  11. +Fri Jun 12 01:16:13 2015  Eric Wong  <e@80x24.org>
    12. 

  12. +
    13. 

  13. +	* ext/openssl/ossl_asn1.c (ossl_asn1_traverse, ossl_asn1_decode,
    14. 

  14. +	  ossl_asn1_decode_all): use RB_GC_GUARD instead of volatile
    15. 

  15. +	  [ruby-core:69371] [Bug #11185]
    16. 

  16. +
    17. 

  17. +Fri Jun 12 01:14:00 2015  NARUSE, Yui  <naruse@ruby-lang.org>
    18. 

  18. +
    19. 

  19. +	* win32/win32.c (setup_overlapped): seek to the file end only when
    20. 

  20. +	  writing (mode:a), not reading (mode:a+, read).
    21. 

  21. +
    22. 

  22. +Fri Jun 12 01:11:52 2015  Aaron Patterson <tenderlove@ruby-lang.org>
    23. 

  23. +
    24. 

  24. +	* load.c (loaded_feature_path): stop returning false negatives for
    25. 

  25. +	  filenames which are trailing substrings of file extensions.  For
    26. 

  26. +	  example, 'b', which a trailing substring of ".rb" should not return
    27. 

  27. +	  false. [Bug #11155][ruby-core:69206]
    28. 

  28. +
    29. 

  29. +	* test/ruby/test_autoload.rb: test for fix
    30. 

  30. +
    31. 

  31. +Sun May 24 03:56:27 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    32. 

  32. +
    33. 

  33. +	* marshal.c (r_symreal): register symbol names as strings first so
    34. 

  34. +	  that r_symlink always returns valid names.
    35. 

  35. +	  [ruby-core:68587] [Bug #10991]
    36. 

  36. +
    37. 

  37. +	* marshal.c (r_ivar, r_object0): now need to intern symbol names.
    38. 

  38. +
    39. 

  39. +	* marshal.c (r_object0): compare with symbol names.
    40. 

  40. +
    41. 

  41. +Sun May 24 03:53:07 2015  Eric Wong  <e@80x24.org>
    42. 

  42. +
    43. 

  43. +	* ext/socket/ancdata.c (bsock_recvmsg_internal): GC guard
    44. 

  44. +	  [Bug #11123]
    45. 

  45. +
    46. 

  46. +Sun May 24 03:44:42 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    47. 

  47. +
    48. 

  48. +	* range.c (linear_object_p, range_include): test if covered for
    49. 

  49. +	  linear objects.  [ruby-core:69052] [Bug #11113]
    50. 

  50. +
    51. 

  51. +Sun May 24 03:41:45 2015  Shugo Maeda  <shugo@ruby-lang.org>
    52. 

  52. +
    53. 

  53. +	* lib/net/imap.rb (body_ext_mpart): should work even if body-fld-dsp
    54. 

  54. +	  is omitted.  [ruby-core:69093] [Bug #11128]
    55. 

  55. +
    56. 

  56. +Sun May 24 03:37:14 2015  SHIBATA Hiroshi  <hsbt@ruby-lang.org>
    57. 

  57. +
    58. 

  58. +	* string.c: added documentation for character sequence \' with String#sub
    59. 

  59. +	  [Bug #11132][ruby-core:69121][fix GH-900][ci skip] Patch by @shishir127
    60. 

  60. +
    61. 

  61. +Sun May 24 03:32:53 2015  SHIBATA Hiroshi  <hsbt@ruby-lang.org>
    62. 

  62. +
    63. 

  63. +	* rational.c: Added documentation for rational literal.
    64. 

  64. +	  [Bug #11075][fix GH-885][ci skip] Patch by @shishir127
    65. 

  65. +
    66. 

  66. +Sun May 24 03:06:20 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    67. 

  67. +
    68. 

  68. +	* ext/socket/ipsocket.c (init_inetsock_internal): preserve errno
    69. 

  69. +	  before other library calls and use rb_syserr_fail.
    70. 

  70. +	  [ruby-core:68531] [Bug #10975]
    71. 

  71. +
    72. 

  72. +Sun May 24 03:01:17 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    73. 

  73. +
    74. 

  74. +	* ext/-test-/printf/printf.c (uint_to_str): renamed to get rid of
    75. 

  75. +	  conflict on cygwin.  [ruby-core:68877] [Bug #11065]
    76. 

  76. +
    77. 

  77. +Sun May 24 02:44:53 2015  Koichi Sasada  <ko1@atdot.net>
    78. 

  78. +
    79. 

  79. +	* vm.c (vm_exec): check other events when RETURN is thrown.
    80. 

  80. +	  [Bug #10724]
    81. 

  81. +
    82. 

  82. +	* test/ruby/test_settracefunc.rb: add a test.
    83. 

  83. +
    84. 

  84. +Sun May 24 02:21:47 2015  Masahiro Tomita  <tommy@tmtm.org>
    85. 

  85. +
    86. 

  86. +	* ext/socket/raddrinfo.c (addrinfo_mload): fix memory leak of
    87. 

  87. +	  addrinfo.  [ruby-dev:48923] [Bug #11051]
    88. 

  88. +
    89. 

  89. +Sun May 24 02:17:05 2015  Kenta Murata  <mrkn@cookpad.com>
    90. 

  90. +
    91. 

  91. +	* bigdecimal: conform to ruby's license.  [ruby-core:68466] [Bug #10952]
    92. 

  92. +
    93. 

  93. +Sun May 24 02:06:34 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    94. 

  94. +
    95. 

  95. +	* ext/-test-/file/fs.c (get_fsname): try magic number only if
    96. 

  96. +	  f_type is included.  [ruby-dev:48913] [Bug #11000]
    97. 

  97. +
    98. 

  98. +Sun May 24 02:06:34 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    99. 

  99. +
    100. 

  100. +	* ext/-test-/file/fs.c (get_fsname): return filesystem name by
    101. 

  101. +	  statfs/statvfs.  [ruby-core:68624] [Bug #10998]
    102. 

  102. +
    103. 

  103. +Sun May 24 02:02:00 2015  Koichi Sasada  <ko1@atdot.net>
    104. 

  104. +
    105. 

  105. +	* test/ruby/test_symbol.rb: fix syntax error.
    106. 

  106. +
    107. 

  107. +Sun May 24 02:02:00 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    108. 

  108. +
    109. 

  109. +	* hash.c (rb_any_hash): Symbols are compared by the identities
    110. 

  110. +	  always.  [ruby-core:68767] [Bug #11035]
    111. 

  111. +
    112. 

  112. +Sun May 24 02:01:07 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    113. 

  113. +
    114. 

  114. +	* hash.c (rb_any_hash): use same hash values with Float#hash so
    115. 

  115. +	  that -0.0 and +0.0 will be identical.
    116. 

  116. +	  [ruby-core:68541] [Bug #10979]
    117. 

  117. +
    118. 

  118. +Thu May 21 01:34:48 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    119. 

  119. +
    120. 

  120. +	* gc.c (id2ref): prohibit from accessing internal objects.
    121. 

  121. +	  [ruby-core:68348] [Bug #10918]
    122. 

  122. +
    123. 

  123. +Thu May 21 01:32:02 2015  Rei Odaira  <Rei.Odaira@gmail.com>
    124. 

  124. +
    125. 

  125. +	* ext/pty/pty.c: AIX supports autopush.
    126. 

  126. +	  Patch by Perry Smith [ruby-core:58539] [Bug #9144]
    127. 

  127. +
    128. 

  128. +Thu May 21 01:07:41 2015  Misumi Rize  <r@ayase-e.li>
    129. 

  129. +
    130. 

  130. +	* vm_insnhelper.c (vm_throw_start): search the target to break
    131. 

  131. +	  from a block with nested rescue, from the nested blocks.
    132. 

  132. +	  [ruby-core:67765] [Bug #10775] [Fix GH-820]
    133. 

  133. +
    134. 

  134. +Thu May 21 00:55:45 2015  Koichi Sasada  <ko1@atdot.net>
    135. 

  135. +
    136. 

  136. +	* vm_args.c: protect value stack from calling other methods
    137. 

  137. +	  during complex parameter setting process (splat, kw, and so on).
    138. 

  138. +	  [Bug #11027]
    139. 

  139. +
    140. 

  140. +	* vm_core.h: remove rb_thead_t::mark_stack_len.
    141. 

  141. +	  With this modification, we don't need to use th->mark_stack_len.
    142. 

  142. +
    143. 

  143. +	* test/ruby/test_keyword.rb: add a test.
    144. 

  144. +
    145. 

  145. +	* cont.c (cont_capture): catch up this fix.
    146. 

  146. +
    147. 

  147. +	* vm.c (rb_thread_mark): ditto.
    148. 

  148. +
    149. 

  149. +Thu May 21 00:07:54 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    150. 

  150. +
    151. 

  151. +	* vm_eval.c (rb_obj_instance_eval, rb_obj_instance_exec): allow
    152. 

  152. +	  symbols to just instance_eval/exec, except for definition of
    153. 

  153. +	  singletons.  [ruby-core:68961] [Bug #11086]
    154. 

  154. +
    155. 

  155. +Wed May 20 04:33:50 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    156. 

  156. +
    157. 

  157. +	* string.c (STR_SET_EMBED): clear NOFREE flag at embedding as
    158. 

  158. +	  embedded strings no longer refer static strings.
    159. 

  159. +	  [ruby-core:68436] [Bug #10942]
    160. 

  160. +
    161. 

  161. +Wed May 20 03:46:11 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    162. 

  162. +
    163. 

  163. +	* dir.c (need_normalization): use getattrlist() if fgetattrlist()
    164. 

  164. +	  is unavailable, on OSX 10.5.  [ruby-core:68829] [Bug #11054]
    165. 

  165. +
    166. 

  166. +Wed May 20 03:25:34 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    167. 

  167. +
    168. 

  168. +	* proc.c (proc_binding): replicate env from method object, and
    169. 

  169. +	  allocate the local variable area for the iseq local table.
    170. 

  170. +	  [ruby-core:68673] [Bug #11012]
    171. 

  171. +
    172. 

  172. +Wed May 20 03:25:34 2015  Koichi Sasada  <ko1@atdot.net>
    173. 

  173. +
    174. 

  174. +	* proc.c: use RUBY_VM_IFUNC_P() to recognize IFUNC or not.
    175. 

  175. +
    176. 

  176. +	* vm.c: ditto.
    177. 

  177. +
    178. 

  178. +	* vm_dump.c: ditto.
    179. 

  179. +
    180. 

  180. +	* vm_insnhelper.c: ditto.
    181. 

  181. +
    182. 

  182. +	* vm_core.h: use RB_TYPE_P() instead of BUILTIN_TYPE().
    183. 

  183. +
    184. 

  184. +Wed May 20 03:10:49 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    185. 

  185. +
    186. 

  186. +	* benchmark/bm_hash_aref_flo.rb: make more realistic data.
    187. 

  187. +	  [ruby-core:68632] [[Bug #10999]
    188. 

  188. +
    189. 

  189. +Wed May 20 02:49:49 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    190. 

  190. +
    191. 

  191. +	* proc.c (respond_to_missing_p): check if the receiver responds to
    192. 

  192. +	  the given method by respond_to_missing?.
    193. 

  193. +
    194. 

  194. +	* proc.c (mnew_missing): create Method object for method_missing.
    195. 

  195. +	  [ruby-core:68564] [Bug #10985]
    196. 

  196. +
    197. 

  197. +Wed May 20 02:16:05 2015  NAKAMURA Usaku  <usa@ruby-lang.org>
    198. 

  198. +
    199. 

  199. +	* dir.c (replace_real_basename): need to check the return value of
    200. 

  200. +	  GLOB_REALLOC().
    201. 

  201. +
    202. 

  202. +Wed May 20 02:16:05 2015  NAKAMURA Usaku  <usa@ruby-lang.org>
    203. 

  203. +
    204. 

  204. +	* dir.c (replace_real_basename): shouldn't create Ruby object before
    205. 

  205. +	  the object system is loaded.
    206. 

  206. +	  [ruby-core:68430] [Bug #10941]
    207. 

  207. +
    208. 

  208. +Wed May 20 01:58:12 2015  Tanaka Akira  <akr@fsij.org>
    209. 

  209. +
    210. 

  210. +	* lib/resolv.rb (Resolv::DNS::Label::Str#==): Check class equality.
    211. 

  211. +	  (Resolv::DNS::Name#initialize): Normalize labels as
    212. 

  212. +	  Resolv::DNS::Label::Str objects.
    213. 

  213. +
    214. 

  214. +Wed May 20 01:47:23 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    215. 

  215. +
    216. 

  216. +	* iseq.c (rb_iseq_compile_with_option): check source type, must be
    217. 

  217. +	  an IO or a String.  [ruby-core:69219] [Bug #11159]
    218. 

  218. +
    219. 

  219. +Fri May 15 05:01:25 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    220. 

  220. +
    221. 

  221. +	* symbol.c (Init_sym): make dsym_fstrs a hash compared by identity
    222. 

  222. +	  as the keys are unique fstrings, to get rid of running hash and
    223. 

  223. +	  compare methods and causing new object allocation during garbage
    224. 

  224. +	  collection phase.  [ruby-dev:48891] [Bug #10933]
    225. 

  225. +
    226. 

  226. +Thu May 14 00:50:40 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    227. 

  227. +
    228. 

  228. +	* parse.y (lambda): push and reset cmdarg_stack in lambda body.
    229. 

  229. +	  [ruby-core:69017] [Bug #11107]
    230. 

  230. +
    231. 

  231. +Thu May 14 00:39:29 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    232. 

  232. +
    233. 

  233. +	* dln.c (dln_load): check if a different libruby is loaded by the
    234. 

  234. +	  extension library, and then bail out to get rid of very frequent
    235. 

  235. +	  reported stale bug reports.
    236. 

  236. +
    237. 

  237. +Thu May 14 00:29:44 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    238. 

  238. +
    239. 

  239. +	* lib/fileutils.rb (FileUtils#mv): show the exact target path in
    240. 

  240. +	  the error message instead of the destination parent directory
    241. 

  241. +	  name.  patched by Joao Britto <jabcalves AT gmail.com> at
    242. 

  242. +	  [ruby-core:68706].  [Bug #11021]
    243. 

  243. +
    244. 

  244. +Thu May 14 00:19:04 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    245. 

  245. +
    246. 

  246. +	* thread_pthread.c (reserve_stack): keep sp safe zone to get rid
    247. 

  247. +	  of crash by -fstack-check.  [ruby-core:68740] [Bug #11030]
    248. 

  248. +
    249. 

  249. +Tue Apr 14 23:33:39 2015  Nobuyoshi Nakada  <nobu@ruby-lang.org>
    250. 

  250. +
    251. 

  251. +	* configure.in: check also procstat_getvmmap, which is not
    252. 

  252. +	  available on FreeBSD 9.  [ruby-core:68468] [Bug #10954]
    253. 

  253. +
    254. 

  254. +	* vm_dump.c (procstat_vm): use kinfo_getvmmap instead if
    255. 

  255. +	  procstat_getvmmap is not available.
    256. 

  256. +
    257. 

  257.  Mon Apr 13 22:11:21 2015  CHIKANAGA Tomoyuki  <nagachika@ruby-lang.org>
    258. 

  258.  
    259. 

  259.  	* ext/openssl/lib/openssl/ssl.rb: stricter hostname verification
    260. 

  260. diff --git a/benchmark/bm_hash_aref_flo.rb b/benchmark/bm_hash_aref_flo.rb
    261. 

  261. index a097bb5..2217274 100644
    262. 

  262. --- a/benchmark/bm_hash_aref_flo.rb
    263. 

  263. +++ b/benchmark/bm_hash_aref_flo.rb
    264. 

  264. @@ -1,4 +1,4 @@
    265. 

  265.  h = {}
    266. 

  266. -strs = (1..10000).to_a.map!(&:to_f)
    267. 

  267. +strs = [*1..10000].map! {|i| i.fdiv(10)}
    268. 

  268.  strs.each { |s| h[s] = s }
    269. 

  269.  50.times { strs.each { |s| h[s] } }
    270. 

  270. diff --git a/bootstraptest/test_block.rb b/bootstraptest/test_block.rb
    271. 

  271. index 6a2ccfc..cdc5960 100644
    272. 

  272. --- a/bootstraptest/test_block.rb
    273. 

  273. +++ b/bootstraptest/test_block.rb
    274. 

  274. @@ -597,3 +597,17 @@ assert_equal 'true', %q{
    275. 

  275.    C1.new.foo{}
    276. 

  276.  }
    277. 

  277.  
    278. 

  278. +assert_equal 'ok', %q{
    279. 

  279. +  1.times do
    280. 

  280. +    begin
    281. 

  281. +      raise
    282. 

  282. +    rescue
    283. 

  283. +      begin
    284. 

  284. +        raise
    285. 

  285. +      rescue
    286. 

  286. +        break
    287. 

  287. +      end
    288. 

  288. +    end
    289. 

  289. +  end
    290. 

  290. +  'ok'
    291. 

  291. +}
    292. 

  292. diff --git a/class.c b/class.c
    293. 

  293. index 65d0d30..f142f44 100644
    294. 

  294. --- a/class.c
    295. 

  295. +++ b/class.c
    296. 

  296. @@ -1531,7 +1531,8 @@ singleton_class_of(VALUE obj)
    297. 

  297.  {
    298. 

  298.      VALUE klass;
    299. 

  299.  
    300. 

  300. -    if (FIXNUM_P(obj) || FLONUM_P(obj) || SYMBOL_P(obj)) {
    301. 

  301. +    if (FIXNUM_P(obj) || FLONUM_P(obj) || STATIC_SYM_P(obj)) {
    302. 

  302. +      no_singleton:
    303. 

  303.  	rb_raise(rb_eTypeError, "can't define singleton");
    304. 

  304.      }
    305. 

  305.      if (SPECIAL_CONST_P(obj)) {
    306. 

  306. @@ -1541,9 +1542,9 @@ singleton_class_of(VALUE obj)
    307. 

  307.  	return klass;
    308. 

  308.      }
    309. 

  309.      else {
    310. 

  310. -	enum ruby_value_type type = BUILTIN_TYPE(obj);
    311. 

  311. -	if (type == T_FLOAT || type == T_BIGNUM) {
    312. 

  312. -	    rb_raise(rb_eTypeError, "can't define singleton");
    313. 

  313. +	switch (BUILTIN_TYPE(obj)) {
    314. 

  314. +	  case T_FLOAT: case T_BIGNUM: case T_SYMBOL:
    315. 

  315. +	    goto no_singleton;
    316. 

  316.  	}
    317. 

  317.      }
    318. 

  318.  
    319. 

  319. diff --git a/configure.in b/configure.in
    320. 

  320. index 8297c5a..7330df4 100644
    321. 

  321. --- a/configure.in
    322. 

  322. +++ b/configure.in
    323. 

  323. @@ -2036,6 +2036,7 @@ AC_CHECK_FUNCS(fchmod)
    324. 

  324.  AC_CHECK_FUNCS(fchown)
    325. 

  325.  AC_CHECK_FUNCS(fcntl)
    326. 

  326.  AC_CHECK_FUNCS(fdatasync)
    327. 

  327. +AC_CHECK_FUNCS(fgetattrlist)
    328. 

  328.  AC_CHECK_FUNCS(fmod)
    329. 

  329.  AC_CHECK_FUNCS(fsync)
    330. 

  330.  AC_CHECK_FUNCS(ftruncate)
    331. 

  331. @@ -3085,6 +3086,9 @@ fi
    332. 

  332.  AS_CASE(["$target_os"],
    333. 

  333.  [freebsd*], [
    334. 

  334.      AC_CHECK_LIB([procstat], [procstat_open_sysctl])
    335. 

  335. +    if test "x$ac_cv_lib_procstat_procstat_open_sysctl" = xyes; then
    336. 

  336. +	AC_CHECK_FUNCS(procstat_getvmmap)
    337. 

  337. +    fi
    338. 

  338.      ])
    339. 

  339.  AS_CASE(["$target_cpu-$target_os"],
    340. 

  340.  [*-darwin*], [
    341. 

  341. diff --git a/cont.c b/cont.c
    342. 

  342. index 78ae089..22e0c5a 100644
    343. 

  343. --- a/cont.c
    344. 

  344. +++ b/cont.c
    345. 

  345. @@ -490,7 +490,7 @@ cont_capture(volatile int *stat)
    346. 

  346.      contval = cont->self;
    347. 

  347.  
    348. 

  348.  #ifdef CAPTURE_JUST_VALID_VM_STACK
    349. 

  349. -    cont->vm_stack_slen = th->cfp->sp + th->mark_stack_len - th->stack;
    350. 

  350. +    cont->vm_stack_slen = th->cfp->sp - th->stack;
    351. 

  351.      cont->vm_stack_clen = th->stack + th->stack_size - (VALUE*)th->cfp;
    352. 

  352.      cont->vm_stack = ALLOC_N(VALUE, cont->vm_stack_slen + cont->vm_stack_clen);
    353. 

  353.      MEMCPY(cont->vm_stack, th->stack, VALUE, cont->vm_stack_slen);
    354. 

  354. diff --git a/dir.c b/dir.c
    355. 

  355. index 0903ec8..84413c6 100644
    356. 

  356. --- a/dir.c
    357. 

  357. +++ b/dir.c
    358. 

  358. @@ -103,13 +103,23 @@ char *strchr(char*,char);
    359. 

  359.  #include <sys/mount.h>
    360. 

  360.  #include <sys/vnode.h>
    361. 

  361.  
    362. 

  362. +# if defined HAVE_FGETATTRLIST || !defined HAVE_GETATTRLIST
    363. 

  363. +#   define need_normalization(dirp, path) need_normalization(dirp)
    364. 

  364. +# else
    365. 

  365. +#   define need_normalization(dirp, path) need_normalization(path)
    366. 

  366. +# endif
    367. 

  367.  static inline int
    368. 

  368. -need_normalization(DIR *dirp)
    369. 

  369. +need_normalization(DIR *dirp, const char *path)
    370. 

  370.  {
    371. 

  371. -# ifdef HAVE_GETATTRLIST
    372. 

  372. +# if defined HAVE_FGETATTRLIST || defined HAVE_GETATTRLIST
    373. 

  373.      u_int32_t attrbuf[SIZEUP32(fsobj_tag_t)];
    374. 

  374.      struct attrlist al = {ATTR_BIT_MAP_COUNT, 0, ATTR_CMN_OBJTAG,};
    375. 

  375. -    if (!fgetattrlist(dirfd(dirp), &al, attrbuf, sizeof(attrbuf), 0)) {
    376. 

  376. +#   if defined HAVE_FGETATTRLIST
    377. 

  377. +    int ret = fgetattrlist(dirfd(dirp), &al, attrbuf, sizeof(attrbuf), 0);
    378. 

  378. +#   else
    379. 

  379. +    int ret = getattrlist(path, &al, attrbuf, sizeof(attrbuf), 0);
    380. 

  380. +#   endif
    381. 

  381. +    if (!ret) {
    382. 

  382.  	const fsobj_tag_t *tag = (void *)(attrbuf+1);
    383. 

  383.  	switch (*tag) {
    384. 

  384.  	  case VT_HFS:
    385. 

  385. @@ -694,7 +704,7 @@ dir_each(VALUE dir)
    386. 

  386.      RETURN_ENUMERATOR(dir, 0, 0);
    387. 

  387.      GetDIR(dir, dirp);
    388. 

  388.      rewinddir(dirp->dir);
    389. 

  389. -    IF_NORMALIZE_UTF8PATH(norm_p = need_normalization(dirp->dir));
    390. 

  390. +    IF_NORMALIZE_UTF8PATH(norm_p = need_normalization(dirp->dir, RSTRING_PTR(dirp->path)));
    391. 

  391.      while ((dp = READDIR(dirp->dir, dirp->enc)) != NULL) {
    392. 

  392.  	const char *name = dp->d_name;
    393. 

  393.  	size_t namlen = NAMLEN(dp);
    394. 

  394. @@ -1481,12 +1491,34 @@ replace_real_basename(char *path, long base, rb_encoding *enc, int norm_p)
    395. 

  395.      free(wplain);
    396. 

  396.      if (h == INVALID_HANDLE_VALUE) return path;
    397. 

  397.      FindClose(h);
    398. 

  398. -    tmp = rb_w32_conv_from_wchar(fd.cFileName, enc);
    399. 

  399. -    wlen = RSTRING_LEN(tmp);
    400. 

  400. -    path = GLOB_REALLOC(path, base + wlen + 1);
    401. 

  401. -    memcpy(path + base, RSTRING_PTR(tmp), wlen);
    402. 

  402. -    path[base + wlen] = 0;
    403. 

  403. -    rb_str_resize(tmp, 0);
    404. 

  404. +    if (tmp) {
    405. 

  405. +	char *buf;
    406. 

  406. +	tmp = rb_w32_conv_from_wchar(fd.cFileName, enc);
    407. 

  407. +	wlen = RSTRING_LEN(tmp);
    408. 

  408. +	buf = GLOB_REALLOC(path, base + wlen + 1);
    409. 

  409. +	if (buf) {
    410. 

  410. +	    path = buf;
    411. 

  411. +	    memcpy(path + base, RSTRING_PTR(tmp), wlen);
    412. 

  412. +	    path[base + wlen] = 0;
    413. 

  413. +	}
    414. 

  414. +	rb_str_resize(tmp, 0);
    415. 

  415. +    }
    416. 

  416. +    else {
    417. 

  417. +	char *utf8filename;
    418. 

  418. +	wlen = WideCharToMultiByte(CP_UTF8, 0, fd.cFileName, -1, NULL, 0, NULL, NULL);
    419. 

  419. +	utf8filename = GLOB_REALLOC(0, wlen);
    420. 

  420. +	if (utf8filename) {
    421. 

  421. +	    char *buf;
    422. 

  422. +	    WideCharToMultiByte(CP_UTF8, 0, fd.cFileName, -1, utf8filename, wlen, NULL, NULL);
    423. 

  423. +	    buf = GLOB_REALLOC(path, base + wlen + 1);
    424. 

  424. +	    if (buf) {
    425. 

  425. +		path = buf;
    426. 

  426. +		memcpy(path + base, utf8filename, wlen);
    427. 

  427. +		path[base + wlen] = 0;
    428. 

  428. +	    }
    429. 

  429. +	    GLOB_FREE(utf8filename);
    430. 

  430. +	}
    431. 

  431. +    }
    432. 

  432.      return path;
    433. 

  433.  }
    434. 

  434.  #elif USE_NAME_ON_FS == 1
    435. 

  435. @@ -1639,7 +1671,7 @@ glob_helper(
    436. 

  436.  # endif
    437. 

  437.  	    return 0;
    438. 

  438.  	}
    439. 

  439. -	IF_NORMALIZE_UTF8PATH(norm_p = need_normalization(dirp));
    440. 

  440. +	IF_NORMALIZE_UTF8PATH(norm_p = need_normalization(dirp, *path ? path : "."));
    441. 

  441.  
    442. 

  442.  # if NORMALIZE_UTF8PATH
    443. 

  443.  	if (!(norm_p || magical || recursive)) {
    444. 

  444. diff --git a/dln.c b/dln.c
    445. 

  445. index 355cec1..e5269ca 100644
    446. 

  446. --- a/dln.c
    447. 

  447. +++ b/dln.c
    448. 

  448. @@ -106,13 +106,12 @@ dln_loaderror(const char *format, ...)
    449. 

  449.  # define USE_DLN_DLOPEN
    450. 

  450.  #endif
    451. 

  451.  
    452. 

  452. -#ifndef FUNCNAME_PATTERN
    453. 

  453. -# if defined(__hp9000s300) || ((defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(__ELF__)) || defined(__BORLANDC__) || defined(NeXT) || defined(__WATCOMC__) || defined(MACOSX_DYLD)
    454. 

  454. -#  define FUNCNAME_PREFIX "_Init_"
    455. 

  455. -# else
    456. 

  456. -#  define FUNCNAME_PREFIX "Init_"
    457. 

  457. -# endif
    458. 

  458. +#if defined(__hp9000s300) || ((defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(__ELF__)) || defined(__BORLANDC__) || defined(NeXT) || defined(__WATCOMC__) || defined(MACOSX_DYLD)
    459. 

  459. +# define EXTERNAL_PREFIX "_"
    460. 

  460. +#else
    461. 

  461. +# define EXTERNAL_PREFIX ""
    462. 

  462.  #endif
    463. 

  463. +#define FUNCNAME_PREFIX EXTERNAL_PREFIX"Init_"
    464. 

  464.  
    465. 

  465.  #if defined __CYGWIN__ || defined DOSISH
    466. 

  466.  #define isdirsep(x) ((x) == '/' || (x) == '\\')
    467. 

  467. @@ -1330,6 +1329,23 @@ dln_load(const char *file)
    468. 

  468.  	    error = dln_strerror();
    469. 

  469.  	    goto failed;
    470. 

  470.  	}
    471. 

  471. +# if defined RUBY_EXPORT
    472. 

  472. +	{
    473. 

  473. +	    static const char incompatible[] = "incompatible library version";
    474. 

  474. +	    void *ex = dlsym(handle, EXTERNAL_PREFIX"ruby_xmalloc");
    475. 

  475. +	    if (ex && ex != ruby_xmalloc) {
    476. 

  476. +
    477. 

  477. +#   if defined __APPLE__
    478. 

  478. +		/* dlclose() segfaults */
    479. 

  479. +		rb_fatal("%s - %s", incompatible, file);
    480. 

  480. +#   else
    481. 

  481. +		dlclose(handle);
    482. 

  482. +		error = incompatible;
    483. 

  483. +		goto failed;
    484. 

  484. +#   endif
    485. 

  485. +	    }
    486. 

  486. +	}
    487. 

  487. +# endif
    488. 

  488.  
    489. 

  489.  	init_fct = (void(*)())(VALUE)dlsym(handle, buf);
    490. 

  490.  	if (init_fct == NULL) {
    491. 

  491. diff --git a/ext/-test-/file/extconf.rb b/ext/-test-/file/extconf.rb
    492. 

  492. index 4e134dd..be4a2fb 100644
    493. 

  493. --- a/ext/-test-/file/extconf.rb
    494. 

  494. +++ b/ext/-test-/file/extconf.rb
    495. 

  495. @@ -1,4 +1,18 @@
    496. 

  496.  $INCFLAGS << " -I$(topdir) -I$(top_srcdir)"
    497. 

  497. +
    498. 

  498. +headers = %w[sys/param.h sys/mount.h sys/vfs.h].select {|h| have_header(h)}
    499. 

  499. +if have_type("struct statfs", headers)
    500. 

  500. +  have_struct_member("struct statfs", "f_fstypename", headers)
    501. 

  501. +  have_struct_member("struct statfs", "f_type", headers)
    502. 

  502. +end
    503. 

  503. +
    504. 

  504. +headers = %w[sys/statvfs.h]
    505. 

  505. +if have_type("struct statvfs", headers)
    506. 

  506. +  have_struct_member("struct statvfs", "f_fstypename", headers)
    507. 

  507. +  have_struct_member("struct statvfs", "f_basetype", headers)
    508. 

  508. +  have_struct_member("struct statvfs", "f_type", headers)
    509. 

  509. +end
    510. 

  510. +
    511. 

  511.  $srcs = Dir[File.join($srcdir, "*.{#{SRC_EXT.join(%q{,})}}")]
    512. 

  512.  inits = $srcs.map {|s| File.basename(s, ".*")}
    513. 

  513.  inits.delete("init")
    514. 

  514. diff --git a/ext/-test-/file/fs.c b/ext/-test-/file/fs.c
    515. 

  515. index 4a41bf3..1ab067e 100644
    516. 

  516. --- a/ext/-test-/file/fs.c
    517. 

  517. +++ b/ext/-test-/file/fs.c
    518. 

  518. @@ -1,55 +1,69 @@
    519. 

  519.  #include "ruby/ruby.h"
    520. 

  520.  #include "ruby/io.h"
    521. 

  521.  
    522. 

  522. -#ifdef __linux__
    523. 

  523. -# define HAVE_GETMNTENT
    524. 

  524. +#ifdef HAVE_SYS_MOUNT_H
    525. 

  525. +#include <sys/mount.h>
    526. 

  526. +#endif
    527. 

  527. +#ifdef HAVE_SYS_VFS_H
    528. 

  528. +#include <sys/vfs.h>
    529. 

  529.  #endif
    530. 

  530.  
    531. 

  531. -#ifdef HAVE_GETMNTENT
    532. 

  532. -# include <stdio.h>
    533. 

  533. -# include <mntent.h>
    534. 

  534. +#if defined HAVE_STRUCT_STATFS_F_FSTYPENAME
    535. 

  535. +typedef struct statfs statfs_t;
    536. 

  536. +# define STATFS(f, s) statfs((f), (s))
    537. 

  537. +# define HAVE_STRUCT_STATFS_T_F_FSTYPENAME 1
    538. 

  538. +# if defined HAVE_STRUCT_STATFS_F_TYPE
    539. 

  539. +#   define HAVE_STRUCT_STATFS_T_F_TYPE 1
    540. 

  540. +# endif
    541. 

  541. +#elif defined(HAVE_STRUCT_STATVFS_F_FSTYPENAME) /* NetBSD */
    542. 

  542. +typedef struct statvfs statfs_t;
    543. 

  543. +# define STATFS(f, s) statvfs((f), (s))
    544. 

  544. +# define HAVE_STRUCT_STATFS_T_F_FSTYPENAME 1
    545. 

  545. +# if defined HAVE_STRUCT_STATVFS_F_TYPE
    546. 

  546. +#   define HAVE_STRUCT_STATFS_T_F_TYPE 1
    547. 

  547. +# endif
    548. 

  548. +#elif defined(HAVE_STRUCT_STATVFS_F_BASETYPE) /* AIX, HP-UX, Solaris */
    549. 

  549. +typedef struct statvfs statfs_t;
    550. 

  550. +# define STATFS(f, s) statvfs((f), (s))
    551. 

  551. +# define HAVE_STRUCT_STATFS_T_F_FSTYPENAME 1
    552. 

  552. +# define f_fstypename f_basetype
    553. 

  553. +# if defined HAVE_STRUCT_STATVFS_F_TYPE
    554. 

  554. +#   define HAVE_STRUCT_STATFS_T_F_TYPE 1
    555. 

  555. +# endif
    556. 

  556.  #endif
    557. 

  557.  
    558. 

  558.  VALUE
    559. 

  559.  get_fsname(VALUE self, VALUE str)
    560. 

  560.  {
    561. 

  561. -#ifdef HAVE_GETMNTENT
    562. 

  562. -    const char *path;
    563. 

  563. -    struct mntent mntbuf;
    564. 

  564. -    static const int buflen = 4096;
    565. 

  565. -    char *buf = alloca(buflen);
    566. 

  566. -    int len = 0;
    567. 

  567. -    FILE *fp;
    568. 

  568. -#define FSNAME_LEN 100
    569. 

  569. -    char name[FSNAME_LEN] = "";
    570. 

  570. +#ifdef STATFS
    571. 

  571. +    statfs_t st;
    572. 

  572. +# define CSTR(s) rb_str_new_cstr(s)
    573. 

  573.  
    574. 

  574.      FilePathValue(str);
    575. 

  575. -    path = RSTRING_PTR(str);
    576. 

  576. -    fp = setmntent("/etc/mtab", "r");
    577. 

  577. -    if (!fp) rb_sys_fail("setmntent(/etb/mtab)");;
    578. 

  578. -
    579. 

  579. -    while (getmntent_r(fp, &mntbuf, buf, buflen)) {
    580. 

  580. -	int i;
    581. 

  581. -	char *mnt_dir = mntbuf.mnt_dir;
    582. 

  582. -	for (i=0; mnt_dir[i]; i++) {
    583. 

  583. -	    if (mnt_dir[i] != path[i]) {
    584. 

  584. -		goto next_entry;
    585. 

  585. -	    }
    586. 

  586. -	}
    587. 

  587. -	if (i >= len) {
    588. 

  588. -	    len = i;
    589. 

  589. -	    strlcpy(name, mntbuf.mnt_type, FSNAME_LEN);
    590. 

  590. -	}
    591. 

  591. -next_entry:
    592. 

  592. -	;
    593. 

  593. +    str = rb_str_encode_ospath(str);
    594. 

  594. +    if (STATFS(StringValueCStr(str), &st) == -1) {
    595. 

  595. +	rb_sys_fail_str(str);
    596. 

  596.      }
    597. 

  597. -    endmntent(fp);
    598. 

  598. -
    599. 

  599. -    if (!len) rb_sys_fail("no matching entry");;
    600. 

  600. -    return rb_str_new_cstr(name);
    601. 

  601. -#else
    602. 

  602. -    return Qnil;
    603. 

  603. +# ifdef HAVE_STRUCT_STATFS_T_F_FSTYPENAME
    604. 

  604. +    if (st.f_fstypename[0])
    605. 

  605. +	return CSTR(st.f_fstypename);
    606. 

  606. +# endif
    607. 

  607. +# ifdef HAVE_STRUCT_STATFS_T_F_TYPE
    608. 

  608. +    switch (st.f_type) {
    609. 

  609. +      case 0x9123683E: /* BTRFS_SUPER_MAGIC */
    610. 

  610. +	return CSTR("btrfs");
    611. 

  611. +      case 0x7461636f: /* OCFS2_SUPER_MAGIC */
    612. 

  612. +	return CSTR("ocfs");
    613. 

  613. +      case 0xEF53: /* EXT2_SUPER_MAGIC EXT3_SUPER_MAGIC EXT4_SUPER_MAGIC */
    614. 

  614. +	return CSTR("ext4");
    615. 

  615. +      case 0x58465342: /* XFS_SUPER_MAGIC */
    616. 

  616. +	return CSTR("xfs");
    617. 

  617. +      case 0x01021994: /* TMPFS_MAGIC */
    618. 

  618. +	return CSTR("tmpfs");
    619. 

  619. +    }
    620. 

  620. +# endif
    621. 

  621.  #endif
    622. 

  622. +    return Qnil;
    623. 

  623.  }
    624. 

  624.  
    625. 

  625.  void
    626. 

  626. diff --git a/ext/-test-/printf/printf.c b/ext/-test-/printf/printf.c
    627. 

  627. index ef7570f..666f559 100644
    628. 

  628. --- a/ext/-test-/printf/printf.c
    629. 

  629. +++ b/ext/-test-/printf/printf.c
    630. 

  630. @@ -20,7 +20,7 @@ printf_test_q(VALUE self, VALUE obj)
    631. 

  631.  }
    632. 

  632.  
    633. 

  633.  static char *
    634. 

  634. -utoa(char *p, char *e, unsigned int x)
    635. 

  635. +uint_to_str(char *p, char *e, unsigned int x)
    636. 

  636.  {
    637. 

  637.      char *e0 = e;
    638. 

  638.      if (e <= p) return p;
    639. 

  639. @@ -71,12 +71,12 @@ printf_test_call(int argc, VALUE *argv, VALUE self)
    640. 

  640.  	    *p++ = '0';
    641. 

  641.  	}
    642. 

  642.  	if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("width"))))) {
    643. 

  643. -	    p = utoa(p, format + sizeof(format), NUM2UINT(v));
    644. 

  644. +	    p = uint_to_str(p, format + sizeof(format), NUM2UINT(v));
    645. 

  645.  	}
    646. 

  646.  	if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("prec"))))) {
    647. 

  647.  	    *p++ = '.';
    648. 

  648.  	    if (FIXNUM_P(v))
    649. 

  649. -		p = utoa(p, format + sizeof(format), NUM2UINT(v));
    650. 

  650. +		p = uint_to_str(p, format + sizeof(format), NUM2UINT(v));
    651. 

  651.  	}
    652. 

  652.      }
    653. 

  653.      *p++ = cnv;
    654. 

  654. diff --git a/ext/-test-/string/nofree.c b/ext/-test-/string/nofree.c
    655. 

  655. new file mode 100644
    656. 

  656. index 0000000..d3d8071
    657. 

  657. --- /dev/null
    658. 

  658. +++ b/ext/-test-/string/nofree.c
    659. 

  659. @@ -0,0 +1,13 @@
    660. 

  660. +#include "ruby.h"
    661. 

  661. +
    662. 

  662. +VALUE
    663. 

  663. +bug_str_nofree(VALUE self)
    664. 

  664. +{
    665. 

  665. +    return rb_str_new_cstr("abcdef");
    666. 

  666. +}
    667. 

  667. +
    668. 

  668. +void
    669. 

  669. +Init_nofree(VALUE klass)
    670. 

  670. +{
    671. 

  671. +    rb_define_singleton_method(klass, "nofree", bug_str_nofree, 0);
    672. 

  672. +}
    673. 

  673. diff --git a/ext/bigdecimal/README b/ext/bigdecimal/README
    674. 

  674. deleted file mode 100644
    675. 

  675. index 7a43628..0000000
    676. 

  676. --- a/ext/bigdecimal/README
    677. 

  677. +++ /dev/null
    678. 

  678. @@ -1,60 +0,0 @@
    679. 

  679. -
    680. 

  680. -  Ruby BIGDECIMAL(Variable Precision) extension library.
    681. 

  681. -  Copyright (C) 1999  by Shigeo Kobayashi(shigeo@tinyforest.gr.jp)
    682. 

  682. -
    683. 

  683. -BigDecimal is copyrighted free software by Shigeo Kobayashi <shigeo@tinyforest.gr.jp>.
    684. 

  684. -You can redistribute it and/or modify it under either the terms of the GPL
    685. 

  685. -(see COPYING file), or the conditions below:
    686. 

  686. -
    687. 

  687. -  1. You may make and give away verbatim copies of the source form of the
    688. 

  688. -     software without restriction, provided that you duplicate all of the
    689. 

  689. -     original copyright notices and associated disclaimers.
    690. 

  690. -
    691. 

  691. -  2. You may modify your copy of the software in any way, provided that
    692. 

  692. -     you do at least ONE of the following:
    693. 

  693. -
    694. 

  694. -       a) place your modifications in the Public Domain or otherwise
    695. 

  695. -          make them Freely Available, such as by posting said
    696. 

  696. -	  modifications to Usenet or an equivalent medium, or by allowing
    697. 

  697. -	  the author to include your modifications in the software.
    698. 

  698. -
    699. 

  699. -       b) use the modified software only within your corporation or
    700. 

  700. -          organization.
    701. 

  701. -
    702. 

  702. -       c) rename any non-standard executables so the names do not conflict
    703. 

  703. -	  with standard executables, which must also be provided.
    704. 

  704. -
    705. 

  705. -       d) make other distribution arrangements with the author.
    706. 

  706. -
    707. 

  707. -  3. You may distribute the software in object code or executable
    708. 

  708. -     form, provided that you do at least ONE of the following:
    709. 

  709. -
    710. 

  710. -       a) distribute the executables and library files of the software,
    711. 

  711. -	  together with instructions (in the manual page or equivalent)
    712. 

  712. -	  on where to get the original distribution.
    713. 

  713. -
    714. 

  714. -       b) accompany the distribution with the machine-readable source of
    715. 

  715. -	  the software.
    716. 

  716. -
    717. 

  717. -       c) give non-standard executables non-standard names, with
    718. 

  718. -          instructions on where to get the original software distribution.
    719. 

  719. -
    720. 

  720. -       d) make other distribution arrangements with the author.
    721. 

  721. -
    722. 

  722. -  4. You may modify and include the part of the software into any other
    723. 

  723. -     software (possibly commercial).
    724. 

  724. -
    725. 

  725. -  5. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
    726. 

  726. -     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
    727. 

  727. -     WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
    728. 

  728. -     PURPOSE.
    729. 

  729. -
    730. 

  730. -* The Author
    731. 

  731. -
    732. 

  732. -Feel free to send comments and bug reports to the ruby-core team.
    733. 

  733. -
    734. 

  734. -  http://bugs.ruby-lang.org
    735. 

  735. -
    736. 

  736. --------------------------------------------------------
    737. 

  737. -created at: Thu Dec 22 1999
    738. 

  738. -updated at: Wed Sep 28 2011
    739. 

  739. diff --git a/ext/bigdecimal/bigdecimal.c b/ext/bigdecimal/bigdecimal.c
    740. 

  740. index 9606646..aabdbc6 100644
    741. 

  741. --- a/ext/bigdecimal/bigdecimal.c
    742. 

  742. +++ b/ext/bigdecimal/bigdecimal.c
    743. 

  743. @@ -4,13 +4,6 @@
    744. 

  744.   *
    745. 

  745.   * Copyright(C) 2002 by Shigeo Kobayashi(shigeo@tinyforest.gr.jp)
    746. 

  746.   *
    747. 

  747. - * You may distribute under the terms of either the GNU General Public
    748. 

  748. - * License or the Artistic License, as specified in the README file
    749. 

  749. - * of this BigDecimal distribution.
    750. 

  750. - *
    751. 

  751. - *  NOTE: Change log in this source removed to reduce source code size.
    752. 

  752. - *        See rev. 1.25 if needed.
    753. 

  753. - *
    754. 

  754.   */
    755. 

  755.  
    756. 

  756.  /* #define BIGDECIMAL_DEBUG 1 */
    757. 

  757. diff --git a/ext/bigdecimal/bigdecimal.gemspec b/ext/bigdecimal/bigdecimal.gemspec
    758. 

  758. index 197bdea..7e291a3 100644
    759. 

  759. --- a/ext/bigdecimal/bigdecimal.gemspec
    760. 

  760. +++ b/ext/bigdecimal/bigdecimal.gemspec
    761. 

  761. @@ -6,6 +6,7 @@ Gem::Specification.new do |s|
    762. 

  762.    s.name = "bigdecimal"
    763. 

  763.    s.version = _VERSION
    764. 

  764.    s.date = date
    765. 

  765. +  s.license = 'ruby'
    766. 

  766.    s.summary = "Arbitrary-precision decimal floating-point number library."
    767. 

  767.    s.homepage = "http://www.ruby-lang.org"
    768. 

  768.    s.email = "mrkn@mrkn.jp"
    769. 

  769. @@ -16,7 +17,6 @@ Gem::Specification.new do |s|
    770. 

  770.      bigdecimal.gemspec
    771. 

  771.      bigdecimal.c
    772. 

  772.      bigdecimal.h
    773. 

  773. -    README
    774. 

  774.      depend extconf.rb
    775. 

  775.      lib/bigdecimal/jacobian.rb
    776. 

  776.      lib/bigdecimal/ludcmp.rb
    777. 

  777. diff --git a/ext/bigdecimal/bigdecimal.h b/ext/bigdecimal/bigdecimal.h
    778. 

  778. index 9d3e0fc..e8adea6 100644
    779. 

  779. --- a/ext/bigdecimal/bigdecimal.h
    780. 

  780. +++ b/ext/bigdecimal/bigdecimal.h
    781. 

  781. @@ -4,13 +4,6 @@
    782. 

  782.   *
    783. 

  783.   * Copyright(C) 2002 by Shigeo Kobayashi(shigeo@tinyforest.gr.jp)
    784. 

  784.   *
    785. 

  785. - * You may distribute under the terms of either the GNU General Public
    786. 

  786. - * License or the Artistic License, as specified in the README file
    787. 

  787. - * of this BigDecimal distribution.
    788. 

  788. - *
    789. 

  789. - * NOTES:
    790. 

  790. - *   2003-03-28 V1.0 checked in.
    791. 

  791. - *
    792. 

  792.   */
    793. 

  793.  
    794. 

  794.  #ifndef  RUBY_BIG_DECIMAL_H
    795. 

  795. diff --git a/ext/openssl/ossl_asn1.c b/ext/openssl/ossl_asn1.c
    796. 

  796. index 3a24d17..6d564a3 100644
    797. 

  797. --- a/ext/openssl/ossl_asn1.c
    798. 

  798. +++ b/ext/openssl/ossl_asn1.c
    799. 

  799. @@ -1029,7 +1029,7 @@ static VALUE
    800. 

  800.  ossl_asn1_traverse(VALUE self, VALUE obj)
    801. 

  801.  {
    802. 

  802.      unsigned char *p;
    803. 

  803. -    volatile VALUE tmp;
    804. 

  804. +    VALUE tmp;
    805. 

  805.      long len, read = 0, offset = 0;
    806. 

  806.  
    807. 

  807.      obj = ossl_to_der_if_possible(obj);
    808. 

  808. @@ -1037,6 +1037,7 @@ ossl_asn1_traverse(VALUE self, VALUE obj)
    809. 

  809.      p = (unsigned char *)RSTRING_PTR(tmp);
    810. 

  810.      len = RSTRING_LEN(tmp);
    811. 

  811.      ossl_asn1_decode0(&p, len, &offset, 0, 1, &read);
    812. 

  812. +    RB_GC_GUARD(tmp);
    813. 

  813.      int_ossl_decode_sanity_check(len, read, offset);
    814. 

  814.      return Qnil;
    815. 

  815.  }
    816. 

  816. @@ -1058,7 +1059,7 @@ ossl_asn1_decode(VALUE self, VALUE obj)
    817. 

  817.  {
    818. 

  818.      VALUE ret;
    819. 

  819.      unsigned char *p;
    820. 

  820. -    volatile VALUE tmp;
    821. 

  821. +    VALUE tmp;
    822. 

  822.      long len, read = 0, offset = 0;
    823. 

  823.  
    824. 

  824.      obj = ossl_to_der_if_possible(obj);
    825. 

  825. @@ -1066,6 +1067,7 @@ ossl_asn1_decode(VALUE self, VALUE obj)
    826. 

  826.      p = (unsigned char *)RSTRING_PTR(tmp);
    827. 

  827.      len = RSTRING_LEN(tmp);
    828. 

  828.      ret = ossl_asn1_decode0(&p, len, &offset, 0, 0, &read);
    829. 

  829. +    RB_GC_GUARD(tmp);
    830. 

  830.      int_ossl_decode_sanity_check(len, read, offset);
    831. 

  831.      return ret;
    832. 

  832.  }
    833. 

  833. @@ -1089,7 +1091,7 @@ ossl_asn1_decode_all(VALUE self, VALUE obj)
    834. 

  834.      VALUE ary, val;
    835. 

  835.      unsigned char *p;
    836. 

  836.      long len, tmp_len = 0, read = 0, offset = 0;
    837. 

  837. -    volatile VALUE tmp;
    838. 

  838. +    VALUE tmp;
    839. 

  839.  
    840. 

  840.      obj = ossl_to_der_if_possible(obj);
    841. 

  841.      tmp = rb_str_new4(StringValue(obj));
    842. 

  842. @@ -1104,6 +1106,7 @@ ossl_asn1_decode_all(VALUE self, VALUE obj)
    843. 

  843.  	read += tmp_read;
    844. 

  844.  	tmp_len -= tmp_read;
    845. 

  845.      }
    846. 

  846. +    RB_GC_GUARD(tmp);
    847. 

  847.      int_ossl_decode_sanity_check(len, read, offset);
    848. 

  848.      return ary;
    849. 

  849.  }
    850. 

  850. diff --git a/ext/pty/pty.c b/ext/pty/pty.c
    851. 

  851. index 29cc689..631adb2 100644
    852. 

  852. --- a/ext/pty/pty.c
    853. 

  853. +++ b/ext/pty/pty.c
    854. 

  854. @@ -261,7 +261,7 @@ get_device_once(int *master, int *slave, char SlaveName[DEVICELEN], int nomesg,
    855. 

  855.      if ((slavefd = rb_cloexec_open(slavedevice, O_RDWR|O_NOCTTY, 0)) == -1) goto error;
    856. 

  856.      rb_update_max_fd(slavefd);
    857. 

  857.  
    858. 

  858. -#if defined(I_PUSH) && !defined(__linux__)
    859. 

  859. +#if defined(I_PUSH) && !defined(__linux__) && !defined(_AIX)
    860. 

  860.      if (ioctl(slavefd, I_PUSH, "ptem") == -1) goto error;
    861. 

  861.      if (ioctl(slavefd, I_PUSH, "ldterm") == -1) goto error;
    862. 

  862.      if (ioctl(slavefd, I_PUSH, "ttcompat") == -1) goto error;
    863. 

  863. @@ -345,7 +345,7 @@ get_device_once(int *master, int *slave, char SlaveName[DEVICELEN], int nomesg,
    864. 

  864.      if (no_mesg(slavedevice, nomesg) == -1) goto error;
    865. 

  865.      if((slavefd = rb_cloexec_open(slavedevice, O_RDWR, 0)) == -1) goto error;
    866. 

  866.      rb_update_max_fd(slavefd);
    867. 

  867. -#if defined(I_PUSH) && !defined(__linux__)
    868. 

  868. +#if defined(I_PUSH) && !defined(__linux__) && !defined(_AIX)
    869. 

  869.      if(ioctl(slavefd, I_PUSH, "ptem") == -1) goto error;
    870. 

  870.      if(ioctl(slavefd, I_PUSH, "ldterm") == -1) goto error;
    871. 

  871.      ioctl(slavefd, I_PUSH, "ttcompat");
    872. 

  872. diff --git a/ext/socket/ancdata.c b/ext/socket/ancdata.c
    873. 

  873. index f0dbb2b..b69417e 100644
    874. 

  874. --- a/ext/socket/ancdata.c
    875. 

  875. +++ b/ext/socket/ancdata.c
    876. 

  876. @@ -1135,7 +1135,7 @@ bsock_sendmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
    877. 

  877.      struct msghdr mh;
    878. 

  878.      struct iovec iov;
    879. 

  879.  #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
    880. 

  880. -    volatile VALUE controls_str = 0;
    881. 

  881. +    VALUE controls_str = 0;
    882. 

  882.      VALUE *controls_ptr = NULL;
    883. 

  883.      int family;
    884. 

  884.  #endif
    885. 

  885. @@ -1291,6 +1291,9 @@ bsock_sendmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
    886. 

  886.              rb_readwrite_sys_fail(RB_IO_WAIT_WRITABLE, "sendmsg(2) would block");
    887. 

  887.  	rb_sys_fail("sendmsg(2)");
    888. 

  888.      }
    889. 

  889. +#if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
    890. 

  890. +    RB_GC_GUARD(controls_str);
    891. 

  891. +#endif
    892. 

  892.  
    893. 

  893.      return SSIZET2NUM(ss);
    894. 

  894.  }
    895. 

  895. @@ -1711,6 +1714,7 @@ bsock_recvmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
    896. 

  896.                  discard_cmsg(cmh, msg_end, (flags & MSG_PEEK) != 0);
    897. 

  897.              rb_ary_push(ret, ctl);
    898. 

  898.          }
    899. 

  899. +        RB_GC_GUARD(ctl_str);
    900. 

  900.      }
    901. 

  901.  #endif
    902. 

  902.  
    903. 

  903. diff --git a/ext/socket/ipsocket.c b/ext/socket/ipsocket.c
    904. 

  904. index ef5ce76..16a8373 100644
    905. 

  905. --- a/ext/socket/ipsocket.c
    906. 

  906. +++ b/ext/socket/ipsocket.c
    907. 

  907. @@ -41,6 +41,7 @@ inetsock_cleanup(struct inetsock_arg *arg)
    908. 

  908.  static VALUE
    909. 

  909.  init_inetsock_internal(struct inetsock_arg *arg)
    910. 

  910.  {
    911. 

  911. +    int error = 0;
    912. 

  912.      int type = arg->type;
    913. 

  913.      struct addrinfo *res, *lres;
    914. 

  914.      int fd, status = 0, local = 0;
    915. 

  915. @@ -80,6 +81,7 @@ init_inetsock_internal(struct inetsock_arg *arg)
    916. 

  916.  	syscall = "socket(2)";
    917. 

  917.  	fd = status;
    918. 

  918.  	if (fd < 0) {
    919. 

  919. +	    error = errno;
    920. 

  920.  	    continue;
    921. 

  921.  	}
    922. 

  922.  	arg->fd = fd;
    923. 

  923. @@ -107,6 +109,7 @@ init_inetsock_internal(struct inetsock_arg *arg)
    924. 

  924.  	}
    925. 

  925.  
    926. 

  926.  	if (status < 0) {
    927. 

  927. +	    error = errno;
    928. 

  928.  	    close(fd);
    929. 

  929.  	    arg->fd = fd = -1;
    930. 

  930.  	    continue;
    931. 

  931. @@ -124,7 +127,7 @@ init_inetsock_internal(struct inetsock_arg *arg)
    932. 

  932.  	    port = arg->remote.serv;
    933. 

  933.  	}
    934. 

  934.  
    935. 

  935. -	rsock_sys_fail_host_port(syscall, host, port);
    936. 

  936. +	rsock_syserr_fail_host_port(error, syscall, host, port);
    937. 

  937.      }
    938. 

  938.  
    939. 

  939.      arg->fd = -1;
    940. 

  940. @@ -132,8 +135,9 @@ init_inetsock_internal(struct inetsock_arg *arg)
    941. 

  941.      if (type == INET_SERVER) {
    942. 

  942.  	status = listen(fd, SOMAXCONN);
    943. 

  943.  	if (status < 0) {
    944. 

  944. +	    error = errno;
    945. 

  945.  	    close(fd);
    946. 

  946. -            rb_sys_fail("listen(2)");
    947. 

  947. +	    rb_syserr_fail(error, "listen(2)");
    948. 

  948.  	}
    949. 

  949.      }
    950. 

  950.  
    951. 

  951. diff --git a/ext/socket/raddrinfo.c b/ext/socket/raddrinfo.c
    952. 

  952. index e13684a..d838898 100644
    953. 

  953. --- a/ext/socket/raddrinfo.c
    954. 

  954. +++ b/ext/socket/raddrinfo.c
    955. 

  955. @@ -1643,6 +1643,7 @@ addrinfo_mload(VALUE self, VALUE ary)
    956. 

  956.  
    957. 

  957.          len = res->ai->ai_addrlen;
    958. 

  958.          memcpy(&ss, res->ai->ai_addr, res->ai->ai_addrlen);
    959. 

  959. +        rb_freeaddrinfo(res);
    960. 

  960.          break;
    961. 

  961.        }
    962. 

  962.      }
    963. 

  963. diff --git a/gc.c b/gc.c
    964. 

  964. index 5940564..549d7ca 100644
    965. 

  965. --- a/gc.c
    966. 

  966. +++ b/gc.c
    967. 

  967. @@ -2771,6 +2771,9 @@ id2ref(VALUE obj, VALUE objid)
    968. 

  968.      if (!is_live_object(objspace, ptr)) {
    969. 

  969.  	rb_raise(rb_eRangeError, "%p is recycled object", p0);
    970. 

  970.      }
    971. 

  971. +    if (RBASIC(ptr)->klass == 0) {
    972. 

  972. +	rb_raise(rb_eRangeError, "%p is internal object", p0);
    973. 

  973. +    }
    974. 

  974.      return (VALUE)ptr;
    975. 

  975.  }
    976. 

  976.  
    977. 

  977. diff --git a/hash.c b/hash.c
    978. 

  978. index 8d37dc6..fb4c5a5 100644
    979. 

  979. --- a/hash.c
    980. 

  980. +++ b/hash.c
    981. 

  981. @@ -142,13 +142,19 @@ rb_any_hash(VALUE a)
    982. 

  982.  	}
    983. 

  983.  	else if (FLONUM_P(a)) {
    984. 

  984.  	    /* prevent pathological behavior: [Bug #10761] */
    985. 

  985. -	    a = (st_index_t)rb_float_value(a);
    986. 

  986. +	    return rb_dbl_hash(rb_float_value(a));
    987. 

  987.  	}
    988. 

  988.  	hnum = rb_objid_hash((st_index_t)a);
    989. 

  989.      }
    990. 

  990.      else if (BUILTIN_TYPE(a) == T_STRING) {
    991. 

  991.  	hnum = rb_str_hash(a);
    992. 

  992.      }
    993. 

  993. +    else if (BUILTIN_TYPE(a) == T_SYMBOL) {
    994. 

  994. +	hnum = rb_objid_hash((st_index_t)a);
    995. 

  995. +    }
    996. 

  996. +    else if (BUILTIN_TYPE(a) == T_FLOAT) {
    997. 

  997. +	return rb_dbl_hash(rb_float_value(a));
    998. 

  998. +    }
    999. 

  999.      else {
    1000. 

  1000.          hval = rb_hash(a);
    1001. 

  1001.  	hnum = FIX2LONG(hval);
    1002. 

  1002. diff --git a/internal.h b/internal.h
    1003. 

  1003. index 4da45a4..1833dca 100644
    1004. 

  1004. --- a/internal.h
    1005. 

  1005. +++ b/internal.h
    1006. 

  1006. @@ -773,6 +773,7 @@ double ruby_float_mod(double x, double y);
    1007. 

  1007.  int rb_num_negative_p(VALUE);
    1008. 

  1008.  VALUE rb_int_succ(VALUE num);
    1009. 

  1009.  VALUE rb_int_pred(VALUE num);
    1010. 

  1010. +VALUE rb_dbl_hash(double d);
    1011. 

  1011.  
    1012. 

  1012.  #if USE_FLONUM
    1013. 

  1013.  #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
    1014. 

  1014. diff --git a/iseq.c b/iseq.c
    1015. 

  1015. index de65dcb..9cf5df6 100644
    1016. 

  1016. --- a/iseq.c
    1017. 

  1017. +++ b/iseq.c
    1018. 

  1018. @@ -596,6 +596,7 @@ rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE li
    1019. 

  1019.  	if (RB_TYPE_P((src), T_FILE))
    1020. 

  1020.  	    node = rb_parser_compile_file_path(parser, file, src, ln);
    1021. 

  1021.  	else {
    1022. 

  1022. +	    StringValue(src);
    1023. 

  1023.  	    node = rb_parser_compile_string_path(parser, file, src, ln);
    1024. 

  1024.  
    1025. 

  1025.  	    if (!node) {
    1026. 

  1026. diff --git a/lib/fileutils.rb b/lib/fileutils.rb
    1027. 

  1027. index 23fd193..932776c 100644
    1028. 

  1028. --- a/lib/fileutils.rb
    1029. 

  1029. +++ b/lib/fileutils.rb
    1030. 

  1030. @@ -518,7 +518,7 @@ module FileUtils
    1031. 

  1031.        begin
    1032. 

  1032.          if destent.exist?
    1033. 

  1033.            if destent.directory?
    1034. 

  1034. -            raise Errno::EEXIST, dest
    1035. 

  1035. +            raise Errno::EEXIST, d
    1036. 

  1036.            else
    1037. 

  1037.              destent.remove_file if rename_cannot_overwrite_file?
    1038. 

  1038.            end
    1039. 

  1039. diff --git a/lib/net/imap.rb b/lib/net/imap.rb
    1040. 

  1040. index a772c46..0517ca1 100644
    1041. 

  1041. --- a/lib/net/imap.rb
    1042. 

  1042. +++ b/lib/net/imap.rb
    1043. 

  1043. @@ -2625,7 +2625,13 @@ module Net
    1044. 

  1044.            return param
    1045. 

  1045.          end
    1046. 

  1046.          disposition = body_fld_dsp
    1047. 

  1047. -        match(T_SPACE)
    1048. 

  1048. +
    1049. 

  1049. +        token = lookahead
    1050. 

  1050. +        if token.symbol == T_SPACE
    1051. 

  1051. +          shift_token
    1052. 

  1052. +        else
    1053. 

  1053. +          return param, disposition
    1054. 

  1054. +        end
    1055. 

  1055.          language = body_fld_lang
    1056. 

  1056.  
    1057. 

  1057.          token = lookahead
    1058. 

  1058. diff --git a/lib/resolv.rb b/lib/resolv.rb
    1059. 

  1059. index 7855c6e..dee6afd 100644
    1060. 

  1060. --- a/lib/resolv.rb
    1061. 

  1061. +++ b/lib/resolv.rb
    1062. 

  1062. @@ -1183,7 +1183,7 @@ class Resolv
    1063. 

  1063.          end
    1064. 

  1064.  
    1065. 

  1065.          def ==(other)
    1066. 

  1066. -          return @downcase == other.downcase
    1067. 

  1067. +          return self.class == other.class && @downcase == other.downcase
    1068. 

  1068.          end
    1069. 

  1069.  
    1070. 

  1070.          def eql?(other)
    1071. 

  1071. @@ -1219,6 +1219,14 @@ class Resolv
    1072. 

  1072.        end
    1073. 

  1073.  
    1074. 

  1074.        def initialize(labels, absolute=true) # :nodoc:
    1075. 

  1075. +        labels = labels.map {|label|
    1076. 

  1076. +          case label
    1077. 

  1077. +          when String then Label::Str.new(label)
    1078. 

  1078. +          when Label::Str then label
    1079. 

  1079. +          else
    1080. 

  1080. +            raise ArgumentError, "unexpected label: #{label.inspect}"
    1081. 

  1081. +          end
    1082. 

  1082. +        }
    1083. 

  1083.          @labels = labels
    1084. 

  1084.          @absolute = absolute
    1085. 

  1085.        end
    1086. 

  1086. diff --git a/load.c b/load.c
    1087. 

  1087. index 65017c9..af3548c 100644
    1088. 

  1088. --- a/load.c
    1089. 

  1089. +++ b/load.c
    1090. 

  1090. @@ -318,7 +318,7 @@ loaded_feature_path(const char *name, long vlen, const char *feature, long len,
    1091. 

  1091.      const char *e;
    1092. 

  1092.  
    1093. 

  1093.      if (vlen < len+1) return 0;
    1094. 

  1094. -    if (!strncmp(name+(vlen-len), feature, len)) {
    1095. 

  1095. +    if (strchr(feature, '.') && !strncmp(name+(vlen-len), feature, len)) {
    1096. 

  1096.  	plen = vlen - len;
    1097. 

  1097.      }
    1098. 

  1098.      else {
    1099. 

  1099. diff --git a/marshal.c b/marshal.c
    1100. 

  1100. index bd57b1f..ab1ab56 100644
    1101. 

  1101. --- a/marshal.c
    1102. 

  1102. +++ b/marshal.c
    1103. 

  1103. @@ -1298,11 +1298,18 @@ r_bytes0(long len, struct load_arg *arg)
    1104. 

  1104.  static int
    1105. 

  1105.  sym2encidx(VALUE sym, VALUE val)
    1106. 

  1106.  {
    1107. 

  1107. -    if (sym == ID2SYM(rb_id_encoding())) {
    1108. 

  1108. +    static const char name_encoding[8] = "encoding";
    1109. 

  1109. +    const char *p;
    1110. 

  1110. +    long l;
    1111. 

  1111. +    if (rb_enc_get_index(sym) != ENCINDEX_US_ASCII) return -1;
    1112. 

  1112. +    RSTRING_GETMEM(sym, p, l);
    1113. 

  1113. +    if (l <= 0) return -1;
    1114. 

  1114. +    if (l == sizeof(name_encoding) &&
    1115. 

  1115. +	memcmp(p, name_encoding, sizeof(name_encoding)) == 0) {
    1116. 

  1116.  	int idx = rb_enc_find_index(StringValueCStr(val));
    1117. 

  1117.  	return idx;
    1118. 

  1118.      }
    1119. 

  1119. -    else if (sym == ID2SYM(rb_intern("E"))) {
    1120. 

  1120. +    else if (l == 1 && *p == 'E') {
    1121. 

  1121.  	if (val == Qfalse) return rb_usascii_encindex();
    1122. 

  1122.  	else if (val == Qtrue) return rb_utf8_encindex();
    1123. 

  1123.  	/* bogus ignore */
    1124. 

  1124. @@ -1330,7 +1337,8 @@ r_symreal(struct load_arg *arg, int ivar)
    1125. 

  1125.      int idx = -1;
    1126. 

  1126.      st_index_t n = arg->symbols->num_entries;
    1127. 

  1127.  
    1128. 

  1128. -    st_insert(arg->symbols, (st_data_t)n, (st_data_t)0);
    1129. 

  1129. +    if (rb_enc_str_asciionly_p(s)) rb_enc_associate_index(s, ENCINDEX_US_ASCII);
    1130. 

  1130. +    st_insert(arg->symbols, (st_data_t)n, (st_data_t)s);
    1131. 

  1131.      if (ivar) {
    1132. 

  1132.  	long num = r_long(arg);
    1133. 

  1133.  	while (num-- > 0) {
    1134. 

  1134. @@ -1339,10 +1347,8 @@ r_symreal(struct load_arg *arg, int ivar)
    1135. 

  1135.  	}
    1136. 

  1136.      }
    1137. 

  1137.      if (idx > 0) rb_enc_associate_index(s, idx);
    1138. 

  1138. -    sym = rb_str_intern(s);
    1139. 

  1139. -    st_insert(arg->symbols, (st_data_t)n, (st_data_t)sym);
    1140. 

  1140.  
    1141. 

  1141. -    return sym;
    1142. 

  1142. +    return s;
    1143. 

  1143.  }
    1144. 

  1144.  
    1145. 

  1145.  static VALUE
    1146. 

  1146. @@ -1370,7 +1376,7 @@ r_symbol(struct load_arg *arg)
    1147. 

  1147.  static VALUE
    1148. 

  1148.  r_unique(struct load_arg *arg)
    1149. 

  1149.  {
    1150. 

  1150. -    return rb_sym2str(r_symbol(arg));
    1151. 

  1151. +    return r_symbol(arg);
    1152. 

  1152.  }
    1153. 

  1153.  
    1154. 

  1154.  static VALUE
    1155. 

  1155. @@ -1468,7 +1474,7 @@ r_ivar(VALUE obj, int *has_encoding, struct load_arg *arg)
    1156. 

  1156.  		if (has_encoding) *has_encoding = TRUE;
    1157. 

  1157.  	    }
    1158. 

  1158.  	    else {
    1159. 

  1159. -		rb_ivar_set(obj, SYM2ID(sym), val);
    1160. 

  1160. +		rb_ivar_set(obj, rb_intern_str(sym), val);
    1161. 

  1161.  	    }
    1162. 

  1162.  	} while (--len > 0);
    1163. 

  1163.      }
    1164. 

  1164. @@ -1793,13 +1799,13 @@ r_object0(struct load_arg *arg, int *ivp, VALUE extmod)
    1165. 

  1165.  	    v = r_entry0(v, idx, arg);
    1166. 

  1166.  	    values = rb_ary_new2(len);
    1167. 

  1167.  	    for (i=0; i<len; i++) {
    1168. 

  1168. +		VALUE n = rb_sym2str(RARRAY_AREF(mem, i));
    1169. 

  1169.  		slot = r_symbol(arg);
    1170. 

  1170.  
    1171. 

  1171. -		if (RARRAY_AREF(mem, i) != slot) {
    1172. 

  1172. +		if (!rb_str_equal(n, slot)) {
    1173. 

  1173.  		    rb_raise(rb_eTypeError, "struct %"PRIsVALUE" not compatible (:%"PRIsVALUE" for :%"PRIsVALUE")",
    1174. 

  1174.  			     rb_class_name(klass),
    1175. 

  1175. -			     rb_sym2str(slot),
    1176. 

  1176. -			     rb_sym2str(RARRAY_AREF(mem, i)));
    1177. 

  1177. +			     slot, n);
    1178. 

  1178.  		}
    1179. 

  1179.                  rb_ary_push(values, r_object(arg));
    1180. 

  1180.  		arg->readable -= 2;
    1181. 

  1181. @@ -1937,11 +1943,12 @@ r_object0(struct load_arg *arg, int *ivp, VALUE extmod)
    1182. 

  1182.  	else {
    1183. 

  1183.  	    v = r_symreal(arg, 0);
    1184. 

  1184.  	}
    1185. 

  1185. +	v = rb_str_intern(v);
    1186. 

  1186.  	v = r_leave(v, arg);
    1187. 

  1187.  	break;
    1188. 

  1188.  
    1189. 

  1189.        case TYPE_SYMLINK:
    1190. 

  1190. -	v = r_symlink(arg);
    1191. 

  1191. +	v = rb_str_intern(r_symlink(arg));
    1192. 

  1192.  	break;
    1193. 

  1193.  
    1194. 

  1194.        default:
    1195. 

  1195. diff --git a/numeric.c b/numeric.c
    1196. 

  1196. index 0222c76..e7435bb 100644
    1197. 

  1197. --- a/numeric.c
    1198. 

  1198. +++ b/numeric.c
    1199. 

  1199. @@ -1137,10 +1137,14 @@ flo_eq(VALUE x, VALUE y)
    1200. 

  1200.  static VALUE
    1201. 

  1201.  flo_hash(VALUE num)
    1202. 

  1202.  {
    1203. 

  1203. -    double d;
    1204. 

  1204. +    return rb_dbl_hash(RFLOAT_VALUE(num));
    1205. 

  1205. +}
    1206. 

  1206. +
    1207. 

  1207. +VALUE
    1208. 

  1208. +rb_dbl_hash(double d)
    1209. 

  1209. +{
    1210. 

  1210.      st_index_t hash;
    1211. 

  1211.  
    1212. 

  1212. -    d = RFLOAT_VALUE(num);
    1213. 

  1213.      /* normalize -0.0 to 0.0 */
    1214. 

  1214.      if (d == 0.0) d = 0.0;
    1215. 

  1215.      hash = rb_memhash(&d, sizeof(d));
    1216. 

  1216. diff --git a/parse.y b/parse.y
    1217. 

  1217. index 0f9a567..1e29197 100644
    1218. 

  1218. --- a/parse.y
    1219. 

  1219. +++ b/parse.y
    1220. 

  1220. @@ -3534,14 +3534,19 @@ lambda		:   {
    1221. 

  1221.  		    {
    1222. 

  1222.  			$<num>$ = ruby_sourceline;
    1223. 

  1223.  		    }
    1224. 

  1224. +		    {
    1225. 

  1225. +			$<val>$ = cmdarg_stack;
    1226. 

  1226. +			cmdarg_stack = 0;
    1227. 

  1227. +		    }
    1228. 

  1228.  		  lambda_body
    1229. 

  1229.  		    {
    1230. 

  1230.  			lpar_beg = $<num>2;
    1231. 

  1231. +			cmdarg_stack = $<val>5;
    1232. 

  1232.  		    /*%%%*/
    1233. 

  1233. -			$$ = NEW_LAMBDA($3, $5);
    1234. 

  1234. +			$$ = NEW_LAMBDA($3, $6);
    1235. 

  1235.  			nd_set_line($$, $<num>4);
    1236. 

  1236.  		    /*%
    1237. 

  1237. -			$$ = dispatch2(lambda, $3, $5);
    1238. 

  1238. +			$$ = dispatch2(lambda, $3, $6);
    1239. 

  1239.  		    %*/
    1240. 

  1240.  			dyna_pop($<vars>1);
    1241. 

  1241.  		    }
    1242. 

  1242. diff --git a/proc.c b/proc.c
    1243. 

  1243. index 48d7dcb..5995c97 100644
    1244. 

  1244. --- a/proc.c
    1245. 

  1245. +++ b/proc.c
    1246. 

  1246. @@ -719,7 +719,7 @@ proc_call(int argc, VALUE *argv, VALUE procval)
    1247. 

  1247.      GetProcPtr(procval, proc);
    1248. 

  1248.  
    1249. 

  1249.      iseq = proc->block.iseq;
    1250. 

  1250. -    if (BUILTIN_TYPE(iseq) == T_NODE || iseq->param.flags.has_block) {
    1251. 

  1251. +    if (RUBY_VM_IFUNC_P(iseq) || iseq->param.flags.has_block) {
    1252. 

  1252.  	if (rb_block_given_p()) {
    1253. 

  1253.  	    rb_proc_t *passed_proc;
    1254. 

  1254.  	    RB_GC_GUARD(passed_procval) = rb_block_proc();
    1255. 

  1255. @@ -843,7 +843,7 @@ rb_block_min_max_arity(rb_block_t *block, int *max)
    1256. 

  1256.  {
    1257. 

  1257.      rb_iseq_t *iseq = block->iseq;
    1258. 

  1258.      if (iseq) {
    1259. 

  1259. -	if (BUILTIN_TYPE(iseq) != T_NODE) {
    1260. 

  1260. +	if (!RUBY_VM_IFUNC_P(iseq)) {
    1261. 

  1261.  	    return rb_iseq_min_max_arity(iseq, max);
    1262. 

  1262.  	}
    1263. 

  1263.  	else {
    1264. 

  1264. @@ -1131,29 +1131,68 @@ rb_obj_is_method(VALUE m)
    1265. 

  1265.      }
    1266. 

  1266.  }
    1267. 

  1267.  
    1268. 

  1268. +static int
    1269. 

  1269. +respond_to_missing_p(VALUE klass, VALUE obj, VALUE sym, int scope)
    1270. 

  1270. +{
    1271. 

  1271. +    /* TODO: merge with obj_respond_to() */
    1272. 

  1272. +    ID rmiss = idRespond_to_missing;
    1273. 

  1273. +
    1274. 

  1274. +    if (obj == Qundef) return 0;
    1275. 

  1275. +    if (rb_method_basic_definition_p(klass, rmiss)) return 0;
    1276. 

  1276. +    return RTEST(rb_funcall(obj, rmiss, 2, sym, scope ? Qfalse : Qtrue));
    1277. 

  1277. +}
    1278. 

  1278. +
    1279. 

  1279. +
    1280. 

  1280. +static VALUE
    1281. 

  1281. +mnew_missing(VALUE rclass, VALUE klass, VALUE obj, ID id, ID rid, VALUE mclass)
    1282. 

  1282. +{
    1283. 

  1283. +    struct METHOD *data;
    1284. 

  1284. +    VALUE method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
    1285. 

  1285. +    rb_method_entry_t *me;
    1286. 

  1286. +    rb_method_definition_t *def;
    1287. 

  1287. +
    1288. 

  1288. +    data->recv = obj;
    1289. 

  1289. +    data->rclass = rclass;
    1290. 

  1290. +    data->defined_class = klass;
    1291. 

  1291. +    data->id = rid;
    1292. 

  1292. +
    1293. 

  1293. +    me = ALLOC(rb_method_entry_t);
    1294. 

  1294. +    data->me = me;
    1295. 

  1295. +    me->flag = 0;
    1296. 

  1296. +    me->mark = 0;
    1297. 

  1297. +    me->called_id = id;
    1298. 

  1298. +    me->klass = klass;
    1299. 

  1299. +    me->def = 0;
    1300. 

  1300. +
    1301. 

  1301. +    def = ALLOC(rb_method_definition_t);
    1302. 

  1302. +    me->def = def;
    1303. 

  1303. +    def->type = VM_METHOD_TYPE_MISSING;
    1304. 

  1304. +    def->original_id = id;
    1305. 

  1305. +    def->alias_count = 0;
    1306. 

  1306. +
    1307. 

  1307. +    data->ume = ALLOC(struct unlinked_method_entry_list_entry);
    1308. 

  1308. +    data->me->def->alias_count++;
    1309. 

  1309. +
    1310. 

  1310. +    OBJ_INFECT(method, klass);
    1311. 

  1311. +
    1312. 

  1312. +    return method;
    1313. 

  1313. +}
    1314. 

  1314. +
    1315. 

  1315.  static VALUE
    1316. 

  1316.  mnew_internal(rb_method_entry_t *me, VALUE defined_class, VALUE klass,
    1317. 

  1317.  	      VALUE obj, ID id, VALUE mclass, int scope, int error)
    1318. 

  1318.  {
    1319. 

  1319. -    VALUE method;
    1320. 

  1320. +    struct METHOD *data;
    1321. 

  1321.      VALUE rclass = klass;
    1322. 

  1322. +    VALUE method;
    1323. 

  1323.      ID rid = id;
    1324. 

  1324. -    struct METHOD *data;
    1325. 

  1325.      rb_method_definition_t *def = 0;
    1326. 

  1326.      rb_method_flag_t flag = NOEX_UNDEF;
    1327. 

  1327.  
    1328. 

  1328.    again:
    1329. 

  1329.      if (UNDEFINED_METHOD_ENTRY_P(me)) {
    1330. 

  1330. -	ID rmiss = idRespond_to_missing;
    1331. 

  1331. -	VALUE sym = ID2SYM(id);
    1332. 

  1332. -
    1333. 

  1333. -	if (obj != Qundef && !rb_method_basic_definition_p(klass, rmiss)) {
    1334. 

  1334. -	    if (RTEST(rb_funcall(obj, rmiss, 2, sym, scope ? Qfalse : Qtrue))) {
    1335. 

  1335. -		me = 0;
    1336. 

  1336. -		defined_class = klass;
    1337. 

  1337. -
    1338. 

  1338. -		goto gen_method;
    1339. 

  1339. -	    }
    1340. 

  1340. +	if (respond_to_missing_p(klass, obj, ID2SYM(id), scope)) {
    1341. 

  1341. +	    return mnew_missing(rclass, klass, obj, id, rid, mclass);
    1342. 

  1342.  	}
    1343. 

  1343.  	if (!error) return Qnil;
    1344. 

  1344.  	rb_print_undef(klass, id, 0);
    1345. 

  1345. @@ -1180,7 +1219,6 @@ mnew_internal(rb_method_entry_t *me, VALUE defined_class, VALUE klass,
    1346. 

  1346.  	rclass = RCLASS_SUPER(rclass);
    1347. 

  1347.      }
    1348. 

  1348.  
    1349. 

  1349. -  gen_method:
    1350. 

  1350.      method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
    1351. 

  1351.  
    1352. 

  1352.      data->recv = obj;
    1353. 

  1353. @@ -1188,25 +1226,7 @@ mnew_internal(rb_method_entry_t *me, VALUE defined_class, VALUE klass,
    1354. 

  1354.      data->defined_class = defined_class;
    1355. 

  1355.      data->id = rid;
    1356. 

  1356.      data->me = ALLOC(rb_method_entry_t);
    1357. 

  1357. -    if (me) {
    1358. 

  1358. -	*data->me = *me;
    1359. 

  1359. -    }
    1360. 

  1360. -    else {
    1361. 

  1361. -	me = data->me;
    1362. 

  1362. -	me->flag = 0;
    1363. 

  1363. -	me->mark = 0;
    1364. 

  1364. -	me->called_id = id;
    1365. 

  1365. -	me->klass = klass;
    1366. 

  1366. -	me->def = 0;
    1367. 

  1367. -
    1368. 

  1368. -	def = ALLOC(rb_method_definition_t);
    1369. 

  1369. -	me->def = def;
    1370. 

  1370. -
    1371. 

  1371. -	def->type = VM_METHOD_TYPE_MISSING;
    1372. 

  1372. -	def->original_id = id;
    1373. 

  1373. -	def->alias_count = 0;
    1374. 

  1374. -
    1375. 

  1375. -    }
    1376. 

  1376. +    *data->me = *me;
    1377. 

  1377.      data->ume = ALLOC(struct unlinked_method_entry_list_entry);
    1378. 

  1378.      data->me->def->alias_count++;
    1379. 

  1379.  
    1380. 

  1380. @@ -1438,6 +1458,23 @@ rb_method_name_error(VALUE klass, VALUE str)
    1381. 

  1381.  		      QUOTE(str), s0, rb_class_name(c));
    1382. 

  1382.  }
    1383. 

  1383.  
    1384. 

  1384. +static VALUE
    1385. 

  1385. +obj_method(VALUE obj, VALUE vid, int scope)
    1386. 

  1386. +{
    1387. 

  1387. +    ID id = rb_check_id(&vid);
    1388. 

  1388. +    const VALUE klass = CLASS_OF(obj);
    1389. 

  1389. +    const VALUE mclass = rb_cMethod;
    1390. 

  1390. +
    1391. 

  1391. +    if (!id) {
    1392. 

  1392. +	if (respond_to_missing_p(klass, obj, vid, scope)) {
    1393. 

  1393. +	    id = rb_intern_str(vid);
    1394. 

  1394. +	    return mnew_missing(klass, klass, obj, id, id, mclass);
    1395. 

  1395. +	}
    1396. 

  1396. +	rb_method_name_error(klass, vid);
    1397. 

  1397. +    }
    1398. 

  1398. +    return mnew(klass, obj, id, mclass, scope);
    1399. 

  1399. +}
    1400. 

  1400. +
    1401. 

  1401.  /*
    1402. 

  1402.   *  call-seq:
    1403. 

  1403.   *     obj.method(sym)    -> method
    1404. 

  1404. @@ -1469,11 +1506,7 @@ rb_method_name_error(VALUE klass, VALUE str)
    1405. 

  1405.  VALUE
    1406. 

  1406.  rb_obj_method(VALUE obj, VALUE vid)
    1407. 

  1407.  {
    1408. 

  1408. -    ID id = rb_check_id(&vid);
    1409. 

  1409. -    if (!id) {
    1410. 

  1410. -	rb_method_name_error(CLASS_OF(obj), vid);
    1411. 

  1411. -    }
    1412. 

  1412. -    return mnew(CLASS_OF(obj), obj, id, rb_cMethod, FALSE);
    1413. 

  1413. +    return obj_method(obj, vid, FALSE);
    1414. 

  1414.  }
    1415. 

  1415.  
    1416. 

  1416.  /*
    1417. 

  1417. @@ -1486,11 +1519,7 @@ rb_obj_method(VALUE obj, VALUE vid)
    1418. 

  1418.  VALUE
    1419. 

  1419.  rb_obj_public_method(VALUE obj, VALUE vid)
    1420. 

  1420.  {
    1421. 

  1421. -    ID id = rb_check_id(&vid);
    1422. 

  1422. -    if (!id) {
    1423. 

  1423. -	rb_method_name_error(CLASS_OF(obj), vid);
    1424. 

  1424. -    }
    1425. 

  1425. -    return mnew(CLASS_OF(obj), obj, id, rb_cMethod, TRUE);
    1426. 

  1426. +    return obj_method(obj, vid, TRUE);
    1427. 

  1427.  }
    1428. 

  1428.  
    1429. 

  1429.  /*
    1430. 

  1430. @@ -1524,6 +1553,11 @@ rb_obj_singleton_method(VALUE obj, VALUE vid)
    1431. 

  1431.      VALUE klass;
    1432. 

  1432.      ID id = rb_check_id(&vid);
    1433. 

  1433.      if (!id) {
    1434. 

  1434. +	if (!NIL_P(klass = rb_singleton_class_get(obj)) &&
    1435. 

  1435. +	    respond_to_missing_p(klass, obj, vid, FALSE)) {
    1436. 

  1436. +	    id = rb_intern_str(vid);
    1437. 

  1437. +	    return mnew_missing(klass, klass, obj, id, id, rb_cMethod);
    1438. 

  1438. +	}
    1439. 

  1439.  	rb_name_error_str(vid, "undefined singleton method `%"PRIsVALUE"' for `%"PRIsVALUE"'",
    1440. 

  1440.  			  QUOTE(vid), obj);
    1441. 

  1441.      }
    1442. 

  1442. @@ -1683,7 +1717,7 @@ rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
    1443. 

  1443.  	rb_proc_t *proc;
    1444. 

  1444.  	body = proc_dup(body);
    1445. 

  1445.  	GetProcPtr(body, proc);
    1446. 

  1446. -	if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) {
    1447. 

  1447. +	if (!RUBY_VM_IFUNC_P(proc->block.iseq)) {
    1448. 

  1448.  	    proc->block.iseq->defined_method_id = id;
    1449. 

  1449.  	    RB_OBJ_WRITE(proc->block.iseq->self, &proc->block.iseq->klass, mod);
    1450. 

  1450.  	    proc->is_lambda = TRUE;
    1451. 

  1451. @@ -2443,22 +2477,40 @@ static VALUE
    1452. 

  1452.  proc_binding(VALUE self)
    1453. 

  1453.  {
    1454. 

  1454.      rb_proc_t *proc;
    1455. 

  1455. -    VALUE bindval;
    1456. 

  1456. +    VALUE bindval, envval;
    1457. 

  1457.      rb_binding_t *bind;
    1458. 

  1458.      rb_iseq_t *iseq;
    1459. 

  1459.  
    1460. 

  1460.      GetProcPtr(self, proc);
    1461. 

  1461. +    envval = proc->envval;
    1462. 

  1462.      iseq = proc->block.iseq;
    1463. 

  1463. -    if (RB_TYPE_P((VALUE)iseq, T_NODE)) {
    1464. 

  1464. +    if (RUBY_VM_IFUNC_P(iseq)) {
    1465. 

  1465. +	rb_env_t *env;
    1466. 

  1466.  	if (!IS_METHOD_PROC_NODE((NODE *)iseq)) {
    1467. 

  1467.  	    rb_raise(rb_eArgError, "Can't create Binding from C level Proc");
    1468. 

  1468.  	}
    1469. 

  1469.  	iseq = rb_method_get_iseq(RNODE(iseq)->u2.value);
    1470. 

  1470. +	GetEnvPtr(envval, env);
    1471. 

  1471. +	if (iseq && env->local_size < iseq->local_size) {
    1472. 

  1472. +	    int prev_local_size = env->local_size;
    1473. 

  1473. +	    int local_size = iseq->local_size;
    1474. 

  1474. +	    VALUE newenvval = TypedData_Wrap_Struct(RBASIC_CLASS(envval), RTYPEDDATA_TYPE(envval), 0);
    1475. 

  1475. +	    rb_env_t *newenv = xmalloc(sizeof(rb_env_t) + ((local_size + 1) * sizeof(VALUE)));
    1476. 

  1476. +	    RTYPEDDATA_DATA(newenvval) = newenv;
    1477. 

  1477. +	    newenv->env_size = local_size + 2;
    1478. 

  1478. +	    newenv->local_size = local_size;
    1479. 

  1479. +	    newenv->prev_envval = env->prev_envval;
    1480. 

  1480. +	    newenv->block = env->block;
    1481. 

  1481. +	    MEMCPY(newenv->env, env->env, VALUE, prev_local_size + 1);
    1482. 

  1482. +	    rb_mem_clear(newenv->env + prev_local_size + 1, local_size - prev_local_size);
    1483. 

  1483. +	    newenv->env[local_size + 1] = newenvval;
    1484. 

  1484. +	    envval = newenvval;
    1485. 

  1485. +	}
    1486. 

  1486.      }
    1487. 

  1487.  
    1488. 

  1488.      bindval = rb_binding_alloc(rb_cBinding);
    1489. 

  1489.      GetBindingPtr(bindval, bind);
    1490. 

  1490. -    bind->env = proc->envval;
    1491. 

  1491. +    bind->env = envval;
    1492. 

  1492.      bind->blockprocval = proc->blockprocval;
    1493. 

  1493.      if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
    1494. 

  1494.  	bind->path = iseq->location.path;
    1495. 

  1495. diff --git a/range.c b/range.c
    1496. 

  1496. index f4ab7e1..857cb48 100644
    1497. 

  1497. --- a/range.c
    1498. 

  1498. +++ b/range.c
    1499. 

  1499. @@ -329,6 +329,21 @@ discrete_object_p(VALUE obj)
    1500. 

  1500.      return rb_respond_to(obj, id_succ);
    1501. 

  1501.  }
    1502. 

  1502.  
    1503. 

  1503. +static int
    1504. 

  1504. +linear_object_p(VALUE obj)
    1505. 

  1505. +{
    1506. 

  1506. +    if (FIXNUM_P(obj) || FLONUM_P(obj)) return TRUE;
    1507. 

  1507. +    if (SPECIAL_CONST_P(obj)) return FALSE;
    1508. 

  1508. +    switch (BUILTIN_TYPE(obj)) {
    1509. 

  1509. +      case T_FLOAT:
    1510. 

  1510. +      case T_BIGNUM:
    1511. 

  1511. +	return TRUE;
    1512. 

  1512. +    }
    1513. 

  1513. +    if (rb_obj_is_kind_of(obj, rb_cNumeric)) return TRUE;
    1514. 

  1514. +    if (rb_obj_is_kind_of(obj, rb_cTime)) return TRUE;
    1515. 

  1515. +    return FALSE;
    1516. 

  1516. +}
    1517. 

  1517. +
    1518. 

  1518.  static VALUE
    1519. 

  1519.  range_step_size(VALUE range, VALUE args, VALUE eobj)
    1520. 

  1520.  {
    1521. 

  1521. @@ -1155,8 +1170,7 @@ range_include(VALUE range, VALUE val)
    1522. 

  1522.      VALUE beg = RANGE_BEG(range);
    1523. 

  1523.      VALUE end = RANGE_END(range);
    1524. 

  1524.      int nv = FIXNUM_P(beg) || FIXNUM_P(end) ||
    1525. 

  1525. -	     rb_obj_is_kind_of(beg, rb_cNumeric) ||
    1526. 

  1526. -	     rb_obj_is_kind_of(end, rb_cNumeric);
    1527. 

  1527. +	     linear_object_p(beg) || linear_object_p(end);
    1528. 

  1528.  
    1529. 

  1529.      if (nv ||
    1530. 

  1530.  	!NIL_P(rb_check_to_integer(beg, "to_int")) ||
    1531. 

  1531. diff --git a/rational.c b/rational.c
    1532. 

  1532. index addb195..134db64 100644
    1533. 

  1533. --- a/rational.c
    1534. 

  1534. +++ b/rational.c
    1535. 

  1535. @@ -2465,13 +2465,14 @@ nurat_s_convert(int argc, VALUE *argv, VALUE klass)
    1536. 

  1536.   * a/b (b>0).  Where a is numerator and b is denominator.  Integer a
    1537. 

  1537.   * equals rational a/1 mathematically.
    1538. 

  1538.   *
    1539. 

  1539. - * In ruby, you can create rational object with Rational, to_r or
    1540. 

  1540. - * rationalize method.  The return values will be irreducible.
    1541. 

  1541. + * In ruby, you can create rational object with Rational, to_r,
    1542. 

  1542. + * rationalize method or suffixing r to a literal.  The return values will be irreducible.
    1543. 

  1543.   *
    1544. 

  1544.   *    Rational(1)      #=> (1/1)
    1545. 

  1545.   *    Rational(2, 3)   #=> (2/3)
    1546. 

  1546.   *    Rational(4, -6)  #=> (-2/3)
    1547. 

  1547.   *    3.to_r           #=> (3/1)
    1548. 

  1548. + *    2/3r             #=> (2/3)
    1549. 

  1549.   *
    1550. 

  1550.   * You can also create rational object from floating-point numbers or
    1551. 

  1551.   * strings.
    1552. 

  1552. diff --git a/string.c b/string.c
    1553. 

  1553. index 2652b29..e6a5fb8 100644
    1554. 

  1554. --- a/string.c
    1555. 

  1555. +++ b/string.c
    1556. 

  1556. @@ -60,7 +60,7 @@ VALUE rb_cSymbol;
    1557. 

  1557.      FL_SET((str), STR_NOEMBED);\
    1558. 

  1558.      STR_SET_EMBED_LEN((str), 0);\
    1559. 

  1559.  } while (0)
    1560. 

  1560. -#define STR_SET_EMBED(str) FL_UNSET((str), STR_NOEMBED)
    1561. 

  1561. +#define STR_SET_EMBED(str) FL_UNSET((str), (STR_NOEMBED|STR_NOFREE))
    1562. 

  1562.  #define STR_SET_EMBED_LEN(str, n) do { \
    1563. 

  1563.      long tmp_n = (n);\
    1564. 

  1564.      RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\
    1565. 

  1565. @@ -4226,6 +4226,9 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
    1566. 

  1566.   *  double-quoted string, both back-references must be preceded by an
    1567. 

  1567.   *  additional backslash. However, within +replacement+ the special match
    1568. 

  1568.   *  variables, such as <code>&$</code>, will not refer to the current match.
    1569. 

  1569. + *  If +replacement+ is a String that looks like a pattern's capture group but
    1570. 

  1570. + *  is actaully not a pattern capture group e.g. <code>"\\'"</code>, then it
    1571. 

  1571. + *  will have to be preceded by two backslashes like so <code>"\\\\'"</code>.
    1572. 

  1572.   *
    1573. 

  1573.   *  If the second argument is a Hash, and the matched text is one of its keys,
    1574. 

  1574.   *  the corresponding value is the replacement string.
    1575. 

  1575. diff --git a/symbol.c b/symbol.c
    1576. 

  1576. index 1127020..696f017 100644
    1577. 

  1577. --- a/symbol.c
    1578. 

  1578. +++ b/symbol.c
    1579. 

  1579. @@ -122,7 +122,7 @@ static const struct st_hash_type symhash = {
    1580. 

  1580.  void
    1581. 

  1581.  Init_sym(void)
    1582. 

  1582.  {
    1583. 

  1583. -    VALUE dsym_fstrs = rb_hash_new();
    1584. 

  1584. +    VALUE dsym_fstrs = rb_ident_hash_new();
    1585. 

  1585.      global_symbols.dsymbol_fstr_hash = dsym_fstrs;
    1586. 

  1586.      rb_gc_register_mark_object(dsym_fstrs);
    1587. 

  1587.      rb_obj_hide(dsym_fstrs);
    1588. 

  1588. diff --git a/test/-ext-/string/test_nofree.rb b/test/-ext-/string/test_nofree.rb
    1589. 

  1589. new file mode 100644
    1590. 

  1590. index 0000000..234c84d
    1591. 

  1591. --- /dev/null
    1592. 

  1592. +++ b/test/-ext-/string/test_nofree.rb
    1593. 

  1593. @@ -0,0 +1,10 @@
    1594. 

  1594. +require 'test/unit'
    1595. 

  1595. +
    1596. 

  1596. +class Test_StringNoFree < Test::Unit::TestCase
    1597. 

  1597. +  def test_no_memory_leak
    1598. 

  1598. +    bug10942 = '[ruby-core:68436] [Bug #10942] no leak on nofree string'
    1599. 

  1599. +    assert_no_memory_leak(%w(-r-test-/string/string), '',
    1600. 

  1600. +                          '1000000.times {Bug::String.nofree << "a" * 100}',
    1601. 

  1601. +                          bug10942, rss: true, limit: 2.0)
    1602. 

  1602. +  end
    1603. 

  1603. +end
    1604. 

  1604. diff --git a/test/-ext-/symbol/test_inadvertent_creation.rb b/test/-ext-/symbol/test_inadvertent_creation.rb
    1605. 

  1605. index 4e7a85f..f772086 100644
    1606. 

  1606. --- a/test/-ext-/symbol/test_inadvertent_creation.rb
    1607. 

  1607. +++ b/test/-ext-/symbol/test_inadvertent_creation.rb
    1608. 

  1608. @@ -82,6 +82,28 @@ module Test_Symbol
    1609. 

  1609.        assert_not_interned_false(c, :class_variable_defined?, noninterned_name("@@"), feature5072)
    1610. 

  1610.      end
    1611. 

  1611.  
    1612. 

  1612. +    def test_missing_method
    1613. 

  1613. +      bug10985 = '[ruby-core:68564] [Bug #10985]'
    1614. 

  1614. +      m = nil
    1615. 

  1615. +      c = Class.new do
    1616. 

  1616. +        def self.respond_to_missing?(*)
    1617. 

  1617. +          true
    1618. 

  1618. +        end
    1619. 

  1619. +      end
    1620. 

  1620. +
    1621. 

  1621. +      s = noninterned_name
    1622. 

  1622. +      assert_nothing_raised(NameError, bug10985) {m = c.method(s)}
    1623. 

  1623. +      assert_raise_with_message(NoMethodError, /#{s}/) {m.call}
    1624. 

  1624. +
    1625. 

  1625. +      s = noninterned_name
    1626. 

  1626. +      assert_nothing_raised(NameError, bug10985) {m = c.public_method(s.to_sym)}
    1627. 

  1627. +      assert_raise_with_message(NoMethodError, /#{s}/) {m.call}
    1628. 

  1628. +
    1629. 

  1629. +      s = noninterned_name
    1630. 

  1630. +      assert_nothing_raised(NameError, bug10985) {m = c.singleton_method(s.to_sym)}
    1631. 

  1631. +      assert_raise_with_message(NoMethodError, /#{s}/) {m.call}
    1632. 

  1632. +    end
    1633. 

  1633. +
    1634. 

  1634.      Feature5079 = '[ruby-core:38404]'
    1635. 

  1635.  
    1636. 

  1636.      def test_undefined_instance_variable
    1637. 

  1637. diff --git a/test/fileutils/test_fileutils.rb b/test/fileutils/test_fileutils.rb
    1638. 

  1638. index fe9a1b3..295fbfd9 100644
    1639. 

  1639. --- a/test/fileutils/test_fileutils.rb
    1640. 

  1640. +++ b/test/fileutils/test_fileutils.rb
    1641. 

  1641. @@ -416,7 +416,8 @@ class TestFileUtils < Test::Unit::TestCase
    1642. 

  1642.  
    1643. 

  1643.      mkdir 'tmp/tmpdir'
    1644. 

  1644.      mkdir_p 'tmp/dest2/tmpdir'
    1645. 

  1645. -    assert_raise(Errno::EEXIST) {
    1646. 

  1646. +    assert_raise_with_message(Errno::EEXIST, %r' - tmp/dest2/tmpdir\z',
    1647. 

  1647. +                              '[ruby-core:68706] [Bug #11021]') {
    1648. 

  1648.        mv 'tmp/tmpdir', 'tmp/dest2'
    1649. 

  1649.      }
    1650. 

  1650.      mkdir 'tmp/dest2/tmpdir/junk'
    1651. 

  1651. diff --git a/test/net/imap/test_imap_response_parser.rb b/test/net/imap/test_imap_response_parser.rb
    1652. 

  1652. index ded7dd1..1612d78 100644
    1653. 

  1653. --- a/test/net/imap/test_imap_response_parser.rb
    1654. 

  1654. +++ b/test/net/imap/test_imap_response_parser.rb
    1655. 

  1655. @@ -276,4 +276,17 @@ EOF
    1656. 

  1656.      assert_equal("SEARCH", response.name)
    1657. 

  1657.      assert_equal([87216, 87221], response.data)
    1658. 

  1658.    end
    1659. 

  1659. +
    1660. 

  1660. +  # [Bug #11128]
    1661. 

  1661. +  def test_body_ext_mpart_without_lang
    1662. 

  1662. +    parser = Net::IMAP::ResponseParser.new
    1663. 

  1663. +    response = parser.parse("* 4 FETCH (BODY (((\"text\" \"plain\" (\"charset\" \"utf-8\") NIL NIL \"7bit\" 257 9 NIL NIL NIL NIL)(\"text\" \"html\" (\"charset\" \"utf-8\") NIL NIL \"quoted-printable\" 655 9 NIL NIL NIL NIL) \"alternative\" (\"boundary\" \"001a1137a5047848dd05157ddaa1\") NIL)(\"application\" \"pdf\" (\"name\" \"test.xml\" \"x-apple-part-url\" \"9D00D9A2-98AB-4EFB-85BA-FB255F8BF3D7\") NIL NIL \"base64\" 4383638 NIL (\"attachment\" (\"filename\" \"test.xml\")) NIL NIL) \"mixed\" (\"boundary\" \"001a1137a5047848e405157ddaa3\") NIL))\r\n")
    1664. 

  1664. +    assert_equal("FETCH", response.name)
    1665. 

  1665. +    body = response.data.attr["BODY"]
    1666. 

  1666. +    assert_equal(nil, body.parts[0].disposition)
    1667. 

  1667. +    assert_equal(nil, body.parts[0].language)
    1668. 

  1668. +    assert_equal("ATTACHMENT", body.parts[1].disposition.dsp_type)
    1669. 

  1669. +    assert_equal("test.xml", body.parts[1].disposition.param["FILENAME"])
    1670. 

  1670. +    assert_equal(nil, body.parts[1].language)
    1671. 

  1671. +  end
    1672. 

  1672.  end
    1673. 

  1673. diff --git a/test/resolv/test_dns.rb b/test/resolv/test_dns.rb
    1674. 

  1674. index 8e54dd7..d7e5c36 100644
    1675. 

  1675. --- a/test/resolv/test_dns.rb
    1676. 

  1676. +++ b/test/resolv/test_dns.rb
    1677. 

  1677. @@ -190,4 +190,11 @@ class TestResolvDNS < Test::Unit::TestCase
    1678. 

  1678.      upper = Resolv::DNS::Name.create("Ruby-Lang.org")
    1679. 

  1679.      assert_equal(lower, upper, bug10550)
    1680. 

  1680.    end
    1681. 

  1681. +
    1682. 

  1682. +  def test_ipv6_name
    1683. 

  1683. +    addr = Resolv::IPv6.new("\0"*16)
    1684. 

  1684. +    labels = addr.to_name.to_a
    1685. 

  1685. +    expected = (['0'] * 32 + ['ip6', 'arpa']).map {|label| Resolv::DNS::Label::Str.new(label) }
    1686. 

  1686. +    assert_equal(expected, labels)
    1687. 

  1687. +  end
    1688. 

  1688.  end
    1689. 

  1689. diff --git a/test/ruby/test_autoload.rb b/test/ruby/test_autoload.rb
    1690. 

  1690. index a95c274..da8855b 100644
    1691. 

  1691. --- a/test/ruby/test_autoload.rb
    1692. 

  1692. +++ b/test/ruby/test_autoload.rb
    1693. 

  1693. @@ -55,6 +55,32 @@ p Foo::Bar
    1694. 

  1694.      }
    1695. 

  1695.    end
    1696. 

  1696.  
    1697. 

  1697. +  def test_autoload_with_unqualified_file_name # [ruby-core:69206]
    1698. 

  1698. +    lp = $LOAD_PATH.dup
    1699. 

  1699. +    lf = $LOADED_FEATURES.dup
    1700. 

  1700. +
    1701. 

  1701. +    Dir.mktmpdir('autoload') { |tmpdir|
    1702. 

  1702. +      $LOAD_PATH << tmpdir
    1703. 

  1703. +
    1704. 

  1704. +      Dir.chdir(tmpdir) do
    1705. 

  1705. +        eval <<-END
    1706. 

  1706. +          class ::Object
    1707. 

  1707. +            module A
    1708. 

  1708. +              autoload :C, 'b'
    1709. 

  1709. +            end
    1710. 

  1710. +          end
    1711. 

  1711. +        END
    1712. 

  1712. +
    1713. 

  1713. +        File.open('b.rb', 'w') {|file| file.puts 'module A; class C; end; end'}
    1714. 

  1714. +        assert_kind_of Class, ::A::C
    1715. 

  1715. +      end
    1716. 

  1716. +    }
    1717. 

  1717. +  ensure
    1718. 

  1718. +    $LOAD_PATH.replace lp
    1719. 

  1719. +    $LOADED_FEATURES.replace lf
    1720. 

  1720. +    Object.send(:remove_const, :A) if Object.const_defined?(:A)
    1721. 

  1721. +  end
    1722. 

  1722. +
    1723. 

  1723.    def test_require_explicit
    1724. 

  1724.      Tempfile.create(['autoload', '.rb']) {|file|
    1725. 

  1725.        file.puts 'class Object; AutoloadTest = 1; end'
    1726. 

  1726. diff --git a/test/ruby/test_float.rb b/test/ruby/test_float.rb
    1727. 

  1727. index ac2d843..eab4d12 100644
    1728. 

  1728. --- a/test/ruby/test_float.rb
    1729. 

  1729. +++ b/test/ruby/test_float.rb
    1730. 

  1730. @@ -672,4 +672,12 @@ class TestFloat < Test::Unit::TestCase
    1731. 

  1731.      assert_equal(0.0, z)
    1732. 

  1732.      assert_equal(-Float::INFINITY, 1.0/z)
    1733. 

  1733.    end
    1734. 

  1734. +
    1735. 

  1735. +  def test_hash_0
    1736. 

  1736. +    bug10979 = '[ruby-core:68541] [Bug #10979]'
    1737. 

  1737. +    assert_equal(+0.0.hash, -0.0.hash)
    1738. 

  1738. +    assert_operator(+0.0, :eql?, -0.0)
    1739. 

  1739. +    h = {0.0 => bug10979}
    1740. 

  1740. +    assert_equal(bug10979, h[-0.0])
    1741. 

  1741. +  end
    1742. 

  1742.  end
    1743. 

  1743. diff --git a/test/ruby/test_iseq.rb b/test/ruby/test_iseq.rb
    1744. 

  1744. index 4af440a..686646d 100644
    1745. 

  1745. --- a/test/ruby/test_iseq.rb
    1746. 

  1746. +++ b/test/ruby/test_iseq.rb
    1747. 

  1747. @@ -134,4 +134,11 @@ class TestISeq < Test::Unit::TestCase
    1748. 

  1748.        assert(!op.to_s.match(/^opt_/), "#{op}")
    1749. 

  1749.      }
    1750. 

  1750.    end
    1751. 

  1751. +
    1752. 

  1752. +  def test_invalid_source
    1753. 

  1753. +    bug11159 = '[ruby-core:69219] [Bug #11159]'
    1754. 

  1754. +    assert_raise(TypeError, bug11159) {ISeq.compile(nil)}
    1755. 

  1755. +    assert_raise(TypeError, bug11159) {ISeq.compile(:foo)}
    1756. 

  1756. +    assert_raise(TypeError, bug11159) {ISeq.compile(1)}
    1757. 

  1757. +  end
    1758. 

  1758.  end
    1759. 

  1759. diff --git a/test/ruby/test_keyword.rb b/test/ruby/test_keyword.rb
    1760. 

  1760. index 70cdba1..9c76e15 100644
    1761. 

  1761. --- a/test/ruby/test_keyword.rb
    1762. 

  1762. +++ b/test/ruby/test_keyword.rb
    1763. 

  1763. @@ -566,4 +566,14 @@ class TestKeywordArguments < Test::Unit::TestCase
    1764. 

  1764.      result = m(["a" => 10]) { |a = nil, **b| [a, b] }
    1765. 

  1765.      assert_equal([{"a" => 10}, {}], result)
    1766. 

  1766.    end
    1767. 

  1767. +
    1768. 

  1768. +  def method_for_test_to_hash_call_during_setup_complex_parameters k1:, k2:, **rest_kw
    1769. 

  1769. +    [k1, k2, rest_kw]
    1770. 

  1770. +  end
    1771. 

  1771. +
    1772. 

  1772. +  def test_to_hash_call_during_setup_complex_parameters
    1773. 

  1773. +    sym = "sym_#{Time.now}".to_sym
    1774. 

  1774. +    h = method_for_test_to_hash_call_during_setup_complex_parameters k1: "foo", k2: "bar", sym => "baz"
    1775. 

  1775. +    assert_equal ["foo", "bar", {sym => "baz"}], h, '[Bug #11027]'
    1776. 

  1776. +  end
    1777. 

  1777.  end
    1778. 

  1778. diff --git a/test/ruby/test_marshal.rb b/test/ruby/test_marshal.rb
    1779. 

  1779. index 9b82d52..3d5d6c9 100644
    1780. 

  1780. --- a/test/ruby/test_marshal.rb
    1781. 

  1781. +++ b/test/ruby/test_marshal.rb
    1782. 

  1782. @@ -252,6 +252,17 @@ class TestMarshal < Test::Unit::TestCase
    1783. 

  1783.      assert_include(Marshal.dump([:a, :a]), ';')
    1784. 

  1784.    end
    1785. 

  1785.  
    1786. 

  1786. +  def test_symlink_in_ivar
    1787. 

  1787. +    bug10991 = '[ruby-core:68587] [Bug #10991]'
    1788. 

  1788. +    sym = Marshal.load("\x04\x08" +
    1789. 

  1789. +                       "I" ":\x0bKernel" +
    1790. 

  1790. +                       ("\x06" +
    1791. 

  1791. +                        ("I" ":\x07@a" +
    1792. 

  1792. +                         ("\x06" ":\x07@b" "e;\x0""o:\x0bObject""\x0")) +
    1793. 

  1793. +                        "0"))
    1794. 

  1794. +    assert_equal(:Kernel, sym, bug10991)
    1795. 

  1795. +  end
    1796. 

  1796. +
    1797. 

  1797.    ClassUTF8 = eval("class R\u{e9}sum\u{e9}; self; end")
    1798. 

  1798.  
    1799. 

  1799.    iso_8859_1 = Encoding::ISO_8859_1
    1800. 

  1800. diff --git a/test/ruby/test_method.rb b/test/ruby/test_method.rb
    1801. 

  1801. index c8b5ff1..35ddc87 100644
    1802. 

  1802. --- a/test/ruby/test_method.rb
    1803. 

  1803. +++ b/test/ruby/test_method.rb
    1804. 

  1804. @@ -877,4 +877,18 @@ class TestMethod < Test::Unit::TestCase
    1805. 

  1805.        obj.bar
    1806. 

  1806.      end
    1807. 

  1807.    end
    1808. 

  1808. +
    1809. 

  1809. +  def test_to_proc_binding
    1810. 

  1810. +    bug11012 = '[ruby-core:68673] [Bug #11012]'
    1811. 

  1811. +    class << (obj = Object.new)
    1812. 

  1812. +      src = 1000.times.map {|i|"v#{i} = nil"}.join("\n")
    1813. 

  1813. +      eval("def foo()\n""#{src}\n""end")
    1814. 

  1814. +    end
    1815. 

  1815. +
    1816. 

  1816. +    b = obj.method(:foo).to_proc.binding
    1817. 

  1817. +    b.local_variables.each_with_index {|n, i|
    1818. 

  1818. +      b.local_variable_set(n, i)
    1819. 

  1819. +    }
    1820. 

  1820. +    assert_equal([998, 999], %w[v998 v999].map {|n| b.local_variable_get(n)}, bug11012)
    1821. 

  1821. +  end
    1822. 

  1822.  end
    1823. 

  1823. diff --git a/test/ruby/test_range.rb b/test/ruby/test_range.rb
    1824. 

  1824. index f81047d..852515f 100644
    1825. 

  1825. --- a/test/ruby/test_range.rb
    1826. 

  1826. +++ b/test/ruby/test_range.rb
    1827. 

  1827. @@ -283,6 +283,14 @@ class TestRange < Test::Unit::TestCase
    1828. 

  1828.      assert_not_operator(0..10, :===, 11)
    1829. 

  1829.    end
    1830. 

  1830.  
    1831. 

  1831. +  def test_eqq_time
    1832. 

  1832. +    bug11113 = '[ruby-core:69052] [Bug #11113]'
    1833. 

  1833. +    t = Time.now
    1834. 

  1834. +    assert_nothing_raised(TypeError, bug11113) {
    1835. 

  1835. +      assert_operator(t..(t+10), :===, t+5)
    1836. 

  1836. +    }
    1837. 

  1837. +  end
    1838. 

  1838. +
    1839. 

  1839.    def test_include
    1840. 

  1840.      assert_include("a".."z", "c")
    1841. 

  1841.      assert_not_include("a".."z", "5")
    1842. 

  1842. diff --git a/test/ruby/test_rubyoptions.rb b/test/ruby/test_rubyoptions.rb
    1843. 

  1843. index 8d3da54..7cb1248 100644
    1844. 

  1844. --- a/test/ruby/test_rubyoptions.rb
    1845. 

  1845. +++ b/test/ruby/test_rubyoptions.rb
    1846. 

  1846. @@ -720,6 +720,14 @@ class TestRubyOptions < Test::Unit::TestCase
    1847. 

  1847.                            bug10555, encoding: "locale")
    1848. 

  1848.        end
    1849. 

  1849.      end
    1850. 

  1850. +
    1851. 

  1851. +    def test_command_line_glob_with_dir
    1852. 

  1852. +      bug10941 = '[ruby-core:68430] [Bug #10941]'
    1853. 

  1853. +      with_tmpchdir do |dir|
    1854. 

  1854. +        Dir.mkdir('test')
    1855. 

  1855. +        assert_in_out_err(["-e", "", "test/*"], "", [], [], bug10941)
    1856. 

  1856. +      end
    1857. 

  1857. +    end
    1858. 

  1858.    end
    1859. 

  1859.  
    1860. 

  1860.    if /mswin|mingw/ =~ RUBY_PLATFORM
    1861. 

  1861. diff --git a/test/ruby/test_settracefunc.rb b/test/ruby/test_settracefunc.rb
    1862. 

  1862. index 58e927c..1dcd2cc 100644
    1863. 

  1863. --- a/test/ruby/test_settracefunc.rb
    1864. 

  1864. +++ b/test/ruby/test_settracefunc.rb
    1865. 

  1865. @@ -1332,4 +1332,24 @@ class TestSetTraceFunc < Test::Unit::TestCase
    1866. 

  1866.      }
    1867. 

  1867.      assert_equal [__LINE__ - 3, __LINE__ - 2], lines, 'Bug #10449'
    1868. 

  1868.    end
    1869. 

  1869. +
    1870. 

  1870. +  class Bug10724
    1871. 

  1871. +    def initialize
    1872. 

  1872. +      loop{return}
    1873. 

  1873. +    end
    1874. 

  1874. +  end
    1875. 

  1875. +
    1876. 

  1876. +  def test_throwing_return_with_finish_frame
    1877. 

  1877. +    target_th = Thread.current
    1878. 

  1878. +    evs = []
    1879. 

  1879. +
    1880. 

  1880. +    TracePoint.new(:call, :return){|tp|
    1881. 

  1881. +      return if Thread.current != target_th
    1882. 

  1882. +      evs << tp.event
    1883. 

  1883. +    }.enable{
    1884. 

  1884. +      a = Bug10724.new
    1885. 

  1885. +    }
    1886. 

  1886. +
    1887. 

  1887. +    assert_equal([:call, :return], evs)
    1888. 

  1888. +  end
    1889. 

  1889.  end
    1890. 

  1890. diff --git a/test/ruby/test_symbol.rb b/test/ruby/test_symbol.rb
    1891. 

  1891. index 596f2b0..ee29cd5 100644
    1892. 

  1892. --- a/test/ruby/test_symbol.rb
    1893. 

  1893. +++ b/test/ruby/test_symbol.rb
    1894. 

  1894. @@ -199,6 +199,35 @@ class TestSymbol < Test::Unit::TestCase
    1895. 

  1895.      assert_raise(TypeError) { a = :foo; def a.foo; end }
    1896. 

  1896.    end
    1897. 

  1897.  
    1898. 

  1898. +  SymbolsForEval = [
    1899. 

  1899. +    :foo,
    1900. 

  1900. +    "dynsym_#{Random.rand(10000)}_#{Time.now}".to_sym
    1901. 

  1901. +  ]
    1902. 

  1902. +
    1903. 

  1903. +  def test_instance_eval
    1904. 

  1904. +    bug11086 = '[ruby-core:68961] [Bug #11086]'
    1905. 

  1905. +    SymbolsForEval.each do |sym|
    1906. 

  1906. +      assert_nothing_raised(TypeError, sym, bug11086) {
    1907. 

  1907. +        sym.instance_eval {}
    1908. 

  1908. +      }
    1909. 

  1909. +      assert_raise(TypeError, sym, bug11086) {
    1910. 

  1910. +        sym.instance_eval {def foo; end}
    1911. 

  1911. +      }
    1912. 

  1912. +    end
    1913. 

  1913. +  end
    1914. 

  1914. +
    1915. 

  1915. +  def test_instance_exec
    1916. 

  1916. +    bug11086 = '[ruby-core:68961] [Bug #11086]'
    1917. 

  1917. +    SymbolsForEval.each do |sym|
    1918. 

  1918. +      assert_nothing_raised(TypeError, sym, bug11086) {
    1919. 

  1919. +        sym.instance_exec {}
    1920. 

  1920. +      }
    1921. 

  1921. +      assert_raise(TypeError, sym, bug11086) {
    1922. 

  1922. +        sym.instance_exec {def foo; end}
    1923. 

  1923. +      }
    1924. 

  1924. +    end
    1925. 

  1925. +  end
    1926. 

  1926. +
    1927. 

  1927.    def test_frozen_symbol
    1928. 

  1928.      assert_equal(true, :foo.frozen?)
    1929. 

  1929.      assert_equal(true, :each.frozen?)
    1930. 

  1930. @@ -238,4 +267,23 @@ class TestSymbol < Test::Unit::TestCase
    1931. 

  1931.        200_000.times { |i| i.to_s.to_sym }
    1932. 

  1932.      end;
    1933. 

  1933.    end
    1934. 

  1934. +
    1935. 

  1935. +  def test_hash_redefinition
    1936. 

  1936. +    assert_separately([], <<-'end;')
    1937. 

  1937. +      bug11035 = '[ruby-core:68767] [Bug #11035]'
    1938. 

  1938. +      class Symbol
    1939. 

  1939. +        def hash
    1940. 

  1940. +          raise
    1941. 

  1941. +        end
    1942. 

  1942. +      end
    1943. 

  1943. +
    1944. 

  1944. +      h = {}
    1945. 

  1945. +      assert_nothing_raised(RuntimeError, bug11035) {
    1946. 

  1946. +        h[:foo] = 1
    1947. 

  1947. +      }
    1948. 

  1948. +      assert_nothing_raised(RuntimeError, bug11035) {
    1949. 

  1949. +        h['bar'.to_sym] = 2
    1950. 

  1950. +      }
    1951. 

  1951. +    end;
    1952. 

  1952. +  end
    1953. 

  1953.  end
    1954. 

  1954. diff --git a/test/ruby/test_syntax.rb b/test/ruby/test_syntax.rb
    1955. 

  1955. index 0274a11..dbb1816 100644
    1956. 

  1956. --- a/test/ruby/test_syntax.rb
    1957. 

  1957. +++ b/test/ruby/test_syntax.rb
    1958. 

  1958. @@ -400,6 +400,11 @@ WARN
    1959. 

  1959.      assert_valid_syntax("bar def foo; self.each do end end", bug9308)
    1960. 

  1960.    end
    1961. 

  1961.  
    1962. 

  1962. +  def test_do_block_in_lambda
    1963. 

  1963. +    bug11107 = '[ruby-core:69017] [Bug #11107]'
    1964. 

  1964. +    assert_valid_syntax('p ->() do a() do end end', bug11107)
    1965. 

  1965. +  end
    1966. 

  1966. +
    1967. 

  1967.    def test_reserved_method_no_args
    1968. 

  1968.      bug6403 = '[ruby-dev:45626]'
    1969. 

  1969.      assert_valid_syntax("def self; :foo; end", __FILE__, bug6403)
    1970. 

  1970. diff --git a/test/socket/test_addrinfo.rb b/test/socket/test_addrinfo.rb
    1971. 

  1971. index 61b889e..96e1991 100644
    1972. 

  1972. --- a/test/socket/test_addrinfo.rb
    1973. 

  1973. +++ b/test/socket/test_addrinfo.rb
    1974. 

  1974. @@ -468,6 +468,17 @@ class TestSocketAddrinfo < Test::Unit::TestCase
    1975. 

  1975.      assert_equal(ai1.canonname, ai2.canonname)
    1976. 

  1976.    end
    1977. 

  1977.  
    1978. 

  1978. +  def test_marshal_memory_leak
    1979. 

  1979. +    bug11051 = '[ruby-dev:48923] [Bug #11051]'
    1980. 

  1980. +    assert_no_memory_leak(%w[-rsocket], <<-PREP, <<-CODE, bug11051, rss: true, limit: 2.0)
    1981. 

  1981. +    d = Marshal.dump(Addrinfo.tcp("127.0.0.1", 80))
    1982. 

  1982. +    1000.times {Marshal.load(d)}
    1983. 

  1983. +    PREP
    1984. 

  1984. +    GC.start
    1985. 

  1985. +    20_000.times {Marshal.load(d)}
    1986. 

  1986. +    CODE
    1987. 

  1987. +  end
    1988. 

  1988. +
    1989. 

  1989.    if Socket.const_defined?("AF_INET6") && Socket::AF_INET6.is_a?(Integer)
    1990. 

  1990.  
    1991. 

  1991.      def test_addrinfo_new_inet6
    1992. 

  1992. diff --git a/thread_pthread.c b/thread_pthread.c
    1993. 

  1993. index 711e60b..5fcad19 100644
    1994. 

  1994. --- a/thread_pthread.c
    1995. 

  1995. +++ b/thread_pthread.c
    1996. 

  1996. @@ -662,11 +662,16 @@ reserve_stack(volatile char *limit, size_t size)
    1997. 

  1997.  # endif
    1998. 

  1998.      struct rlimit rl;
    1999. 

  1999.      volatile char buf[0x100];
    2000. 

  2000. +    enum {stack_check_margin = 0x1000}; /* for -fstack-check */
    2001. 

  2001. +
    2002. 

  2002.      STACK_GROW_DIR_DETECTION;
    2003. 

  2003.  
    2004. 

  2004.      if (!getrlimit(RLIMIT_STACK, &rl) && rl.rlim_cur == RLIM_INFINITY)
    2005. 

  2005.  	return;
    2006. 

  2006.  
    2007. 

  2007. +    if (size < stack_check_margin) return;
    2008. 

  2008. +    size -= stack_check_margin;
    2009. 

  2009. +
    2010. 

  2010.      size -= sizeof(buf); /* margin */
    2011. 

  2011.      if (IS_STACK_DIR_UPPER()) {
    2012. 

  2012.  	const volatile char *end = buf + sizeof(buf);
    2013. 

  2013. @@ -674,13 +679,14 @@ reserve_stack(volatile char *limit, size_t size)
    2014. 

  2014.  	if (limit > end) {
    2015. 

  2015.  	    size = limit - end;
    2016. 

  2016.  	    limit = alloca(size);
    2017. 

  2017. -	    limit[size-1] = 0;
    2018. 

  2018. +	    limit[stack_check_margin+size-1] = 0;
    2019. 

  2019.  	}
    2020. 

  2020.      }
    2021. 

  2021.      else {
    2022. 

  2022.  	limit -= size;
    2023. 

  2023.  	if (buf > limit) {
    2024. 

  2024.  	    limit = alloca(buf - limit);
    2025. 

  2025. +	    limit -= stack_check_margin;
    2026. 

  2026.  	    limit[0] = 0;
    2027. 

  2027.  	}
    2028. 

  2028.      }
    2029. 

  2029. diff --git a/version.h b/version.h
    2030. 

  2030. index 6766b31..e5f8480 100644
    2031. 

  2031. --- a/version.h
    2032. 

  2032. +++ b/version.h
    2033. 

  2033. @@ -1,10 +1,10 @@
    2034. 

  2034.  #define RUBY_VERSION "2.2.2"
    2035. 

  2035. -#define RUBY_RELEASE_DATE "2015-04-13"
    2036. 

  2036. -#define RUBY_PATCHLEVEL 95
    2037. 

  2037. +#define RUBY_RELEASE_DATE "2015-06-12"
    2038. 

  2038. +#define RUBY_PATCHLEVEL 133
    2039. 

  2039.  
    2040. 

  2040.  #define RUBY_RELEASE_YEAR 2015
    2041. 

  2041. -#define RUBY_RELEASE_MONTH 4
    2042. 

  2042. -#define RUBY_RELEASE_DAY 13
    2043. 

  2043. +#define RUBY_RELEASE_MONTH 6
    2044. 

  2044. +#define RUBY_RELEASE_DAY 12
    2045. 

  2045.  
    2046. 

  2046.  #include "ruby/version.h"
    2047. 

  2047.  
    2048. 

  2048. diff --git a/vm.c b/vm.c
    2049. 

  2049. index e6ef3a8..17f3c53 100644
    2050. 

  2050. --- a/vm.c
    2051. 

  2051. +++ b/vm.c
    2052. 

  2052. @@ -380,7 +380,7 @@ env_mark(void * const ptr)
    2053. 

  2053.      RUBY_MARK_UNLESS_NULL(env->block.proc);
    2054. 

  2054.  
    2055. 

  2055.      if (env->block.iseq) {
    2056. 

  2056. -	if (BUILTIN_TYPE(env->block.iseq) == T_NODE) {
    2057. 

  2057. +	if (RUBY_VM_IFUNC_P(env->block.iseq)) {
    2058. 

  2058.  	    RUBY_MARK_UNLESS_NULL((VALUE)env->block.iseq);
    2059. 

  2059.  	}
    2060. 

  2060.  	else {
    2061. 

  2061. @@ -768,7 +768,7 @@ invoke_block_from_c(rb_thread_t *th, const rb_block_t *block,
    2062. 

  2062.      if (SPECIAL_CONST_P(block->iseq)) {
    2063. 

  2063.  	return Qnil;
    2064. 

  2064.      }
    2065. 

  2065. -    else if (BUILTIN_TYPE(block->iseq) != T_NODE) {
    2066. 

  2066. +    else if (!RUBY_VM_IFUNC_P(block->iseq)) {
    2067. 

  2067.  	VALUE ret;
    2068. 

  2068.  	const rb_iseq_t *iseq = block->iseq;
    2069. 

  2069.  	const rb_control_frame_t *cfp;
    2070. 

  2070. @@ -1287,6 +1287,30 @@ vm_frametype_name(const rb_control_frame_t *cfp)
    2071. 

  2071.  }
    2072. 

  2072.  #endif
    2073. 

  2073.  
    2074. 

  2074. +static void
    2075. 

  2075. +hook_before_rewind(rb_thread_t *th, rb_control_frame_t *cfp)
    2076. 

  2076. +{
    2077. 

  2077. +    switch (VM_FRAME_TYPE(th->cfp)) {
    2078. 

  2078. +      case VM_FRAME_MAGIC_METHOD:
    2079. 

  2079. +	RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0);
    2080. 

  2080. +	EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, 0, 0, Qnil);
    2081. 

  2081. +	break;
    2082. 

  2082. +      case VM_FRAME_MAGIC_BLOCK:
    2083. 

  2083. +      case VM_FRAME_MAGIC_LAMBDA:
    2084. 

  2084. +	if (VM_FRAME_TYPE_BMETHOD_P(th->cfp)) {
    2085. 

  2085. +	    EXEC_EVENT_HOOK(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil);
    2086. 

  2086. +	    EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, th->cfp->me->called_id, th->cfp->me->klass, Qnil);
    2087. 

  2087. +	}
    2088. 

  2088. +	else {
    2089. 

  2089. +	    EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil);
    2090. 

  2090. +	}
    2091. 

  2091. +	break;
    2092. 

  2092. +      case VM_FRAME_MAGIC_CLASS:
    2093. 

  2093. +	EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_END, th->cfp->self, 0, 0, Qnil);
    2094. 

  2094. +	break;
    2095. 

  2095. +    }
    2096. 

  2096. +}
    2097. 

  2097. +
    2098. 

  2098.  /* evaluator body */
    2099. 

  2099.  
    2100. 

  2100.  /*                  finish
    2101. 

  2101. @@ -1385,7 +1409,6 @@ vm_frametype_name(const rb_control_frame_t *cfp)
    2102. 

  2102.    };
    2103. 

  2103.   */
    2104. 

  2104.  
    2105. 

  2105. -
    2106. 

  2106.  static VALUE
    2107. 

  2107.  vm_exec(rb_thread_t *th)
    2108. 

  2108.  {
    2109. 

  2109. @@ -1455,15 +1478,9 @@ vm_exec(rb_thread_t *th)
    2110. 

  2110.  			    }
    2111. 

  2111.  			}
    2112. 

  2112.  			if (!catch_iseqval) {
    2113. 

  2113. -			    result = GET_THROWOBJ_VAL(err);
    2114. 

  2114.  			    th->errinfo = Qnil;
    2115. 

  2115. -
    2116. 

  2116. -			    switch (VM_FRAME_TYPE(cfp)) {
    2117. 

  2117. -			      case VM_FRAME_MAGIC_LAMBDA:
    2118. 

  2118. -				EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil);
    2119. 

  2119. -				break;
    2120. 

  2120. -			    }
    2121. 

  2121. -
    2122. 

  2122. +			    result = GET_THROWOBJ_VAL(err);
    2123. 

  2123. +			    hook_before_rewind(th, th->cfp);
    2124. 

  2124.  			    vm_pop_frame(th);
    2125. 

  2125.  			    goto finish_vme;
    2126. 

  2126.  			}
    2127. 

  2127. @@ -1606,26 +1623,7 @@ vm_exec(rb_thread_t *th)
    2128. 

  2128.  	}
    2129. 

  2129.  	else {
    2130. 

  2130.  	    /* skip frame */
    2131. 

  2131. -
    2132. 

  2132. -	    switch (VM_FRAME_TYPE(th->cfp)) {
    2133. 

  2133. -	      case VM_FRAME_MAGIC_METHOD:
    2134. 

  2134. -		RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0);
    2135. 

  2135. -		EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, 0, 0, Qnil);
    2136. 

  2136. -		break;
    2137. 

  2137. -	      case VM_FRAME_MAGIC_BLOCK:
    2138. 

  2138. -	      case VM_FRAME_MAGIC_LAMBDA:
    2139. 

  2139. -		if (VM_FRAME_TYPE_BMETHOD_P(th->cfp)) {
    2140. 

  2140. -		    EXEC_EVENT_HOOK(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil);
    2141. 

  2141. -		    EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, th->cfp->me->called_id, th->cfp->me->klass, Qnil);
    2142. 

  2142. -		}
    2143. 

  2143. -		else {
    2144. 

  2144. -		    EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil);
    2145. 

  2145. -		}
    2146. 

  2146. -		break;
    2147. 

  2147. -	      case VM_FRAME_MAGIC_CLASS:
    2148. 

  2148. -		EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_END, th->cfp->self, 0, 0, Qnil);
    2149. 

  2149. -		break;
    2150. 

  2150. -	    }
    2151. 

  2151. +	    hook_before_rewind(th, th->cfp);
    2152. 

  2152.  
    2153. 

  2153.  	    if (VM_FRAME_TYPE_FINISH_P(th->cfp)) {
    2154. 

  2154.  		vm_pop_frame(th);
    2155. 

  2155. @@ -2015,7 +2013,6 @@ rb_thread_mark(void *ptr)
    2156. 

  2156.  	    rb_control_frame_t *limit_cfp = (void *)(th->stack + th->stack_size);
    2157. 

  2157.  
    2158. 

  2158.  	    rb_gc_mark_values((long)(sp - p), p);
    2159. 

  2159. -	    rb_gc_mark_locations(sp, sp + th->mark_stack_len);
    2160. 

  2160.  
    2161. 

  2161.  	    while (cfp != limit_cfp) {
    2162. 

  2162.  		rb_iseq_t *iseq = cfp->iseq;
    2163. 

  2163. diff --git a/vm_args.c b/vm_args.c
    2164. 

  2164. index 446ad48..abdd161 100644
    2165. 

  2165. --- a/vm_args.c
    2166. 

  2166. +++ b/vm_args.c
    2167. 

  2167. @@ -83,19 +83,17 @@ args_reduce(struct args_info *args, int over_argc)
    2168. 

  2168.  }
    2169. 

  2169.  
    2170. 

  2170.  static inline int
    2171. 

  2171. -args_check_block_arg0(struct args_info *args, rb_thread_t *th, const int msl)
    2172. 

  2172. +args_check_block_arg0(struct args_info *args, rb_thread_t *th)
    2173. 

  2173.  {
    2174. 

  2174.      VALUE ary = Qnil;
    2175. 

  2175.  
    2176. 

  2176.      if (args->rest && RARRAY_LEN(args->rest) == 1) {
    2177. 

  2177.  	VALUE arg0 = RARRAY_AREF(args->rest, 0);
    2178. 

  2178.  	ary = rb_check_array_type(arg0);
    2179. 

  2179. -	th->mark_stack_len = msl;
    2180. 

  2180.      }
    2181. 

  2181.      else if (args->argc == 1) {
    2182. 

  2182.  	VALUE arg0 = args->argv[0];
    2183. 

  2183.  	ary = rb_check_array_type(arg0);
    2184. 

  2184. -	th->mark_stack_len = msl;
    2185. 

  2185.  	args->argv[0] = arg0; /* see: https://bugs.ruby-lang.org/issues/8484 */
    2186. 

  2186.      }
    2187. 

  2187.  
    2188. 

  2188. @@ -173,10 +171,9 @@ args_rest_array(struct args_info *args)
    2189. 

  2189.  }
    2190. 

  2190.  
    2191. 

  2191.  static int
    2192. 

  2192. -keyword_hash_p(VALUE *kw_hash_ptr, VALUE *rest_hash_ptr, rb_thread_t *th, const int msl)
    2193. 

  2193. +keyword_hash_p(VALUE *kw_hash_ptr, VALUE *rest_hash_ptr, rb_thread_t *th)
    2194. 

  2194.  {
    2195. 

  2195.      *rest_hash_ptr = rb_check_hash_type(*kw_hash_ptr);
    2196. 

  2196. -    th->mark_stack_len = msl;
    2197. 

  2197.  
    2198. 

  2198.      if (!NIL_P(*rest_hash_ptr)) {
    2199. 

  2199.  	VALUE hash = rb_extract_keywords(rest_hash_ptr);
    2200. 

  2200. @@ -191,7 +188,7 @@ keyword_hash_p(VALUE *kw_hash_ptr, VALUE *rest_hash_ptr, rb_thread_t *th, const
    2201. 

  2201.  }
    2202. 

  2202.  
    2203. 

  2203.  static VALUE
    2204. 

  2204. -args_pop_keyword_hash(struct args_info *args, VALUE *kw_hash_ptr, rb_thread_t *th, const int msl)
    2205. 

  2205. +args_pop_keyword_hash(struct args_info *args, VALUE *kw_hash_ptr, rb_thread_t *th)
    2206. 

  2206.  {
    2207. 

  2207.      VALUE rest_hash;
    2208. 

  2208.  
    2209. 

  2209. @@ -200,7 +197,7 @@ args_pop_keyword_hash(struct args_info *args, VALUE *kw_hash_ptr, rb_thread_t *t
    2210. 

  2210.  	assert(args->argc > 0);
    2211. 

  2211.  	*kw_hash_ptr = args->argv[args->argc-1];
    2212. 

  2212.  
    2213. 

  2213. -	if (keyword_hash_p(kw_hash_ptr, &rest_hash, th, msl)) {
    2214. 

  2214. +	if (keyword_hash_p(kw_hash_ptr, &rest_hash, th)) {
    2215. 

  2215.  	    if (rest_hash) {
    2216. 

  2216.  		args->argv[args->argc-1] = rest_hash;
    2217. 

  2217.  	    }
    2218. 

  2218. @@ -216,7 +213,7 @@ args_pop_keyword_hash(struct args_info *args, VALUE *kw_hash_ptr, rb_thread_t *t
    2219. 

  2219.  	if (len > 0) {
    2220. 

  2220.  	    *kw_hash_ptr = RARRAY_AREF(args->rest, len - 1);
    2221. 

  2221.  
    2222. 

  2222. -	    if (keyword_hash_p(kw_hash_ptr, &rest_hash, th, msl)) {
    2223. 

  2223. +	    if (keyword_hash_p(kw_hash_ptr, &rest_hash, th)) {
    2224. 

  2224.  		if (rest_hash) {
    2225. 

  2225.  		    RARRAY_ASET(args->rest, len - 1, rest_hash);
    2226. 

  2226.  		}
    2227. 

  2227. @@ -511,9 +508,27 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
    2228. 

  2228.      int given_argc;
    2229. 

  2229.      struct args_info args_body, *args;
    2230. 

  2230.      VALUE keyword_hash = Qnil;
    2231. 

  2231. -    const int msl = ci->argc + iseq->param.size;
    2232. 

  2232. +    VALUE * const orig_sp = th->cfp->sp;
    2233. 

  2233. +    int i;
    2234. 

  2234.  
    2235. 

  2235. -    th->mark_stack_len = msl;
    2236. 

  2236. +    /*
    2237. 

  2237. +     * Extend SP for GC.
    2238. 

  2238. +     *
    2239. 

  2239. +     * [pushed values] [uninitialized values]
    2240. 

  2240. +     * <- ci->argc -->
    2241. 

  2241. +     * <- iseq->param.size------------------>
    2242. 

  2242. +     * ^ locals        ^ sp
    2243. 

  2243. +     *
    2244. 

  2244. +     * =>
    2245. 

  2245. +     * [pushed values] [initialized values  ]
    2246. 

  2246. +     * <- ci->argc -->
    2247. 

  2247. +     * <- iseq->param.size------------------>
    2248. 

  2248. +     * ^ locals                             ^ sp
    2249. 

  2249. +     */
    2250. 

  2250. +    for (i=ci->argc; i<iseq->param.size; i++) {
    2251. 

  2251. +	locals[i] = Qnil;
    2252. 

  2252. +    }
    2253. 

  2253. +    th->cfp->sp = &locals[i];
    2254. 

  2254.  
    2255. 

  2255.      /* setup args */
    2256. 

  2256.      args = &args_body;
    2257. 

  2257. @@ -556,7 +571,7 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
    2258. 

  2258.  	    (min_argc > 0 || iseq->param.opt_num > 1 ||
    2259. 

  2259.  	     iseq->param.flags.has_kw || iseq->param.flags.has_kwrest) &&
    2260. 

  2260.  	    !iseq->param.flags.ambiguous_param0 &&
    2261. 

  2261. -	    args_check_block_arg0(args, th, msl)) {
    2262. 

  2262. +	    args_check_block_arg0(args, th)) {
    2263. 

  2263.  	    given_argc = RARRAY_LENINT(args->rest);
    2264. 

  2264.  	}
    2265. 

  2265.  	break;
    2266. 

  2266. @@ -564,7 +579,7 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
    2267. 

  2267.  	if (given_argc == 1 &&
    2268. 

  2268.  	    given_argc != iseq->param.lead_num &&
    2269. 

  2269.  	    !iseq->param.flags.has_rest &&
    2270. 

  2270. -	    args_check_block_arg0(args, th, msl)) {
    2271. 

  2271. +	    args_check_block_arg0(args, th)) {
    2272. 

  2272.  	    given_argc = RARRAY_LENINT(args->rest);
    2273. 

  2273.  	}
    2274. 

  2274.      }
    2275. 

  2275. @@ -590,7 +605,7 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
    2276. 

  2276.      if (given_argc > min_argc &&
    2277. 

  2277.  	(iseq->param.flags.has_kw || iseq->param.flags.has_kwrest) &&
    2278. 

  2278.  	args->kw_argv == NULL) {
    2279. 

  2279. -	if (args_pop_keyword_hash(args, &keyword_hash, th, msl)) {
    2280. 

  2280. +	if (args_pop_keyword_hash(args, &keyword_hash, th)) {
    2281. 

  2281.  	    given_argc--;
    2282. 

  2282.  	}
    2283. 

  2283.      }
    2284. 

  2284. @@ -662,8 +677,7 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
    2285. 

  2285.      }
    2286. 

  2286.  #endif
    2287. 

  2287.  
    2288. 

  2288. -    th->mark_stack_len = 0;
    2289. 

  2289. -
    2290. 

  2290. +    th->cfp->sp = orig_sp;
    2291. 

  2291.      return opt_pc;
    2292. 

  2292.  }
    2293. 

  2293.  
    2294. 

  2294. diff --git a/vm_core.h b/vm_core.h
    2295. 

  2295. index 3eb1b85..9079130 100644
    2296. 

  2296. --- a/vm_core.h
    2297. 

  2297. +++ b/vm_core.h
    2298. 

  2298. @@ -642,7 +642,6 @@ typedef struct rb_thread_struct {
    2299. 

  2299.      enum rb_thread_status status;
    2300. 

  2300.      int to_kill;
    2301. 

  2301.      int priority;
    2302. 

  2302. -    int mark_stack_len;
    2303. 

  2303.  
    2304. 

  2304.      native_thread_data_t native_thread_data;
    2305. 

  2305.      void *blocking_region_buffer;
    2306. 

  2306. @@ -913,7 +912,7 @@ rb_block_t *rb_vm_control_frame_block_ptr(rb_control_frame_t *cfp);
    2307. 

  2307.  #define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
    2308. 

  2308.    (!RUBY_VM_VALID_CONTROL_FRAME_P((cfp), RUBY_VM_END_CONTROL_FRAME(th)))
    2309. 

  2309.  
    2310. 

  2310. -#define RUBY_VM_IFUNC_P(ptr)        (BUILTIN_TYPE(ptr) == T_NODE)
    2311. 

  2311. +#define RUBY_VM_IFUNC_P(ptr)        RB_TYPE_P((VALUE)(ptr), T_NODE)
    2312. 

  2312.  #define RUBY_VM_NORMAL_ISEQ_P(ptr) \
    2313. 

  2313.    ((ptr) && !RUBY_VM_IFUNC_P(ptr))
    2314. 

  2314.  
    2315. 

  2315. diff --git a/vm_dump.c b/vm_dump.c
    2316. 

  2316. index da2e6a9..a8d4875 100644
    2317. 

  2317. --- a/vm_dump.c
    2318. 

  2318. +++ b/vm_dump.c
    2319. 

  2319. @@ -36,7 +36,7 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
    2320. 

  2320.      const char *magic, *iseq_name = "-", *selfstr = "-", *biseq_name = "-";
    2321. 

  2321.      VALUE tmp;
    2322. 

  2322.  
    2323. 

  2323. -    if (cfp->block_iseq != 0 && BUILTIN_TYPE(cfp->block_iseq) != T_NODE) {
    2324. 

  2324. +    if (cfp->block_iseq != 0 && !RUBY_VM_IFUNC_P(cfp->block_iseq)) {
    2325. 

  2325.  	biseq_name = "";	/* RSTRING(cfp->block_iseq->location.label)->ptr; */
    2326. 

  2326.      }
    2327. 

  2327.  
    2328. 

  2328. @@ -735,7 +735,11 @@ procstat_vm(struct procstat *procstat, struct kinfo_proc *kipp)
    2329. 

  2329.  		ptrwidth, "START", ptrwidth, "END", "PRT", "RES",
    2330. 

  2330.  		"PRES", "REF", "SHD", "FL", "TP", "PATH");
    2331. 

  2331.  
    2332. 

  2332. +#ifdef HAVE_PROCSTAT_GETVMMAP
    2333. 

  2333.  	freep = procstat_getvmmap(procstat, kipp, &cnt);
    2334. 

  2334. +#else
    2335. 

  2335. +	freep = kinfo_getvmmap(kipp->ki_pid, &cnt);
    2336. 

  2336. +#endif
    2337. 

  2337.  	if (freep == NULL)
    2338. 

  2338.  		return;
    2339. 

  2339.  	for (i = 0; i < cnt; i++) {
    2340. 

  2340. diff --git a/vm_eval.c b/vm_eval.c
    2341. 

  2341. index 2bdf63b..bcd455b 100644
    2342. 

  2342. --- a/vm_eval.c
    2343. 

  2343. +++ b/vm_eval.c
    2344. 

  2344. @@ -1629,6 +1629,20 @@ specific_eval(int argc, const VALUE *argv, VALUE klass, VALUE self)
    2345. 

  2345.      }
    2346. 

  2346.  }
    2347. 

  2347.  
    2348. 

  2348. +static VALUE
    2349. 

  2349. +singleton_class_for_eval(VALUE self)
    2350. 

  2350. +{
    2351. 

  2351. +    if (SPECIAL_CONST_P(self)) {
    2352. 

  2352. +	return rb_special_singleton_class(self);
    2353. 

  2353. +    }
    2354. 

  2354. +    switch (BUILTIN_TYPE(self)) {
    2355. 

  2355. +      case T_FLOAT: case T_BIGNUM: case T_SYMBOL:
    2356. 

  2356. +	return Qnil;
    2357. 

  2357. +      default:
    2358. 

  2358. +	return rb_singleton_class(self);
    2359. 

  2359. +    }
    2360. 

  2360. +}
    2361. 

  2361. +
    2362. 

  2362.  /*
    2363. 

  2363.   *  call-seq:
    2364. 

  2364.   *     obj.instance_eval(string [, filename [, lineno]] )   -> obj
    2365. 

  2365. @@ -1665,14 +1679,7 @@ specific_eval(int argc, const VALUE *argv, VALUE klass, VALUE self)
    2366. 

  2366.  VALUE
    2367. 

  2367.  rb_obj_instance_eval(int argc, const VALUE *argv, VALUE self)
    2368. 

  2368.  {
    2369. 

  2369. -    VALUE klass;
    2370. 

  2370. -
    2371. 

  2371. -    if (SPECIAL_CONST_P(self)) {
    2372. 

  2372. -	klass = rb_special_singleton_class(self);
    2373. 

  2373. -    }
    2374. 

  2374. -    else {
    2375. 

  2375. -	klass = rb_singleton_class(self);
    2376. 

  2376. -    }
    2377. 

  2377. +    VALUE klass = singleton_class_for_eval(self);
    2378. 

  2378.      return specific_eval(argc, argv, klass, self);
    2379. 

  2379.  }
    2380. 

  2380.  
    2381. 

  2381. @@ -1697,14 +1704,7 @@ rb_obj_instance_eval(int argc, const VALUE *argv, VALUE self)
    2382. 

  2382.  VALUE
    2383. 

  2383.  rb_obj_instance_exec(int argc, const VALUE *argv, VALUE self)
    2384. 

  2384.  {
    2385. 

  2385. -    VALUE klass;
    2386. 

  2386. -
    2387. 

  2387. -    if (SPECIAL_CONST_P(self)) {
    2388. 

  2388. -	klass = rb_special_singleton_class(self);
    2389. 

  2389. -    }
    2390. 

  2390. -    else {
    2391. 

  2391. -	klass = rb_singleton_class(self);
    2392. 

  2392. -    }
    2393. 

  2393. +    VALUE klass = singleton_class_for_eval(self);
    2394. 

  2394.      return yield_under(klass, self, rb_ary_new4(argc, argv));
    2395. 

  2395.  }
    2396. 

  2396.  
    2397. 

  2397. diff --git a/vm_insnhelper.c b/vm_insnhelper.c
    2398. 

  2398. index 21c60af..8b2f8e7 100644
    2399. 

  2399. --- a/vm_insnhelper.c
    2400. 

  2400. +++ b/vm_insnhelper.c
    2401. 

  2401. @@ -630,13 +630,11 @@ vm_throw_start(rb_thread_t * const th, rb_control_frame_t * const reg_cfp, int s
    2402. 

  2402.  	rb_iseq_t *base_iseq = GET_ISEQ();
    2403. 

  2403.  	escape_cfp = reg_cfp;
    2404. 

  2404.  
    2405. 

  2405. -      search_parent:
    2406. 

  2406. -	if (base_iseq->type != ISEQ_TYPE_BLOCK) {
    2407. 

  2407. +	while (base_iseq->type != ISEQ_TYPE_BLOCK) {
    2408. 

  2408.  	    if (escape_cfp->iseq->type == ISEQ_TYPE_CLASS) {
    2409. 

  2409.  		escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
    2410. 

  2410.  		ep = escape_cfp->ep;
    2411. 

  2411.  		base_iseq = escape_cfp->iseq;
    2412. 

  2412. -		goto search_parent;
    2413. 

  2413.  	    }
    2414. 

  2414.  	    else {
    2415. 

  2415.  		ep = VM_EP_PREV_EP(ep);
    2416. 

  2416. @@ -2073,7 +2071,7 @@ vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci
    2417. 

  2417.      }
    2418. 

  2418.      iseq = block->iseq;
    2419. 

  2419.  
    2420. 

  2420. -    if (BUILTIN_TYPE(iseq) != T_NODE) {
    2421. 

  2421. +    if (!RUBY_VM_IFUNC_P(iseq)) {
    2422. 

  2422.  	int opt_pc;
    2423. 

  2423.  	const int arg_size = iseq->param.size;
    2424. 

  2424.  	int is_lambda = block_proc_is_lambda(block->proc);
    2425. 

  2425. diff --git a/win32/win32.c b/win32/win32.c
    2426. 

  2426. index b7d7e32..fc2c99e 100644
    2427. 

  2427. --- a/win32/win32.c
    2428. 

  2428. +++ b/win32/win32.c
    2429. 

  2429. @@ -6318,12 +6318,16 @@ rb_w32_close(int fd)
    2430. 

  2430.  }
    2431. 

  2431.  
    2432. 

  2432.  static int
    2433. 

  2433. -setup_overlapped(OVERLAPPED *ol, int fd)
    2434. 

  2434. +setup_overlapped(OVERLAPPED *ol, int fd, int iswrite)
    2435. 

  2435.  {
    2436. 

  2436.      memset(ol, 0, sizeof(*ol));
    2437. 

  2437.      if (!(_osfile(fd) & (FDEV | FPIPE))) {
    2438. 

  2438.  	LONG high = 0;
    2439. 

  2439. -	DWORD method = _osfile(fd) & FAPPEND ? FILE_END : FILE_CURRENT;
    2440. 

  2440. +	/* On mode:a, it can write only FILE_END.
    2441. 

  2441. +	 * On mode:a+, though it can write only FILE_END,
    2442. 

  2442. +	 * it can read from everywhere.
    2443. 

  2443. +	 */
    2444. 

  2444. +	DWORD method = ((_osfile(fd) & FAPPEND) && iswrite) ? FILE_END : FILE_CURRENT;
    2445. 

  2445.  	DWORD low = SetFilePointer((HANDLE)_osfhnd(fd), 0, &high, method);
    2446. 

  2446.  #ifndef INVALID_SET_FILE_POINTER
    2447. 

  2447.  #define INVALID_SET_FILE_POINTER ((DWORD)-1)
    2448. 

  2448. @@ -6420,7 +6424,7 @@ rb_w32_read(int fd, void *buf, size_t size)
    2449. 

  2449.  
    2450. 

  2450.      /* if have cancel_io, use Overlapped I/O */
    2451. 

  2451.      if (cancel_io) {
    2452. 

  2452. -	if (setup_overlapped(&ol, fd)) {
    2453. 

  2453. +	if (setup_overlapped(&ol, fd, FALSE)) {
    2454. 

  2454.  	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
    2455. 

  2455.  	    return -1;
    2456. 

  2456.  	}
    2457. 

  2457. @@ -6550,7 +6554,7 @@ rb_w32_write(int fd, const void *buf, size_t size)
    2458. 

  2458.  
    2459. 

  2459.      /* if have cancel_io, use Overlapped I/O */
    2460. 

  2460.      if (cancel_io) {
    2461. 

  2461. -	if (setup_overlapped(&ol, fd)) {
    2462. 

  2462. +	if (setup_overlapped(&ol, fd, TRUE)) {
    2463. 

  2463.  	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
    2464. 

  2464.  	    return -1;
    2465. 

  2465.  	}
    2466. 

  2466.