PageRenderTime 55ms CodeModel.GetById 12ms RepoModel.GetById 0ms 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

Large files files are truncated, but you can click here to view the full 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 = d…
    1586.

Large files files are truncated, but you can click here to view the full file