In perl.git, the branch blead has been updated <http://perl5.git.perl.org/perl.git/commitdiff/290f44ead05a5718e4f391f298e4d75e601393e5?hp=2c8efe4079b75c61cf34425054539a9c24913e9f>
- Log ----------------------------------------------------------------- commit 290f44ead05a5718e4f391f298e4d75e601393e5 Author: David Mitchell <[email protected]> Date: Mon Jun 12 16:26:02 2017 +0100 keep PERL_HASH_SEED_BYTES as an int adding a sizeof() expression was converting it into an unsigned long, which was triggering this warning in Hash-Util: Util.xs:99:45: warning: format specifies type 'int' but the argument has type 'unsigned long' [-Wformat] M hv_func.h commit fa531f329e4f1fbd1d51dc1d40cc900089487939 Author: David Mitchell <[email protected]> Date: Mon Jun 12 13:31:22 2017 +0100 gv.c, mg.c: fix 32-bit compiler warnings mg.c:641:21: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] UV uv = (UV)mg->mg_obj; It's storing a char-ranged integer value as an SV*. By using SSize_t rather than UV to store the char, it avoids mismatched size warnings. M gv.c M mg.c commit 522dba3426c18f53b5e3a09c16b13670d4bafd6d Author: David Mitchell <[email protected]> Date: Mon Jun 12 13:05:23 2017 +0100 Storable: fix a couple of 32-bit warnings Storable.xs: In function 'retrieve_blessed': Storable.xs:1015:39: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] else if (PerlIO_read(cxt->fio, x, y) != y) { \ ^ Storable.xs:4078:2: note: in expansion of macro 'SAFEPVREAD' SAFEPVREAD(classname, len, malloced_classname); M dist/Storable/Storable.pm M dist/Storable/Storable.xs commit 6d58945bb899c873defec040c7d8c9823f3c5d68 Author: David Mitchell <[email protected]> Date: Mon Jun 12 12:57:27 2017 +0100 PerlIO-scalar: fix 32-bit compiler warning M ext/PerlIO-scalar/scalar.pm M ext/PerlIO-scalar/scalar.xs commit 51099b64db323d0e1d871837f619d72bea8ca2f9 Author: David Mitchell <[email protected]> Date: Mon Jun 12 11:42:22 2017 +0100 fix utf char > IV_MAX on 32-bit platforms Commit v5.27.0-132-g13f4dd3 forbade out of range Unicode code points, and fixed/removed tests that no longer apply. However, this was probably only tested on a 64-bit platform. Several tests now fail on 32-bit platforms, due to things like "\x{80000000}". This commit fixes up those tests too. M ext/XS-APItest/t/utf8.t M ext/XS-APItest/t/utf8_warn_base.pl M t/comp/parser.t M t/lib/warnings/utf8 M t/op/chop.t M t/op/index.t M t/opbasic/qq.t M t/re/pat_advanced.t M t/uni/parser.t ----------------------------------------------------------------------- Summary of changes: dist/Storable/Storable.pm | 2 +- dist/Storable/Storable.xs | 4 +- ext/PerlIO-scalar/scalar.pm | 2 +- ext/PerlIO-scalar/scalar.xs | 2 +- ext/XS-APItest/t/utf8.t | 3 + ext/XS-APItest/t/utf8_warn_base.pl | 124 ++++++++++++++++++------------------- gv.c | 8 +-- hv_func.h | 2 +- mg.c | 14 ++--- t/comp/parser.t | 2 +- t/lib/warnings/utf8 | 7 +-- t/op/chop.t | 20 ++---- t/op/index.t | 11 ++-- t/opbasic/qq.t | 7 +-- t/re/pat_advanced.t | 3 +- t/uni/parser.t | 3 +- 16 files changed, 96 insertions(+), 118 deletions(-) diff --git a/dist/Storable/Storable.pm b/dist/Storable/Storable.pm index d8fd740eee..3adc8044de 100644 --- a/dist/Storable/Storable.pm +++ b/dist/Storable/Storable.pm @@ -22,7 +22,7 @@ package Storable; @ISA = qw(Exporter); use vars qw($canonical $forgive_me $VERSION); -$VERSION = '2.62'; +$VERSION = '2.63'; BEGIN { if (eval { diff --git a/dist/Storable/Storable.xs b/dist/Storable/Storable.xs index 9ba48be1c4..1043bf7914 100644 --- a/dist/Storable/Storable.xs +++ b/dist/Storable/Storable.xs @@ -4075,7 +4075,7 @@ static SV *retrieve_blessed(pTHX_ stcxt_t *cxt, const char *cname) New(10003, classname, len+1, char); malloced_classname = classname; } - SAFEPVREAD(classname, len, malloced_classname); + SAFEPVREAD(classname, (SSize_t)len, malloced_classname); classname[len] = '\0'; /* Mark string end */ /* @@ -4266,7 +4266,7 @@ static SV *retrieve_hook(pTHX_ stcxt_t *cxt, const char *cname) malloced_classname = classname; } - SAFEPVREAD(classname, len, malloced_classname); + SAFEPVREAD(classname, (SSize_t)len, malloced_classname); classname[len] = '\0'; /* Mark string end */ /* diff --git a/ext/PerlIO-scalar/scalar.pm b/ext/PerlIO-scalar/scalar.pm index ce328ede23..bcbb56c7c6 100644 --- a/ext/PerlIO-scalar/scalar.pm +++ b/ext/PerlIO-scalar/scalar.pm @@ -1,5 +1,5 @@ package PerlIO::scalar; -our $VERSION = '0.26'; +our $VERSION = '0.27'; require XSLoader; XSLoader::load(); 1; diff --git a/ext/PerlIO-scalar/scalar.xs b/ext/PerlIO-scalar/scalar.xs index c9a24db0b3..4c5d2c1cb1 100644 --- a/ext/PerlIO-scalar/scalar.xs +++ b/ext/PerlIO-scalar/scalar.xs @@ -187,7 +187,7 @@ PerlIOScalar_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) * always less than half the size of the address space */ assert(sizeof(Off_t) >= sizeof(len)); - assert((Off_t)len >= 0); + assert(len < ((~(STRLEN)0) >> 1)); if ((Off_t)len <= s->posn) return 0; got = len - (STRLEN)(s->posn); diff --git a/ext/XS-APItest/t/utf8.t b/ext/XS-APItest/t/utf8.t index 788d564188..95e2628f57 100644 --- a/ext/XS-APItest/t/utf8.t +++ b/ext/XS-APItest/t/utf8.t @@ -869,6 +869,9 @@ my $p = (isASCII) ? "\xe1\x80" : I8_to_native("\xE4\xA0"); # partial for my $restriction (sort keys %restriction_types) { use bytes; + next if $restriction eq 'fits_in_31_bits' + && !defined $restriction_types{"fits_in_31_bits"}{'first_invalid_offset'}; + for my $use_flags ("", "_flags") { # For each restriction, we test it in both the is_foo_flags functions diff --git a/ext/XS-APItest/t/utf8_warn_base.pl b/ext/XS-APItest/t/utf8_warn_base.pl index 66f6f3df6a..a3f4052b55 100644 --- a/ext/XS-APItest/t/utf8_warn_base.pl +++ b/ext/XS-APItest/t/utf8_warn_base.pl @@ -377,70 +377,6 @@ my @tests = ( (isASCII) ? 4 : 5, qr/Unicode non-character.*is not recommended for open interchange/ ], - [ "requires at least 32 bits", - (isASCII) - ? "\xfe\x82\x80\x80\x80\x80\x80" - : I8_to_native( - "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa2\xa0\xa0\xa0\xa0\xa0\xa0"), - # This code point is chosen so that it is representable in a UV on - # 32-bit machines - $::UTF8_WARN_ABOVE_31_BIT, $::UTF8_DISALLOW_ABOVE_31_BIT, - $::UTF8_GOT_ABOVE_31_BIT, - 'utf8', 0x80000000, - (isASCII) ? 7 : $::max_bytes, - (isASCII) ? 1 : 8, - nonportable_regex(0x80000000) - ], - [ "highest 32 bit code point", - (isASCII) - ? "\xfe\x83\xbf\xbf\xbf\xbf\xbf" - : I8_to_native( - "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa3\xbf\xbf\xbf\xbf\xbf\xbf"), - $::UTF8_WARN_ABOVE_31_BIT, $::UTF8_DISALLOW_ABOVE_31_BIT, - $::UTF8_GOT_ABOVE_31_BIT, - 'utf8', 0xFFFFFFFF, - (isASCII) ? 7 : $::max_bytes, - (isASCII) ? 1 : 8, - nonportable_regex(0xffffffff) - ], - [ "requires at least 32 bits, and use SUPER-type flags, instead of" - . " ABOVE_31_BIT", - (isASCII) - ? "\xfe\x82\x80\x80\x80\x80\x80" - : I8_to_native( - "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa2\xa0\xa0\xa0\xa0\xa0\xa0"), - $::UTF8_WARN_SUPER, $::UTF8_DISALLOW_SUPER, $::UTF8_GOT_SUPER, - 'utf8', 0x80000000, - (isASCII) ? 7 : $::max_bytes, - 1, - nonportable_regex(0x80000000) - ], - [ "overflow with warnings/disallow for more than 31 bits", - # This tests the interaction of WARN_ABOVE_31_BIT/DISALLOW_ABOVE_31_BIT - # with overflow. The overflow malformation is never allowed, so - # preventing it takes precedence if the ABOVE_31_BIT options would - # otherwise allow in an overflowing value. The ASCII code points (1 - # for 32-bits; 1 for 64) were chosen because the old overflow - # detection algorithm did not catch them; this means this test also - # checks for that fix. The EBCDIC are arbitrary overflowing ones - # since we have no reports of failures with it. - (($::is64bit) - ? ((isASCII) - ? "\xff\x80\x90\x90\x90\xbf\xbf\xbf\xbf\xbf\xbf\xbf\xbf" - : I8_to_native( - "\xff\xB0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0")) - : ((isASCII) - ? "\xfe\x86\x80\x80\x80\x80\x80" - : I8_to_native( - "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa4\xa0\xa0\xa0\xa0\xa0\xa0"))), - $::UTF8_WARN_ABOVE_31_BIT, - $::UTF8_DISALLOW_ABOVE_31_BIT, - $::UTF8_GOT_ABOVE_31_BIT, - 'utf8', 0, - (! isASCII || $::is64bit) ? $::max_bytes : 7, - (isASCII || $::is64bit) ? 2 : 8, - qr/overflows/ - ], ); if (! $::is64bit) { @@ -471,6 +407,66 @@ else { $::max_bytes, (isASCII) ? 1 : 7, qr/and( is)? not portable/ ]; + [ "requires at least 32 bits", + (isASCII) + ? "\xfe\x82\x80\x80\x80\x80\x80" + : I8_to_native( + "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa2\xa0\xa0\xa0\xa0\xa0\xa0"), + # This code point is chosen so that it is representable in a UV on + # 32-bit machines + $::UTF8_WARN_ABOVE_31_BIT, $::UTF8_DISALLOW_ABOVE_31_BIT, + $::UTF8_GOT_ABOVE_31_BIT, + 'utf8', 0x80000000, + (isASCII) ? 7 : $::max_bytes, + (isASCII) ? 1 : 8, + nonportable_regex(0x80000000) + ], + [ "highest 32 bit code point", + (isASCII) + ? "\xfe\x83\xbf\xbf\xbf\xbf\xbf" + : I8_to_native( + "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa3\xbf\xbf\xbf\xbf\xbf\xbf"), + $::UTF8_WARN_ABOVE_31_BIT, $::UTF8_DISALLOW_ABOVE_31_BIT, + $::UTF8_GOT_ABOVE_31_BIT, + 'utf8', 0xFFFFFFFF, + (isASCII) ? 7 : $::max_bytes, + (isASCII) ? 1 : 8, + nonportable_regex(0xffffffff) + ], + [ "requires at least 32 bits, and use SUPER-type flags, instead of" + . " ABOVE_31_BIT", + (isASCII) + ? "\xfe\x82\x80\x80\x80\x80\x80" + : I8_to_native( + "\xff\xa0\xa0\xa0\xa0\xa0\xa0\xa2\xa0\xa0\xa0\xa0\xa0\xa0"), + $::UTF8_WARN_SUPER, $::UTF8_DISALLOW_SUPER, $::UTF8_GOT_SUPER, + 'utf8', 0x80000000, + (isASCII) ? 7 : $::max_bytes, + 1, + nonportable_regex(0x80000000) + ], + [ "overflow with warnings/disallow for more than 31 bits", + # This tests the interaction of WARN_ABOVE_31_BIT/DISALLOW_ABOVE_31_BIT + # with overflow. The overflow malformation is never allowed, so + # preventing it takes precedence if the ABOVE_31_BIT options would + # otherwise allow in an overflowing value. The ASCII code points (1 + # for 32-bits; 1 for 64) were chosen because the old overflow + # detection algorithm did not catch them; this means this test also + # checks for that fix. The EBCDIC are arbitrary overflowing ones + # since we have no reports of failures with it. + ((isASCII) + ? "\xff\x80\x90\x90\x90\xbf\xbf\xbf\xbf\xbf\xbf\xbf\xbf" + : I8_to_native( + "\xff\xB0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0\xa0")), + $::UTF8_WARN_ABOVE_31_BIT, + $::UTF8_DISALLOW_ABOVE_31_BIT, + $::UTF8_GOT_ABOVE_31_BIT, + 'utf8', 0, + (! isASCII || $::is64bit) ? $::max_bytes : 7, + (isASCII || $::is64bit) ? 2 : 8, + qr/overflows/ + ]; + if (! isASCII) { push @tests, # These could falsely show wrongly in a naive # implementation diff --git a/gv.c b/gv.c index 42ef902f33..5da09dfe77 100644 --- a/gv.c +++ b/gv.c @@ -1995,9 +1995,9 @@ S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, /* @{^CAPTURE} %{^CAPTURE} */ if (memEQs(name, len, "\003APTURE")) { AV* const av = GvAVn(gv); - UV uv= *name; + const Size_t n = *name; - sv_magic(MUTABLE_SV(av), (SV*)uv, PERL_MAGIC_regdata, NULL, 0); + sv_magic(MUTABLE_SV(av), (SV*)n, PERL_MAGIC_regdata, NULL, 0); SvREADONLY_on(av); if (sv_type == SVt_PVHV || sv_type == SVt_PVGV) @@ -2163,9 +2163,9 @@ S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, } { /* @- @+ */ AV* const av = GvAVn(gv); - const UV uv = (UV)*name; + const Size_t n = *name; - sv_magic(MUTABLE_SV(av), (SV*)uv, PERL_MAGIC_regdata, NULL, 0); + sv_magic(MUTABLE_SV(av), (SV*)n, PERL_MAGIC_regdata, NULL, 0); SvREADONLY_on(av); } break; diff --git a/hv_func.h b/hv_func.h index 4be4214293..fdbb7538b0 100644 --- a/hv_func.h +++ b/hv_func.h @@ -83,7 +83,7 @@ #define _PERL_HASH_FUNC "SBOX32_WITH_" __PERL_HASH_FUNC -#define _PERL_HASH_SEED_BYTES ( __PERL_HASH_SEED_BYTES + ( 3 * sizeof(U32) ) ) +#define _PERL_HASH_SEED_BYTES ( __PERL_HASH_SEED_BYTES + (int)( 3 * sizeof(U32) ) ) #define _PERL_HASH_STATE_BYTES \ ( __PERL_HASH_STATE_BYTES + ( ( 1 + ( 256 * SBOX32_MAX_LEN ) ) * sizeof(U32) ) ) diff --git a/mg.c b/mg.c index 3a2210d20f..498a141599 100644 --- a/mg.c +++ b/mg.c @@ -638,8 +638,8 @@ Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) if (PL_curpm) { REGEXP * const rx = PM_GETRE(PL_curpm); if (rx) { - UV uv = (UV)mg->mg_obj; - if (uv == '+') { /* @+ */ + const SSize_t n = (SSize_t)mg->mg_obj; + if (n == '+') { /* @+ */ /* return the number possible */ return RX_NPARENS(rx); } else { /* @- @^CAPTURE @{^CAPTURE} */ @@ -650,7 +650,7 @@ Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) && (RX_OFFS(rx)[paren].start == -1 || RX_OFFS(rx)[paren].end == -1) ) paren--; - if (uv == '-') { + if (n == '-') { /* @- */ return (U32)paren; } else { @@ -674,10 +674,10 @@ Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) if (PL_curpm) { REGEXP * const rx = PM_GETRE(PL_curpm); if (rx) { - const UV uv = (UV)mg->mg_obj; + const SSize_t n = (SSize_t)mg->mg_obj; /* @{^CAPTURE} does not contain $&, so we need to increment by 1 */ const I32 paren = mg->mg_len - + (uv == '\003' ? 1 : 0); + + (n == '\003' ? 1 : 0); SSize_t s; SSize_t t; if (paren < 0) @@ -688,9 +688,9 @@ Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) { SSize_t i; - if (uv == '+') /* @+ */ + if (n == '+') /* @+ */ i = t; - else if (uv == '-') /* @- */ + else if (n == '-') /* @- */ i = s; else { /* @^CAPTURE @{^CAPTURE} */ CALLREG_NUMBUF_FETCH(rx,paren,sv); diff --git a/t/comp/parser.t b/t/comp/parser.t index 6fd5ad0aa0..9b0f3a710a 100644 --- a/t/comp/parser.t +++ b/t/comp/parser.t @@ -586,7 +586,7 @@ is $@, "", 'substr keys assignment'; { no warnings; - eval "q" . chr(100000000064); + eval "q" . chr(0x7fffffff); like $@, qr/Can't find string terminator "." anywhere before EOF/, 'RT 128952'; } diff --git a/t/lib/warnings/utf8 b/t/lib/warnings/utf8 index a10174a633..a4dfb12698 100644 --- a/t/lib/warnings/utf8 +++ b/t/lib/warnings/utf8 @@ -99,12 +99,11 @@ Operation "uc" returns its argument for non-Unicode code point 0x110000 at - lin Operation "uc" returns its argument for UTF-16 surrogate U+D800 at - line 5. ######## use warnings 'utf8'; -no warnings 'deprecated'; # This is above IV_MAX on 32 bit machines -my $big_nonUnicode = uc(chr(0x8000_0000)); +my $big_nonUnicode = uc(chr(0x7fff_ffff)); no warnings 'non_unicode'; -my $big_nonUnicode = uc(chr(0x8000_0000)); +my $big_nonUnicode = uc(chr(0x7fff_ffff)); EXPECT -Operation "uc" returns its argument for non-Unicode code point 0x80000000 at - line 3. +Operation "uc" returns its argument for non-Unicode code point 0x7FFFFFFF at - line 2. ######## use warnings 'utf8'; my $d7ff = lc pack("U", 0xD7FF); diff --git a/t/op/chop.t b/t/op/chop.t index f12332ae7c..8afc546113 100644 --- a/t/op/chop.t +++ b/t/op/chop.t @@ -7,7 +7,7 @@ BEGIN { require './charset_tools.pl'; } -my $tests_count = 148; +my $tests_count = 146; plan tests => $tests_count; $_ = 'abc'; @@ -253,22 +253,10 @@ foreach my $start (@chars) { # [perl #73246] chop doesn't support utf8 # the problem was UTF8_IS_START() didn't handle perl's extended UTF8 - no warnings 'deprecated'; # This is above IV_MAX on 32 bit machines - my $utf = "\x{80000001}\x{80000000}"; + my $utf = "\x{7fffffff}\x{7ffffffe}"; my $result = chop($utf); - is($utf, "\x{80000001}", "chopping high 'unicode'- remnant"); - is($result, "\x{80000000}", "chopping high 'unicode' - result"); - - SKIP: { - no warnings 'overflow'; # avoid compile-time warnings below on 32-bit architectures - use Config; - $Config{ivsize} >= 8 - or skip("this build can't handle very large characters", 2); - my $utf = "\x{7fffffffffffffff}\x{7ffffffffffffffe}"; - my $result = chop $utf; - is($utf, "\x{7fffffffffffffff}", "chop even higher 'unicode' - remnant"); - is($result, "\x{7ffffffffffffffe}", "chop even higher 'unicode' - result"); - } + is($utf, "\x{7fffffff}", "chopping high 'unicode'- remnant"); + is($result, "\x{7ffffffe}", "chopping high 'unicode' - result"); } $/ = "\n"; diff --git a/t/op/index.t b/t/op/index.t index d1e46dc648..f043ef81e2 100644 --- a/t/op/index.t +++ b/t/op/index.t @@ -130,17 +130,16 @@ is(rindex($a, "foo", ), 0); } { - no warnings 'deprecated'; # These are above IV_MAX on 32 bit machines - my $a = eval q{"\x{80000000}"}; + my $a = eval q{"\x{7fffffff}"}; my $s = $a.'defxyz'; - is(index($s, 'def'), 1, "0x80000000 is a single character"); + is(index($s, 'def'), 1, "0x7fffffff is a single character"); - my $b = eval q{"\x{fffffffd}"}; + my $b = eval q{"\x{7ffffffd}"}; my $t = $b.'pqrxyz'; - is(index($t, 'pqr'), 1, "0xfffffffd is a single character"); + is(index($t, 'pqr'), 1, "0x7ffffffd is a single character"); local ${^UTF8CACHE} = -1; - is(index($t, 'xyz'), 4, "0xfffffffd and utf8cache"); + is(index($t, 'xyz'), 4, "0x7ffffffd and utf8cache"); } diff --git a/t/opbasic/qq.t b/t/opbasic/qq.t index 5d6908cef1..e633783df2 100644 --- a/t/opbasic/qq.t +++ b/t/opbasic/qq.t @@ -8,7 +8,7 @@ BEGIN { # This file uses a specially crafted is() function rather than that found in # t/test.pl or Test::More. Hence, we place this file in directory t/opbasic. -print q(1..29 +print q(1..28 ); # This is() function is written to avoid "" @@ -71,11 +71,6 @@ is ("a\o{120}b", "a" . chr(0x50) . "b"); is ("a\o{400}b", "a" . chr(0x100) . "b"); is ("a\o{1000}b", "a" . chr(0x200) . "b"); -# This caused a memory fault -no warnings "utf8"; -no warnings 'deprecated'; # This is above IV_MAX on 32 bit machines -is ("abc", eval qq[qq\x{8000_0000}abc\x{8000_0000}]); - # Maybe \x{} should be an error, but if not it should certainly mean \x{0} # rather than anything else. is ("\x{}", chr(0)); diff --git a/t/re/pat_advanced.t b/t/re/pat_advanced.t index f2d9c74da9..a2ff68169b 100644 --- a/t/re/pat_advanced.t +++ b/t/re/pat_advanced.t @@ -2402,8 +2402,7 @@ EOF $Config{uvsize} == 8 or skip("need large code-points for this test", 1); - # This is above IV_MAX on 32 bit machines, so turn off those warnings - fresh_perl_is('no warnings "deprecated"; /\x{E000000000}|/ and print qq(ok\n)', "ok\n", {}, + fresh_perl_is('/\x{E000000000}|/ and print qq(ok\n)', "ok\n", {}, "buffer overflow in TRIE_STORE_REVCHAR"); } diff --git a/t/uni/parser.t b/t/uni/parser.t index 2c68fb0473..c5cf21c7ca 100644 --- a/t/uni/parser.t +++ b/t/uni/parser.t @@ -237,9 +237,8 @@ SKIP: { # [perl #128738] skip("test is only valid on 64-bit ints", 2); } else { - no warnings 'deprecated'; my $a; - eval "\$a = q \x{ffffffff}Hello, \\\\whirled!\x{ffffffff}"; + eval "\$a = q \x{7fffffff}Hello, \\\\whirled!\x{7fffffff}"; is $@, "", "No errors in eval'ing a string with large code point delimiter"; is $a, 'Hello, \whirled!', -- Perl5 Master Repository
