diff options
| author | Andrew Fresh <afresh1@cvs.openbsd.org> | 2019-02-13 21:11:45 +0000 |
|---|---|---|
| committer | Andrew Fresh <afresh1@cvs.openbsd.org> | 2019-02-13 21:11:45 +0000 |
| commit | 0cc2c999dde616622e1c1a39da60828645040e47 (patch) | |
| tree | d67af193288a2d010b2eae5d526d615c6adbcaf5 /gnu/usr.bin/perl/pod | |
| parent | 2e70a883f7ff179f56cb433b7b3473e5ca1eefe4 (diff) | |
Import perl-5.28.1
looking good sthen@, Great! bluhm@
Diffstat (limited to 'gnu/usr.bin/perl/pod')
27 files changed, 7389 insertions, 42 deletions
diff --git a/gnu/usr.bin/perl/pod/perl5004delta.pod b/gnu/usr.bin/perl/pod/perl5004delta.pod index fc5ae62bb85..264483e118b 100644 --- a/gnu/usr.bin/perl/pod/perl5004delta.pod +++ b/gnu/usr.bin/perl/pod/perl5004delta.pod @@ -696,7 +696,7 @@ effect if perl is compiled with system malloc().) If this macro is defined, running out of memory need not be a fatal error: a memory pool can allocated by assigning to the special -variable C<$^M>. See L<"$^M">. +variable C<$^M>. See L</"$^M">. =item -DPACK_MALLOC diff --git a/gnu/usr.bin/perl/pod/perl5005delta.pod b/gnu/usr.bin/perl/pod/perl5005delta.pod index e73bcebc429..f1e304e3202 100644 --- a/gnu/usr.bin/perl/pod/perl5005delta.pod +++ b/gnu/usr.bin/perl/pod/perl5005delta.pod @@ -106,7 +106,7 @@ directly accessing perl globals as C<GvSV(errgv)>. The API call is backward compatible with existing perls and provides source compatibility with threading is enabled. -See L<"C Source Compatibility"> for more information. +See L</"C Source Compatibility"> for more information. =back @@ -134,7 +134,7 @@ Oneliners with the C<-e> switch do not create temporary files anymore. Many new warnings that were introduced in 5.004 have been made optional. Some of these warnings are still present, but perl's new -features make them less often a problem. See L<New Diagnostics>. +features make them less often a problem. See L</New Diagnostics>. =head2 Licensing diff --git a/gnu/usr.bin/perl/pod/perl5100delta.pod b/gnu/usr.bin/perl/pod/perl5100delta.pod index 10d71d686a3..6728559a95e 100644 --- a/gnu/usr.bin/perl/pod/perl5100delta.pod +++ b/gnu/usr.bin/perl/pod/perl5100delta.pod @@ -1015,7 +1015,7 @@ The L<perlreapi> manpage describes the interface to the perl interpreter used to write pluggable regular expression engines (by Ævar Arnfjörð Bjarmason). -The L<perlunitut> manpage is an tutorial for programming with Unicode and +The L<perlunitut> manpage is a tutorial for programming with Unicode and string encodings in Perl, courtesy of Juerd Waalboer. A new manual page, L<perlunifaq> (the Perl Unicode FAQ), has been added @@ -1576,7 +1576,7 @@ inherits from C<B::SV> (it used to inherit from C<B::IV>). The anonymous hash and array constructors now take 1 op in the optree instead of 3, now that pp_anonhash and pp_anonlist return a reference to -an hash/array when the op is flagged with OPf_SPECIAL. (Nicholas Clark) +a hash/array when the op is flagged with OPf_SPECIAL. (Nicholas Clark) =head1 Known Problems diff --git a/gnu/usr.bin/perl/pod/perl5101delta.pod b/gnu/usr.bin/perl/pod/perl5101delta.pod index 415ab6be245..1fdd0451d90 100644 --- a/gnu/usr.bin/perl/pod/perl5101delta.pod +++ b/gnu/usr.bin/perl/pod/perl5101delta.pod @@ -127,7 +127,7 @@ if overload fallback is active, it will be used instead, as usual.) =item * The semantics of C<use feature :5.10*> have changed slightly. -See L<"Modules and Pragmata"> for more information. +See L</"Modules and Pragmata"> for more information. =item * diff --git a/gnu/usr.bin/perl/pod/perl5120delta.pod b/gnu/usr.bin/perl/pod/perl5120delta.pod index b8bd646bdda..5b5eac0ecfb 100644 --- a/gnu/usr.bin/perl/pod/perl5120delta.pod +++ b/gnu/usr.bin/perl/pod/perl5120delta.pod @@ -65,7 +65,7 @@ years, it will become a standard practice. However, C<package NAME VERSION> requires a new, 'strict' version -number format. See L<"Version number formats"> for details. +number format. See L</"Version number formats"> for details. =head2 The C<...> operator @@ -430,7 +430,7 @@ to bless them into C<IO::Handle>. =item * The semantics of C<use feature :5.10*> have changed slightly. -See L<"Modules and Pragmata"> for more information. +See L</"Modules and Pragmata"> for more information. =item * @@ -1707,7 +1707,7 @@ Two flag bits are currently supported. =item * C<SVf_UTF8> will call C<SvUTF8_on()> for you. (Note that this does -not convert an sequence of ISO 8859-1 characters to UTF-8). A wrapper, +not convert a sequence of ISO 8859-1 characters to UTF-8). A wrapper, C<newSVpvn_utf8()> is available for this. =item * diff --git a/gnu/usr.bin/perl/pod/perl5140delta.pod b/gnu/usr.bin/perl/pod/perl5140delta.pod index 26df41c6520..0f4fa6f6d4f 100644 --- a/gnu/usr.bin/perl/pod/perl5140delta.pod +++ b/gnu/usr.bin/perl/pod/perl5140delta.pod @@ -2461,7 +2461,7 @@ parser's API in a detectable way. =item refcnt: fd %d%s -This new error only occurs if a internal consistency check fails when a +This new error only occurs if an internal consistency check fails when a pipe is about to be closed. =item Regexp modifier "/%c" may not appear twice diff --git a/gnu/usr.bin/perl/pod/perl5180delta.pod b/gnu/usr.bin/perl/pod/perl5180delta.pod index a5a3cae23e6..79d2af3604a 100644 --- a/gnu/usr.bin/perl/pod/perl5180delta.pod +++ b/gnu/usr.bin/perl/pod/perl5180delta.pod @@ -540,7 +540,7 @@ inherited by child processes. In this release, when assigning to C<%ENV>, values are immediately stringified, and converted to be only a byte string. -First, it is forced to be a only a string. Then if the string is utf8 and the +First, it is forced to be only a string. Then if the string is utf8 and the equivalent of C<utf8::downgrade()> works, that result is used; otherwise, the equivalent of C<utf8::encode()> is used, and a warning is issued about wide characters (L</Diagnostics>). @@ -2759,7 +2759,7 @@ The use of C<PL_stashcache>, the stash name lookup cache for method calls, has been restored, Commit da6b625f78f5f133 in August 2011 inadvertently broke the code that looks -up values in C<PL_stashcache>. As it's a only cache, quite correctly everything +up values in C<PL_stashcache>. As it's only a cache, quite correctly everything carried on working without it. =item * diff --git a/gnu/usr.bin/perl/pod/perl5181delta.pod b/gnu/usr.bin/perl/pod/perl5181delta.pod index 93fb251991f..64bb9d0844d 100644 --- a/gnu/usr.bin/perl/pod/perl5181delta.pod +++ b/gnu/usr.bin/perl/pod/perl5181delta.pod @@ -48,7 +48,7 @@ Module::CoreList has been upgraded from 2.89 to 2.96. =item AIX -A rarely-encounted configuration bug in the AIX hints file has been corrected. +A rarely-encountered configuration bug in the AIX hints file has been corrected. =item MidnightBSD diff --git a/gnu/usr.bin/perl/pod/perl5184delta.pod b/gnu/usr.bin/perl/pod/perl5184delta.pod index 3f1b3a37e5c..4a043a1cbe8 100644 --- a/gnu/usr.bin/perl/pod/perl5184delta.pod +++ b/gnu/usr.bin/perl/pod/perl5184delta.pod @@ -48,7 +48,7 @@ Introduced by L<perl #113536|https://rt.perl.org/Public/Bug/Display.html?id=113536>, a memory leak on every call to C<system> and backticks (C< `` >), on most Win32 Perls starting from 5.18.0 has been fixed. The memory leak only occurred if you -enabled psuedo-fork in your build of Win32 Perl, and were running that build on +enabled pseudo-fork in your build of Win32 Perl, and were running that build on Server 2003 R2 or newer OS. The leak does not appear on WinXP SP3. [L<perl #121676|https://rt.perl.org/Public/Bug/Display.html?id=121676>] diff --git a/gnu/usr.bin/perl/pod/perl5243delta.pod b/gnu/usr.bin/perl/pod/perl5243delta.pod new file mode 100644 index 00000000000..7aabed92b90 --- /dev/null +++ b/gnu/usr.bin/perl/pod/perl5243delta.pod @@ -0,0 +1,335 @@ +=encoding utf8 + +=head1 NAME + +perl5243delta - what is new for perl v5.24.3 + +=head1 DESCRIPTION + +This document describes differences between the 5.24.2 release and the 5.24.3 +release. + +If you are upgrading from an earlier release such as 5.24.1, first read +L<perl5242delta>, which describes differences between 5.24.1 and 5.24.2. + +=head1 Security + +=head2 [CVE-2017-12837] Heap buffer overflow in regular expression compiler + +Compiling certain regular expression patterns with the case-insensitive +modifier could cause a heap buffer overflow and crash perl. This has now been +fixed. +L<[perl #131582]|https://rt.perl.org/Public/Bug/Display.html?id=131582> + +=head2 [CVE-2017-12883] Buffer over-read in regular expression parser + +For certain types of syntax error in a regular expression pattern, the error +message could either contain the contents of a random, possibly large, chunk of +memory, or could crash perl. This has now been fixed. +L<[perl #131598]|https://rt.perl.org/Public/Bug/Display.html?id=131598> + +=head2 [CVE-2017-12814] C<$ENV{$key}> stack buffer overflow on Windows + +A possible stack buffer overflow in the C<%ENV> code on Windows has been fixed +by removing the buffer completely since it was superfluous anyway. +L<[perl #131665]|https://rt.perl.org/Public/Bug/Display.html?id=131665> + +=head1 Incompatible Changes + +There are no changes intentionally incompatible with 5.24.2. If any exist, +they are bugs, and we request that you submit a report. See L</Reporting +Bugs> below. + +=head1 Modules and Pragmata + +=head2 Updated Modules and Pragmata + +=over 4 + +=item * + +L<Module::CoreList> has been upgraded from version 5.20170715_24 to +5.20170922_24. + +=item * + +L<POSIX> has been upgraded from version 1.65 to 1.65_01. + +=item * + +L<Time::HiRes> has been upgraded from version 1.9733 to 1.9741. + +L<[perl #128427]|https://rt.perl.org/Public/Bug/Display.html?id=128427> +L<[perl #128445]|https://rt.perl.org/Public/Bug/Display.html?id=128445> +L<[perl #128972]|https://rt.perl.org/Public/Bug/Display.html?id=128972> +L<[cpan #120032]|https://rt.cpan.org/Public/Bug/Display.html?id=120032> + +=back + +=head1 Configuration and Compilation + +=over 4 + +=item * + +When building with GCC 6 and link-time optimization (the B<-flto> option to +B<gcc>), F<Configure> was treating all probed symbols as present on the system, +regardless of whether they actually exist. This has been fixed. +L<[perl #128131]|https://rt.perl.org/Public/Bug/Display.html?id=128131> + +=item * + +F<Configure> now aborts if both C<-Duselongdouble> and C<-Dusequadmath> are +requested. +L<[perl #126203]|https://rt.perl.org/Public/Bug/Display.html?id=126203> + +=item * + +Fixed a bug in which F<Configure> could append C<-quadmath> to the archname +even if it was already present. +L<[perl #128538]|https://rt.perl.org/Public/Bug/Display.html?id=128538> + +=item * + +Clang builds with C<-DPERL_GLOBAL_STRUCT> or C<-DPERL_GLOBAL_STRUCT_PRIVATE> +have been fixed (by disabling Thread Safety Analysis for these configurations). + +=back + +=head1 Platform Support + +=head2 Platform-Specific Notes + +=over 4 + +=item VMS + +=over 4 + +=item * + +C<configure.com> now recognizes the VSI-branded C compiler. + +=back + +=item Windows + +=over 4 + +=item * + +Building XS modules with GCC 6 in a 64-bit build of Perl failed due to +incorrect mapping of C<strtoll> and C<strtoull>. This has now been fixed. +L<[perl #131726]|https://rt.perl.org/Public/Bug/Display.html?id=131726> +L<[cpan #121683]|https://rt.cpan.org/Public/Bug/Display.html?id=121683> +L<[cpan #122353]|https://rt.cpan.org/Public/Bug/Display.html?id=122353> + +=back + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +C<< /@0{0*-E<gt>@*/*0 >> and similar contortions used to crash, but no longer +do, but merely produce a syntax error. +L<[perl #128171]|https://rt.perl.org/Public/Bug/Display.html?id=128171> + +=item * + +C<do> or C<require> with an argument which is a reference or typeglob which, +when stringified, contains a null character, started crashing in Perl 5.20, but +has now been fixed. +L<[perl #128182]|https://rt.perl.org/Public/Bug/Display.html?id=128182> + +=item * + +Expressions containing an C<&&> or C<||> operator (or their synonyms C<and> and +C<or>) were being compiled incorrectly in some cases. If the left-hand side +consisted of either a negated bareword constant or a negated C<do {}> block +containing a constant expression, and the right-hand side consisted of a +negated non-foldable expression, one of the negations was effectively ignored. +The same was true of C<if> and C<unless> statement modifiers, though with the +left-hand and right-hand sides swapped. This long-standing bug has now been +fixed. +L<[perl #127952]|https://rt.perl.org/Public/Bug/Display.html?id=127952> + +=item * + +C<reset> with an argument no longer crashes when encountering stash entries +other than globs. +L<[perl #128106]|https://rt.perl.org/Public/Bug/Display.html?id=128106> + +=item * + +Assignment of hashes to, and deletion of, typeglobs named C<*::::::> no longer +causes crashes. +L<[perl #128086]|https://rt.perl.org/Public/Bug/Display.html?id=128086> + +=item * + +Assignment variants of any bitwise ops under the C<bitwise> feature would crash +if the left-hand side was an array or hash. +L<[perl #128204]|https://rt.perl.org/Public/Bug/Display.html?id=128204> + +=item * + +C<socket> now leaves the error code returned by the system in C<$!> on failure. +L<[perl #128316]|https://rt.perl.org/Public/Bug/Display.html?id=128316> + +=item * + +Parsing bad POSIX charclasses no longer leaks memory. +L<[perl #128313]|https://rt.perl.org/Public/Bug/Display.html?id=128313> + +=item * + +Since Perl 5.20, line numbers have been off by one when perl is invoked with +the B<-x> switch. This has been fixed. +L<[perl #128508]|https://rt.perl.org/Public/Bug/Display.html?id=128508> + +=item * + +Some obscure cases of subroutines and file handles being freed at the same time +could result in crashes, but have been fixed. The crash was introduced in Perl +5.22. +L<[perl #128597]|https://rt.perl.org/Public/Bug/Display.html?id=128597> + +=item * + +Some regular expression parsing glitches could lead to assertion failures with +regular expressions such as C</(?E<lt>=/> and C</(?E<lt>!/>. This has now been +fixed. +L<[perl #128170]|https://rt.perl.org/Public/Bug/Display.html?id=128170> + +=item * + +C<gethostent> and similar functions now perform a null check internally, to +avoid crashing with the torsocks library. This was a regression from Perl +5.22. +L<[perl #128740]|https://rt.perl.org/Public/Bug/Display.html?id=128740> + +=item * + +Mentioning the same constant twice in a row (which is a syntax error) no longer +fails an assertion under debugging builds. This was a regression from Perl +5.20. +L<[perl #126482]|https://rt.perl.org/Public/Bug/Display.html?id=126482> + +=item * + +In Perl 5.24 C<fchown> was changed not to accept negative one as an argument +because in some platforms that is an error. However, in some other platforms +that is an acceptable argument. This change has been reverted. +L<[perl #128967]|https://rt.perl.org/Public/Bug/Display.html?id=128967>. + +=item * + +C<@{x> followed by a newline where C<"x"> represents a control or non-ASCII +character no longer produces a garbled syntax error message or a crash. +L<[perl #128951]|https://rt.perl.org/Public/Bug/Display.html?id=128951> + +=item * + +A regression in Perl 5.24 with C<tr/\N{U+...}/foo/> when the code point was +between 128 and 255 has been fixed. +L<[perl #128734]|https://rt.perl.org/Public/Bug/Display.html?id=128734>. + +=item * + +Many issues relating to C<printf "%a"> of hexadecimal floating point were +fixed. In addition, the "subnormals" (formerly known as "denormals") floating +point numbers are now supported both with the plain IEEE 754 floating point +numbers (64-bit or 128-bit) and the x86 80-bit "extended precision". Note that +subnormal hexadecimal floating point literals will give a warning about +"exponent underflow". +L<[perl #128843]|https://rt.perl.org/Public/Bug/Display.html?id=128843> +L<[perl #128888]|https://rt.perl.org/Public/Bug/Display.html?id=128888> +L<[perl #128889]|https://rt.perl.org/Public/Bug/Display.html?id=128889> +L<[perl #128890]|https://rt.perl.org/Public/Bug/Display.html?id=128890> +L<[perl #128893]|https://rt.perl.org/Public/Bug/Display.html?id=128893> +L<[perl #128909]|https://rt.perl.org/Public/Bug/Display.html?id=128909> +L<[perl #128919]|https://rt.perl.org/Public/Bug/Display.html?id=128919> + +=item * + +The parser could sometimes crash if a bareword came after C<evalbytes>. +L<[perl #129196]|https://rt.perl.org/Public/Bug/Display.html?id=129196> + +=item * + +Fixed a place where the regex parser was not setting the syntax error correctly +on a syntactically incorrect pattern. +L<[perl #129122]|https://rt.perl.org/Public/Bug/Display.html?id=129122> + +=item * + +A vulnerability in Perl's C<sprintf> implementation has been fixed by avoiding +a possible memory wrap. +L<[perl #131260]|https://rt.perl.org/Public/Bug/Display.html?id=131260> + +=back + +=head1 Acknowledgements + +Perl 5.24.3 represents approximately 2 months of development since Perl 5.24.2 +and contains approximately 3,200 lines of changes across 120 files from 23 +authors. + +Excluding auto-generated files, documentation and release tools, there were +approximately 1,600 lines of changes to 56 .pm, .t, .c and .h files. + +Perl continues to flourish into its third decade thanks to a vibrant community +of users and developers. The following people are known to have contributed +the improvements that became Perl 5.24.3: + +Aaron Crane, Craig A. Berry, Dagfinn Ilmari Mannsåker, Dan Collins, Daniel +Dragan, Dave Cross, David Mitchell, Eric Herman, Father Chrysostomos, H.Merijn +Brand, Hugo van der Sanden, James E Keenan, Jarkko Hietaniemi, John SJ +Anderson, Karl Williamson, Ken Brown, Lukas Mai, Matthew Horsfall, Stevan +Little, Steve Hay, Steven Humphrey, Tony Cook, Yves Orton. + +The list above is almost certainly incomplete as it is automatically generated +from version control history. In particular, it does not include the names of +the (very much appreciated) contributors who reported issues to the Perl bug +tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please see +the F<AUTHORS> file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the articles recently +posted to the comp.lang.perl.misc newsgroup and the perl bug database at +L<https://rt.perl.org/> . There may also be information at +L<http://www.perl.org/> , the Perl Home Page. + +If you believe you have an unreported bug, please run the L<perlbug> program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C<perl -V>, +will be sent off to perlbug@perl.org to be analysed by the Perl porting team. + +If the bug you are reporting has security implications which make it +inappropriate to send to a publicly archived mailing list, then see +L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION> for details of how to +report the issue. + +=head1 SEE ALSO + +The F<Changes> file for an explanation of how to view exhaustive details on +what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut diff --git a/gnu/usr.bin/perl/pod/perl5244delta.pod b/gnu/usr.bin/perl/pod/perl5244delta.pod new file mode 100644 index 00000000000..502b0672b89 --- /dev/null +++ b/gnu/usr.bin/perl/pod/perl5244delta.pod @@ -0,0 +1,130 @@ +=encoding utf8 + +=head1 NAME + +perl5244delta - what is new for perl v5.24.4 + +=head1 DESCRIPTION + +This document describes differences between the 5.24.3 release and the 5.24.4 +release. + +If you are upgrading from an earlier release such as 5.24.2, first read +L<perl5243delta>, which describes differences between 5.24.2 and 5.24.3. + +=head1 Security + +=head2 [CVE-2018-6797] heap-buffer-overflow (WRITE of size 1) in S_regatom (regcomp.c) + +A crafted regular expression could cause a heap buffer write overflow, with +control over the bytes written. +L<[perl #132227]|https://rt.perl.org/Public/Bug/Display.html?id=132227> + +=head2 [CVE-2018-6798] Heap-buffer-overflow in Perl__byte_dump_string (utf8.c) + +Matching a crafted locale dependent regular expression could cause a heap +buffer read overflow and potentially information disclosure. +L<[perl #132063]|https://rt.perl.org/Public/Bug/Display.html?id=132063> + +=head2 [CVE-2018-6913] heap-buffer-overflow in S_pack_rec + +C<pack()> could cause a heap buffer write overflow with a large item count. +L<[perl #131844]|https://rt.perl.org/Public/Bug/Display.html?id=131844> + +=head2 Assertion failure in Perl__core_swash_init (utf8.c) + +Control characters in a supposed Unicode property name could cause perl to +crash. This has been fixed. +L<[perl #132055]|https://rt.perl.org/Public/Bug/Display.html?id=132055> +L<[perl #132553]|https://rt.perl.org/Public/Bug/Display.html?id=132553> +L<[perl #132658]|https://rt.perl.org/Public/Bug/Display.html?id=132658> + +=head1 Incompatible Changes + +There are no changes intentionally incompatible with 5.24.3. If any exist, +they are bugs, and we request that you submit a report. See L</Reporting +Bugs> below. + +=head1 Modules and Pragmata + +=head2 Updated Modules and Pragmata + +=over 4 + +=item * + +L<Module::CoreList> has been upgraded from version 5.20170922_24 to 5.20180414_24. + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +The C<readpipe()> built-in function now checks at compile time that it has only +one parameter expression, and puts it in scalar context, thus ensuring that it +doesn't corrupt the stack at runtime. +L<[perl #4574]|https://rt.perl.org/Public/Bug/Display.html?id=4574> + +=back + +=head1 Acknowledgements + +Perl 5.24.4 represents approximately 7 months of development since Perl 5.24.3 +and contains approximately 2,400 lines of changes across 49 files from 12 +authors. + +Excluding auto-generated files, documentation and release tools, there were +approximately 1,300 lines of changes to 12 .pm, .t, .c and .h files. + +Perl continues to flourish into its third decade thanks to a vibrant community +of users and developers. The following people are known to have contributed +the improvements that became Perl 5.24.4: + +Abigail, Chris 'BinGOs' Williams, John SJ Anderson, Karen Etheridge, Karl +Williamson, Renee Baecker, Sawyer X, Steve Hay, Todd Rinaldo, Tony Cook, Yves +Orton, Zefram. + +The list above is almost certainly incomplete as it is automatically generated +from version control history. In particular, it does not include the names of +the (very much appreciated) contributors who reported issues to the Perl bug +tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please see +the F<AUTHORS> file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the articles recently +posted to the comp.lang.perl.misc newsgroup and the perl bug database at +L<https://rt.perl.org/> . There may also be information at +L<http://www.perl.org/> , the Perl Home Page. + +If you believe you have an unreported bug, please run the L<perlbug> program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C<perl -V>, +will be sent off to perlbug@perl.org to be analysed by the Perl porting team. + +If the bug you are reporting has security implications which make it +inappropriate to send to a publicly archived mailing list, then see +L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION> +for details of how to report the issue. + +=head1 SEE ALSO + +The F<Changes> file for an explanation of how to view exhaustive details on +what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut diff --git a/gnu/usr.bin/perl/pod/perl5260delta.pod b/gnu/usr.bin/perl/pod/perl5260delta.pod new file mode 100644 index 00000000000..a2a1484dbe4 --- /dev/null +++ b/gnu/usr.bin/perl/pod/perl5260delta.pod @@ -0,0 +1,3334 @@ +=encoding utf8 + +=head1 NAME + +perl5260delta - what is new for perl v5.26.0 + +=head1 DESCRIPTION + +This document describes the differences between the 5.24.0 release and the +5.26.0 release. + +=head1 Notice + +This release includes three updates with widespread effects: + +=over 4 + +=item * C<"."> no longer in C<@INC> + +For security reasons, the current directory (C<".">) is no longer included +by default at the end of the module search path (C<@INC>). This may have +widespread implications for the building, testing and installing of +modules, and for the execution of scripts. See the section +L<< Removal of the current directory (C<".">) from C<@INC> >> +for the full details. + +=item * C<do> may now warn + +C<do> now gives a deprecation warning when it fails to load a file which +it would have loaded had C<"."> been in C<@INC>. + +=item * In regular expression patterns, a literal left brace C<"{"> +should be escaped + +See L</Unescaped literal C<"{"> characters in regular expression patterns are no longer permissible>. + +=back + +=head1 Core Enhancements + +=head2 Lexical subroutines are no longer experimental + +Using the C<lexical_subs> feature introduced in v5.18 no longer emits a warning. Existing +code that disables the C<experimental::lexical_subs> warning category +that the feature previously used will continue to work. The +C<lexical_subs> feature has no effect; all Perl code can use lexical +subroutines, regardless of what feature declarations are in scope. + +=head2 Indented Here-documents + +This adds a new modifier C<"~"> to here-docs that tells the parser +that it should look for C</^\s*$DELIM\n/> as the closing delimiter. + +These syntaxes are all supported: + + <<~EOF; + <<~\EOF; + <<~'EOF'; + <<~"EOF"; + <<~`EOF`; + <<~ 'EOF'; + <<~ "EOF"; + <<~ `EOF`; + +The C<"~"> modifier will strip, from each line in the here-doc, the +same whitespace that appears before the delimiter. + +Newlines will be copied as-is, and lines that don't include the +proper beginning whitespace will cause perl to croak. + +For example: + + if (1) { + print <<~EOF; + Hello there + EOF + } + +prints "Hello there\n" with no leading whitespace. + +=head2 New regular expression modifier C</xx> + +Specifying two C<"x"> characters to modify a regular expression pattern +does everything that a single one does, but additionally TAB and SPACE +characters within a bracketed character class are generally ignored and +can be added to improve readability, like +S<C</[ ^ A-Z d-f p-x ]/xx>>. Details are at +L<perlre/E<sol>x and E<sol>xx>. + +=head2 C<@{^CAPTURE}>, C<%{^CAPTURE}>, and C<%{^CAPTURE_ALL}> + +C<@{^CAPTURE}> exposes the capture buffers of the last match as an +array. So C<$1> is C<${^CAPTURE}[0]>. This is a more efficient equivalent +to code like C<substr($matched_string,$-[0],$+[0]-$-[0])>, and you don't +have to keep track of the C<$matched_string> either. This variable has no +single character equivalent. Note that, like the other regex magic variables, +the contents of this variable is dynamic; if you wish to store it beyond +the lifetime of the match you must copy it to another array. + +C<%{^CAPTURE}> is equivalent to C<%+> (I<i.e.>, named captures). Other than +being more self-documenting there is no difference between the two forms. + +C<%{^CAPTURE_ALL}> is equivalent to C<%-> (I<i.e.>, all named captures). +Other than being more self-documenting there is no difference between the +two forms. + +=head2 Declaring a reference to a variable + +As an experimental feature, Perl now allows the referencing operator to come +after L<C<my()>|perlfunc/my>, L<C<state()>|perlfunc/state>, +L<C<our()>|perlfunc/our>, or L<C<local()>|perlfunc/local>. This syntax must +be enabled with C<use feature 'declared_refs'>. It is experimental, and will +warn by default unless C<no warnings 'experimental::refaliasing'> is in effect. +It is intended mainly for use in assignments to references. For example: + + use experimental 'refaliasing', 'declared_refs'; + my \$a = \$b; + +See L<perlref/Assigning to References> for more details. + +=head2 Unicode 9.0 is now supported + +A list of changes is at L<http://www.unicode.org/versions/Unicode9.0.0/>. +Modules that are shipped with core Perl but not maintained by p5p do not +necessarily support Unicode 9.0. L<Unicode::Normalize> does work on 9.0. + +=head2 Use of C<\p{I<script>}> uses the improved Script_Extensions property + +Unicode 6.0 introduced an improved form of the Script (C<sc>) property, and +called it Script_Extensions (C<scx>). Perl now uses this improved +version when a property is specified as just C<\p{I<script>}>. This +should make programs more accurate when determining if a character is +used in a given script, but there is a slight chance of breakage for +programs that very specifically needed the old behavior. The meaning of +compound forms, like C<\p{sc=I<script>}> are unchanged. See +L<perlunicode/Scripts>. + +=head2 Perl can now do default collation in UTF-8 locales on platforms +that support it + +Some platforms natively do a reasonable job of collating and sorting in +UTF-8 locales. Perl now works with those. For portability and full +control, L<Unicode::Collate> is still recommended, but now you may +not need to do anything special to get good-enough results, depending on +your application. See +L<perllocale/Category C<LC_COLLATE>: Collation: Text Comparisons and Sorting>. + +=head2 Better locale collation of strings containing embedded C<NUL> +characters + +In locales that have multi-level character weights, C<NUL>s are now +ignored at the higher priority ones. There are still some gotchas in +some strings, though. See +L<perllocale/Collation of strings containing embedded C<NUL> characters>. + +=head2 C<CORE> subroutines for hash and array functions callable via +reference + +The hash and array functions in the C<CORE> namespace (C<keys>, C<each>, +C<values>, C<push>, C<pop>, C<shift>, C<unshift> and C<splice>) can now +be called with ampersand syntax (C<&CORE::keys(\%hash>) and via reference +(C<< my $k = \&CORE::keys; $k-E<gt>(\%hash) >>). Previously they could only be +used when inlined. + +=head2 New Hash Function For 64-bit Builds + +We have switched to a hybrid hash function to better balance +performance for short and long keys. + +For short keys, 16 bytes and under, we use an optimised variant of +One At A Time Hard, and for longer keys we use Siphash 1-3. For very +long keys this is a big improvement in performance. For shorter keys +there is a modest improvement. + +=head1 Security + +=head2 Removal of the current directory (C<".">) from C<@INC> + +The perl binary includes a default set of paths in C<@INC>. Historically +it has also included the current directory (C<".">) as the final entry, +unless run with taint mode enabled (C<perl -T>). While convenient, this has +security implications: for example, where a script attempts to load an +optional module when its current directory is untrusted (such as F</tmp>), +it could load and execute code from under that directory. + +Starting with v5.26, C<"."> is always removed by default, not just under +tainting. This has major implications for installing modules and executing +scripts. + +The following new features have been added to help ameliorate these +issues. + +=over + +=item * F<Configure -Udefault_inc_excludes_dot> + +There is a new F<Configure> option, C<default_inc_excludes_dot> (enabled +by default) which builds a perl executable without C<".">; unsetting this +option using C<-U> reverts perl to the old behaviour. This may fix your +path issues but will reintroduce all the security concerns, so don't +build a perl executable like this unless you're I<really> confident that +such issues are not a concern in your environment. + +=item * C<PERL_USE_UNSAFE_INC> + +There is a new environment variable recognised by the perl interpreter. +If this variable has the value 1 when the perl interpreter starts up, +then C<"."> will be automatically appended to C<@INC> (except under tainting). + +This allows you restore the old perl interpreter behaviour on a +case-by-case basis. But note that this is intended to be a temporary crutch, +and this feature will likely be removed in some future perl version. +It is currently set by the C<cpan> utility and C<Test::Harness> to +ease installation of CPAN modules which have not been updated to handle the +lack of dot. Once again, don't use this unless you are sure that this +will not reintroduce any security concerns. + +=item * A new deprecation warning issued by C<do>. + +While it is well-known that C<use> and C<require> use C<@INC> to search +for the file to load, many people don't realise that C<do "file"> also +searches C<@INC> if the file is a relative path. With the removal of C<".">, +a simple C<do "file.pl"> will fail to read in and execute C<file.pl> from +the current directory. Since this is commonly expected behaviour, a new +deprecation warning is now issued whenever C<do> fails to load a file which +it otherwise would have found if a dot had been in C<@INC>. + +=back + +Here are some things script and module authors may need to do to make +their software work in the new regime. + +=over + +=item * Script authors + +If the issue is within your own code (rather than within included +modules), then you have two main options. Firstly, if you are confident +that your script will only be run within a trusted directory (under which +you expect to find trusted files and modules), then add C<"."> back into the +path; I<e.g.>: + + BEGIN { + my $dir = "/some/trusted/directory"; + chdir $dir or die "Can't chdir to $dir: $!\n"; + # safe now + push @INC, '.'; + } + + use "Foo::Bar"; # may load /some/trusted/directory/Foo/Bar.pm + do "config.pl"; # may load /some/trusted/directory/config.pl + +On the other hand, if your script is intended to be run from within +untrusted directories (such as F</tmp>), then your script suddenly failing +to load files may be indicative of a security issue. You most likely want +to replace any relative paths with full paths; for example, + + do "foo_config.pl" + +might become + + do "$ENV{HOME}/foo_config.pl" + +If you are absolutely certain that you want your script to load and +execute a file from the current directory, then use a C<./> prefix; for +example: + + do "./foo_config.pl" + +=item * Installing and using CPAN modules + +If you install a CPAN module using an automatic tool like C<cpan>, then +this tool will itself set the C<PERL_USE_UNSAFE_INC> environment variable +while building and testing the module, which may be sufficient to install +a distribution which hasn't been updated to be dot-aware. If you want to +install such a module manually, then you'll need to replace the +traditional invocation: + + perl Makefile.PL && make && make test && make install + +with something like + + (export PERL_USE_UNSAFE_INC=1; \ + perl Makefile.PL && make && make test && make install) + +Note that this only helps build and install an unfixed module. It's +possible for the tests to pass (since they were run under +C<PERL_USE_UNSAFE_INC=1>), but for the module itself to fail to perform +correctly in production. In this case, you may have to temporarily modify +your script until a fixed version of the module is released. +For example: + + use Foo::Bar; + { + local @INC = (@INC, '.'); + # assuming read_config() needs '.' in @INC + $config = Foo::Bar->read_config(); + } + +This is only rarely expected to be necessary. Again, if doing this, +assess the resultant risks first. + +=item * Module Authors + +If you maintain a CPAN distribution, it may need updating to run in +a dotless environment. Although C<cpan> and other such tools will +currently set the C<PERL_USE_UNSAFE_INC> during module build, this is a +temporary workaround for the set of modules which rely on C<"."> being in +C<@INC> for installation and testing, and this may mask deeper issues. It +could result in a module which passes tests and installs, but which +fails at run time. + +During build, test, and install, it will normally be the case that any perl +processes will be executing directly within the root directory of the +untarred distribution, or a known subdirectory of that, such as F<t/>. It +may well be that F<Makefile.PL> or F<t/foo.t> will attempt to include +local modules and configuration files using their direct relative +filenames, which will now fail. + +However, as described above, automatic tools like F<cpan> will (for now) +set the C<PERL_USE_UNSAFE_INC> environment variable, which introduces +dot during a build. + +This makes it likely that your existing build and test code will work, but +this may mask issues with your code which only manifest when used after +install. It is prudent to try and run your build process with that +variable explicitly disabled: + + (export PERL_USE_UNSAFE_INC=0; \ + perl Makefile.PL && make && make test && make install) + +This is more likely to show up any potential problems with your module's +build process, or even with the module itself. Fixing such issues will +ensure both that your module can again be installed manually, and that +it will still build once the C<PERL_USE_UNSAFE_INC> crutch goes away. + +When fixing issues in tests due to the removal of dot from C<@INC>, +reinsertion of dot into C<@INC> should be performed with caution, for this +too may suppress real errors in your runtime code. You are encouraged +wherever possible to apply the aforementioned approaches with explicit +absolute/relative paths, or to relocate your needed files into a +subdirectory and insert that subdirectory into C<@INC> instead. + +If your runtime code has problems under the dotless C<@INC>, then the comments +above on how to fix for script authors will mostly apply here too. Bear in +mind though that it is considered bad form for a module to globally add a dot to +C<@INC>, since it introduces both a security risk and hides issues of +accidentally requiring dot in C<@INC>, as explained above. + +=back + +=head2 Escaped colons and relative paths in PATH + +On Unix systems, Perl treats any relative paths in the C<PATH> environment +variable as tainted when starting a new process. Previously, it was +allowing a backslash to escape a colon (unlike the OS), consequently +allowing relative paths to be considered safe if the PATH was set to +something like C</\:.>. The check has been fixed to treat C<"."> as tainted +in that example. + +=head2 New C<-Di> switch is now required for PerlIO debugging output + +This is used for debugging of code within PerlIO to avoid recursive +calls. Previously this output would be sent to the file specified +by the C<PERLIO_DEBUG> environment variable if perl wasn't running +setuid and the C<-T> or C<-t> switches hadn't been parsed yet. + +If perl performed output at a point where it hadn't yet parsed its +switches this could result in perl creating or overwriting the file +named by C<PERLIO_DEBUG> even when the C<-T> switch had been supplied. + +Perl now requires the C<-Di> switch to be present before it will produce +PerlIO debugging +output. By default this is written to C<stderr>, but can optionally +be redirected to a file by setting the C<PERLIO_DEBUG> environment +variable. + +If perl is running setuid or the C<-T> switch was supplied, +C<PERLIO_DEBUG> is ignored and the debugging output is sent to +C<stderr> as for any other C<-D> switch. + +=head1 Incompatible Changes + +=head2 Unescaped literal C<"{"> characters in regular expression +patterns are no longer permissible + +You have to now say something like C<"\{"> or C<"[{]"> to specify to +match a LEFT CURLY BRACKET; otherwise, it is a fatal pattern compilation +error. This change will allow future extensions to the language. + +These have been deprecated since v5.16, with a deprecation message +raised for some uses starting in v5.22. Unfortunately, the code added +to raise the message was buggy and failed to warn in some cases where +it should have. Therefore, enforcement of this ban for these cases is +deferred until Perl 5.30, but the code has been fixed to raise a +default-on deprecation message for them in the meantime. + +Some uses of literal C<"{"> occur in contexts where we do not foresee +the meaning ever being anything but the literal, such as the very first +character in the pattern, or after a C<"|"> meaning alternation. Thus + + qr/{fee|{fie/ + +matches either of the strings C<{fee> or C<{fie>. To avoid forcing +unnecessary code changes, these uses do not need to be escaped, and no +warning is raised about them, and there are no current plans to change this. + +But it is always correct to escape C<"{">, and the simple rule to +remember is to always do so. + +See L<Unescaped left brace in regex is illegal here|perldiag/Unescaped left brace in regex is illegal here in regex; marked by S<E<lt>-- HERE> in mE<sol>%sE<sol>>. + +=head2 C<scalar(%hash)> return signature changed + +The value returned for C<scalar(%hash)> will no longer show information about +the buckets allocated in the hash. It will simply return the count of used +keys. It is thus equivalent to C<0+keys(%hash)>. + +A form of backward compatibility is provided via +L<C<Hash::Util::bucket_ratio()>|Hash::Util/bucket_ratio> which provides +the same behavior as +C<scalar(%hash)> provided in Perl 5.24 and earlier. + +=head2 C<keys> returned from an lvalue subroutine + +C<keys> returned from an lvalue subroutine can no longer be assigned +to in list context. + + sub foo : lvalue { keys(%INC) } + (foo) = 3; # death + sub bar : lvalue { keys(@_) } + (bar) = 3; # also an error + +This makes the lvalue sub case consistent with C<(keys %hash) = ...> and +C<(keys @_) = ...>, which are also errors. +L<[perl #128187]|https://rt.perl.org/Public/Bug/Display.html?id=128187> + +=head2 The C<${^ENCODING}> facility has been removed + +The special behaviour associated with assigning a value to this variable +has been removed. As a consequence, the L<encoding> pragma's default mode +is no longer supported. If +you still need to write your source code in encodings other than UTF-8, use a +source filter such as L<Filter::Encoding> on CPAN or L<encoding>'s C<Filter> +option. + +=head2 C<POSIX::tmpnam()> has been removed + +The fundamentally unsafe C<tmpnam()> interface was deprecated in +Perl 5.22 and has now been removed. In its place, you can use, +for example, the L<File::Temp> interfaces. + +=head2 require ::Foo::Bar is now illegal. + +Formerly, C<require ::Foo::Bar> would try to read F</Foo/Bar.pm>. Now any +bareword require which starts with a double colon dies instead. + +=head2 Literal control character variable names are no longer permissible + +A variable name may no longer contain a literal control character under +any circumstances. These previously were allowed in single-character +names on ASCII platforms, but have been deprecated there since Perl +5.20. This affects things like C<$I<\cT>>, where I<\cT> is a literal +control (such as a C<NAK> or C<NEGATIVE ACKNOWLEDGE> character) in the +source code. + +=head2 C<NBSP> is no longer permissible in C<\N{...}> + +The name of a character may no longer contain non-breaking spaces. It +has been deprecated to do so since Perl 5.22. + +=head1 Deprecations + +=head2 String delimiters that aren't stand-alone graphemes are now deprecated + +For Perl to eventually allow string delimiters to be Unicode +grapheme clusters (which look like a single character, but may be +a sequence of several ones), we have to stop allowing a single character +delimiter that isn't a grapheme by itself. These are unlikely to exist +in actual code, as they would typically display as attached to the +character in front of them. + +=head2 C<\cI<X>> that maps to a printable is no longer deprecated + +This means we have no plans to remove this feature. It still raises a +warning, but only if syntax warnings are enabled. The feature was +originally intended to be a way to express non-printable characters that +don't have a mnemonic (C<\t> and C<\n> are mnemonics for two +non-printable characters, but most non-printables don't have a +mnemonic.) But the feature can be used to specify a few printable +characters, though those are more clearly expressed as the printable +itself. See +L<http://www.nntp.perl.org/group/perl.perl5.porters/2017/02/msg242944.html>. + +=head1 Performance Enhancements + +=over 4 + +=item * + +A hash in boolean context is now sometimes faster, I<e.g.> + + if (!%h) { ... } + +This was already special-cased, but some cases were missed (such as +C<grep %$_, @AoH>), and even the ones which weren't have been improved. + +=item * New Faster Hash Function on 64 bit builds + +We use a different hash function for short and long keys. This should +improve performance and security, especially for long keys. + +=item * readline is faster + +Reading from a file line-by-line with C<readline()> or C<< E<lt>E<gt> >> should +now typically be faster due to a better implementation of the code that +searches for the next newline character. + +=item * + +Assigning one reference to another, I<e.g.> C<$ref1 = $ref2> has been +optimized in some cases. + +=item * + +Remove some exceptions to creating Copy-on-Write strings. The string +buffer growth algorithm has been slightly altered so that you're less +likely to encounter a string which can't be COWed. + +=item * + +Better optimise array and hash assignment: where an array or hash appears +in the LHS of a list assignment, such as C<(..., @a) = (...);>, it's +likely to be considerably faster, especially if it involves emptying the +array/hash. For example, this code runs about a third faster compared to +Perl 5.24.0: + + my @a; + for my $i (1..10_000_000) { + @a = (1,2,3); + @a = (); + } + +=item * + +Converting a single-digit string to a number is now substantially faster. + +=item * + +The C<split> builtin is now slightly faster in many cases: in particular +for the two specially-handled forms + + my @a = split ...; + local @a = split ...; + +=item * + +The rather slow implementation for the experimental subroutine signatures +feature has been made much faster; it is now comparable in speed with the +traditional C<my ($a, $b, @c) = @_>. + +=item * + +Bareword constant strings are now permitted to take part in constant +folding. They were originally exempted from constant folding in August 1999, +during the development of Perl 5.6, to ensure that C<use strict "subs"> +would still apply to bareword constants. That has now been accomplished a +different way, so barewords, like other constants, now gain the performance +benefits of constant folding. + +This also means that void-context warnings on constant expressions of +barewords now report the folded constant operand, rather than the operation; +this matches the behaviour for non-bareword constants. + +=back + +=head1 Modules and Pragmata + +=head2 Updated Modules and Pragmata + +=over 4 + +=item * + +IO::Compress has been upgraded from version 2.069 to 2.074. + +=item * + +L<Archive::Tar> has been upgraded from version 2.04 to 2.24. + +=item * + +L<arybase> has been upgraded from version 0.11 to 0.12. + +=item * + +L<attributes> has been upgraded from version 0.27 to 0.29. + +The deprecation message for the C<:unique> and C<:locked> attributes +now mention that they will disappear in Perl 5.28. + +=item * + +L<B> has been upgraded from version 1.62 to 1.68. + +=item * + +L<B::Concise> has been upgraded from version 0.996 to 0.999. + +Its output is now more descriptive for C<op_private> flags. + +=item * + +L<B::Debug> has been upgraded from version 1.23 to 1.24. + +=item * + +L<B::Deparse> has been upgraded from version 1.37 to 1.40. + +=item * + +L<B::Xref> has been upgraded from version 1.05 to 1.06. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<base> has been upgraded from version 2.23 to 2.25. + +=item * + +L<bignum> has been upgraded from version 0.42 to 0.47. + +=item * + +L<Carp> has been upgraded from version 1.40 to 1.42. + +=item * + +L<charnames> has been upgraded from version 1.43 to 1.44. + +=item * + +L<Compress::Raw::Bzip2> has been upgraded from version 2.069 to 2.074. + +=item * + +L<Compress::Raw::Zlib> has been upgraded from version 2.069 to 2.074. + +=item * + +L<Config::Perl::V> has been upgraded from version 0.25 to 0.28. + +=item * + +L<CPAN> has been upgraded from version 2.11 to 2.18. + +=item * + +L<CPAN::Meta> has been upgraded from version 2.150005 to 2.150010. + +=item * + +L<Data::Dumper> has been upgraded from version 2.160 to 2.167. + +The XS implementation now supports Deparse. + +=item * + +L<DB_File> has been upgraded from version 1.835 to 1.840. + +=item * + +L<Devel::Peek> has been upgraded from version 1.23 to 1.26. + +=item * + +L<Devel::PPPort> has been upgraded from version 3.32 to 3.35. + +=item * + +L<Devel::SelfStubber> has been upgraded from version 1.05 to 1.06. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<diagnostics> has been upgraded from version 1.34 to 1.36. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<Digest> has been upgraded from version 1.17 to 1.17_01. + +=item * + +L<Digest::MD5> has been upgraded from version 2.54 to 2.55. + +=item * + +L<Digest::SHA> has been upgraded from version 5.95 to 5.96. + +=item * + +L<DynaLoader> has been upgraded from version 1.38 to 1.42. + +=item * + +L<Encode> has been upgraded from version 2.80 to 2.88. + +=item * + +L<encoding> has been upgraded from version 2.17 to 2.19. + +This module's default mode is no longer supported. It now +dies when imported, unless the C<Filter> option is being used. + +=item * + +L<encoding::warnings> has been upgraded from version 0.12 to 0.13. + +This module is no longer supported. It emits a warning to +that effect and then does nothing. + +=item * + +L<Errno> has been upgraded from version 1.25 to 1.28. + +It now documents that using C<%!> automatically loads Errno for you. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<ExtUtils::Embed> has been upgraded from version 1.33 to 1.34. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<ExtUtils::MakeMaker> has been upgraded from version 7.10_01 to 7.24. + +=item * + +L<ExtUtils::Miniperl> has been upgraded from version 1.05 to 1.06. + +=item * + +L<ExtUtils::ParseXS> has been upgraded from version 3.31 to 3.34. + +=item * + +L<ExtUtils::Typemaps> has been upgraded from version 3.31 to 3.34. + +=item * + +L<feature> has been upgraded from version 1.42 to 1.47. + +=item * + +L<File::Copy> has been upgraded from version 2.31 to 2.32. + +=item * + +L<File::Fetch> has been upgraded from version 0.48 to 0.52. + +=item * + +L<File::Glob> has been upgraded from version 1.26 to 1.28. + +It now Issues a deprecation message for C<File::Glob::glob()>. + +=item * + +L<File::Spec> has been upgraded from version 3.63 to 3.67. + +=item * + +L<FileHandle> has been upgraded from version 2.02 to 2.03. + +=item * + +L<Filter::Simple> has been upgraded from version 0.92 to 0.93. + +It no longer treats C<no MyFilter> immediately following C<use MyFilter> as +end-of-file. +L<[perl #107726]|https://rt.perl.org/Public/Bug/Display.html?id=107726> + +=item * + +L<Getopt::Long> has been upgraded from version 2.48 to 2.49. + +=item * + +L<Getopt::Std> has been upgraded from version 1.11 to 1.12. + +=item * + +L<Hash::Util> has been upgraded from version 0.19 to 0.22. + +=item * + +L<HTTP::Tiny> has been upgraded from version 0.056 to 0.070. + +Internal 599-series errors now include the redirect history. + +=item * + +L<I18N::LangTags> has been upgraded from version 0.40 to 0.42. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<IO> has been upgraded from version 1.36 to 1.38. + +=item * + +L<IO::Socket::IP> has been upgraded from version 0.37 to 0.38. + +=item * + +L<IPC::Cmd> has been upgraded from version 0.92 to 0.96. + +=item * + +L<IPC::SysV> has been upgraded from version 2.06_01 to 2.07. + +=item * + +L<JSON::PP> has been upgraded from version 2.27300 to 2.27400_02. + +=item * + +L<lib> has been upgraded from version 0.63 to 0.64. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<List::Util> has been upgraded from version 1.42_02 to 1.46_02. + +=item * + +L<Locale::Codes> has been upgraded from version 3.37 to 3.42. + +=item * + +L<Locale::Maketext> has been upgraded from version 1.26 to 1.28. + +=item * + +L<Locale::Maketext::Simple> has been upgraded from version 0.21 to 0.21_01. + +=item * + +L<Math::BigInt> has been upgraded from version 1.999715 to 1.999806. + +=item * + +L<Math::BigInt::FastCalc> has been upgraded from version 0.40 to 0.5005. + +=item * + +L<Math::BigRat> has been upgraded from version 0.260802 to 0.2611. + +=item * + +L<Math::Complex> has been upgraded from version 1.59 to 1.5901. + +=item * + +L<Memoize> has been upgraded from version 1.03 to 1.03_01. + +=item * + +L<Module::CoreList> has been upgraded from version 5.20170420 to 5.20170530. + +=item * + +L<Module::Load::Conditional> has been upgraded from version 0.64 to 0.68. + +=item * + +L<Module::Metadata> has been upgraded from version 1.000031 to 1.000033. + +=item * + +L<mro> has been upgraded from version 1.18 to 1.20. + +=item * + +L<Net::Ping> has been upgraded from version 2.43 to 2.55. + +IPv6 addresses and C<AF_INET6> sockets are now supported, along with several +other enhancements. + +=item * + +L<NEXT> has been upgraded from version 0.65 to 0.67. + +=item * + +L<Opcode> has been upgraded from version 1.34 to 1.39. + +=item * + +L<open> has been upgraded from version 1.10 to 1.11. + +=item * + +L<OS2::Process> has been upgraded from version 1.11 to 1.12. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<overload> has been upgraded from version 1.26 to 1.28. + +Its compilation speed has been improved slightly. + +=item * + +L<parent> has been upgraded from version 0.234 to 0.236. + +=item * + +L<perl5db.pl> has been upgraded from version 1.50 to 1.51. + +It now ignores F</dev/tty> on non-Unix systems. +L<[perl #113960]|https://rt.perl.org/Public/Bug/Display.html?id=113960> + +=item * + +L<Perl::OSType> has been upgraded from version 1.009 to 1.010. + +=item * + +L<perlfaq> has been upgraded from version 5.021010 to 5.021011. + +=item * + +L<PerlIO> has been upgraded from version 1.09 to 1.10. + +=item * + +L<PerlIO::encoding> has been upgraded from version 0.24 to 0.25. + +=item * + +L<PerlIO::scalar> has been upgraded from version 0.24 to 0.26. + +=item * + +L<Pod::Checker> has been upgraded from version 1.60 to 1.73. + +=item * + +L<Pod::Functions> has been upgraded from version 1.10 to 1.11. + +=item * + +L<Pod::Html> has been upgraded from version 1.22 to 1.2202. + +=item * + +L<Pod::Perldoc> has been upgraded from version 3.25_02 to 3.28. + +=item * + +L<Pod::Simple> has been upgraded from version 3.32 to 3.35. + +=item * + +L<Pod::Usage> has been upgraded from version 1.68 to 1.69. + +=item * + +L<POSIX> has been upgraded from version 1.65 to 1.76. + +This remedies several defects in making its symbols exportable. +L<[perl #127821]|https://rt.perl.org/Public/Bug/Display.html?id=127821> + +The C<POSIX::tmpnam()> interface has been removed, +see L</"POSIX::tmpnam() has been removed">. + +The following deprecated functions have been removed: + + POSIX::isalnum + POSIX::isalpha + POSIX::iscntrl + POSIX::isdigit + POSIX::isgraph + POSIX::islower + POSIX::isprint + POSIX::ispunct + POSIX::isspace + POSIX::isupper + POSIX::isxdigit + POSIX::tolower + POSIX::toupper + +Trying to import POSIX subs that have no real implementations +(like C<POSIX::atend()>) now fails at import time, instead of +waiting until runtime. + +=item * + +L<re> has been upgraded from version 0.32 to 0.34 + +This adds support for the new L<C<E<47>xx>|perlre/E<sol>x and E<sol>xx> +regular expression pattern modifier, and a change to the L<S<C<use re +'strict'>>|re/'strict' mode> experimental feature. When S<C<re +'strict'>> is enabled, a warning now will be generated for all +unescaped uses of the two characters C<"}"> and C<"]"> in regular +expression patterns (outside bracketed character classes) that are taken +literally. This brings them more in line with the C<")"> character which +is always a metacharacter unless escaped. Being a metacharacter only +sometimes, depending on an action at a distance, can lead to silently +having the pattern mean something quite different than was intended, +which the S<C<re 'strict'>> mode is intended to minimize. + +=item * + +L<Safe> has been upgraded from version 2.39 to 2.40. + +=item * + +L<Scalar::Util> has been upgraded from version 1.42_02 to 1.46_02. + +=item * + +L<Storable> has been upgraded from version 2.56 to 2.62. + +Fixes +L<[perl #130098]|https://rt.perl.org/Public/Bug/Display.html?id=130098>. + +=item * + +L<Symbol> has been upgraded from version 1.07 to 1.08. + +=item * + +L<Sys::Syslog> has been upgraded from version 0.33 to 0.35. + +=item * + +L<Term::ANSIColor> has been upgraded from version 4.04 to 4.06. + +=item * + +L<Term::ReadLine> has been upgraded from version 1.15 to 1.16. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<Test> has been upgraded from version 1.28 to 1.30. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<Test::Harness> has been upgraded from version 3.36 to 3.38. + +=item * + +L<Test::Simple> has been upgraded from version 1.001014 to 1.302073. + +=item * + +L<Thread::Queue> has been upgraded from version 3.09 to 3.12. + +=item * + +L<Thread::Semaphore> has been upgraded from 2.12 to 2.13. + +Added the C<down_timed> method. + +=item * + +L<threads> has been upgraded from version 2.07 to 2.15. + +=item * + +L<threads::shared> has been upgraded from version 1.51 to 1.56. + +=item * + +L<Tie::Hash::NamedCapture> has been upgraded from version 0.09 to 0.10. + +=item * + +L<Time::HiRes> has been upgraded from version 1.9733 to 1.9741. + +It now builds on systems with C++11 compilers (such as G++ 6 and Clang++ +3.9). + +Now uses C<clockid_t>. + +=item * + +L<Time::Local> has been upgraded from version 1.2300 to 1.25. + +=item * + +L<Unicode::Collate> has been upgraded from version 1.14 to 1.19. + +=item * + +L<Unicode::UCD> has been upgraded from version 0.64 to 0.68. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<version> has been upgraded from version 0.9916 to 0.9917. + +=item * + +L<VMS::DCLsym> has been upgraded from version 1.06 to 1.08. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=item * + +L<warnings> has been upgraded from version 1.36 to 1.37. + +=item * + +L<XS::Typemap> has been upgraded from version 0.14 to 0.15. + +=item * + +L<XSLoader> has been upgraded from version 0.21 to 0.27. + +Fixed a security hole in which binary files could be loaded from a path +outside of L<C<@INC>|perlvar/@INC>. + +It now uses 3-arg C<open()> instead of 2-arg C<open()>. +L<[perl #130122]|https://rt.perl.org/Public/Bug/Display.html?id=130122> + +=back + +=head1 Documentation + +=head2 New Documentation + +=head3 L<perldeprecation> + +This file documents all upcoming deprecations, and some of the deprecations +which already have been removed. The purpose of this documentation is +two-fold: document what will disappear, and by which version, and serve +as a guide for people dealing with code which has features that no longer +work after an upgrade of their perl. + +=head2 Changes to Existing Documentation + +We have attempted to update the documentation to reflect the changes +listed in this document. If you find any we have missed, send email to +L<perlbug@perl.org|mailto:perlbug@perl.org>. + +Additionally, all references to Usenet have been removed, and the +following selected changes have been made: + +=head3 L<perlfunc> + +=over 4 + +=item * + +Removed obsolete text about L<C<defined()>|perlfunc/defined> +on aggregates that should have been deleted earlier, when the feature +was removed. + +=item * + +Corrected documentation of L<C<eval()>|perlfunc/eval>, +and L<C<evalbytes()>|perlfunc/evalbytes>. + +=item * + +Clarified documentation of L<C<seek()>|perlfunc/seek>, +L<C<tell()>|perlfunc/tell> and L<C<sysseek()>|perlfunc/sysseek> +emphasizing that positions are in bytes and not characters. +L<[perl #128607]|https://rt.perl.org/Public/Bug/Display.html?id=128607> + +=item * + +Clarified documentation of L<C<sort()>|perlfunc/sort LIST> concerning +the variables C<$a> and C<$b>. + +=item * + +In L<C<split()>|perlfunc/split> noted that certain pattern modifiers are +legal, and added a caution about its use in Perls before v5.11. + +=item * + +Removed obsolete documentation of L<C<study()>|perlfunc/study>, noting +that it is now a no-op. + +=item * + +Noted that L<C<vec()>|perlfunc/vec> doesn't work well when the string +contains characters whose code points are above 255. + +=back + +=head3 L<perlguts> + +=over 4 + +=item * + +Added advice on +L<formatted printing of operands of C<Size_t> and C<SSize_t>|perlguts/Formatted Printing of Size_t and SSize_t> + +=back + +=head3 L<perlhack> + +=over 4 + +=item * + +Clarify what editor tab stop rules to use, and note that we are +migrating away from using tabs, replacing them with sequences of SPACE +characters. + +=back + +=head3 L<perlhacktips> + +=over 4 + +=item * + +Give another reason to use C<cBOOL> to cast an expression to boolean. + +=item * + +Note that the macros C<TRUE> and C<FALSE> are available to express +boolean values. + +=back + +=head3 L<perlinterp> + +=over 4 + +=item * + +L<perlinterp> has been expanded to give a more detailed example of how to +hunt around in the parser for how a given operator is handled. + +=back + +=head3 L<perllocale> + +=over 4 + +=item * + +Some locales aren't compatible with Perl. Note that these can cause +core dumps. + +=back + +=head3 L<perlmod> + +=over 4 + +=item * + +Various clarifications have been added. + +=back + +=head3 L<perlmodlib> + +=over 4 + +=item * + +Updated the site mirror list. + +=back + +=head3 L<perlobj> + +=over 4 + +=item * + +Added a section on calling methods using their fully qualified names. + +=item * + +Do not discourage manual C<@ISA>. + +=back + +=head3 L<perlootut> + +=over 4 + +=item * + +Mention C<Moo> more. + +=back + +=head3 L<perlop> + +=over 4 + +=item * + +Note that white space must be used for quoting operators if the +delimiter is a word character (I<i.e.>, matches C<\w>). + +=item * + +Clarify that in regular expression patterns delimited by single quotes, +no variable interpolation is done. + +=back + +=head3 L<perlre> + +=over 4 + +=item * + +The first part was extensively rewritten to incorporate various basic +points, that in earlier versions were mentioned in sort of an appendix +on Version 8 regular expressions. + +=item * + +Note that it is common to have the C</x> modifier and forget that this +means that C<"#"> has to be escaped. + +=back + +=head3 L<perlretut> + +=over 4 + +=item * + +Add introductory material. + +=item * + +Note that a metacharacter occurring in a context where it can't mean +that, silently loses its meta-ness and matches literally. +L<C<use re 'strict'>|re/'strict' mode> can catch some of these. + +=back + +=head3 L<perlunicode> + +=over 4 + +=item * + +Corrected the text about Unicode BYTE ORDER MARK handling. + +=item * + +Updated the text to correspond with changes in Unicode UTS#18, concerning +regular expressions, and Perl compatibility with what it says. + +=back + +=head3 L<perlvar> + +=over 4 + +=item * + +Document C<@ISA>. It was documented in other places, but not in L<perlvar>. + +=back + +=head1 Diagnostics + +=head2 New Diagnostics + +=head3 New Errors + +=over 4 + +=item * + +L<A signature parameter must start with C<'$'>, C<'@'> or C<'%'> +|perldiag/A signature parameter must start with C<'$'>, C<'@'> or C<'%'>> + +=item * + +L<Bareword in require contains "%s"|perldiag/"Bareword in require contains "%s""> + +=item * + +L<Bareword in require maps to empty filename|perldiag/"Bareword in require maps to empty filename"> + +=item * + +L<Bareword in require maps to disallowed filename "%s"|perldiag/"Bareword in require maps to disallowed filename "%s""> + +=item * + +L<Bareword in require must not start with a double-colon: "%s"|perldiag/"Bareword in require must not start with a double-colon: "%s""> + +=item * + +L<%s: command not found|perldiag/"%s: command not found"> + +(A) You've accidentally run your script through B<bash> or another shell +instead of Perl. Check the C<#!> line, or manually feed your script into +Perl yourself. The C<#!> line at the top of your file could look like: + + #!/usr/bin/perl + +=item * + +L<%s: command not found: %s|perldiag/"%s: command not found: %s"> + +(A) You've accidentally run your script through B<zsh> or another shell +instead of Perl. Check the C<#!> line, or manually feed your script into +Perl yourself. The C<#!> line at the top of your file could look like: + + #!/usr/bin/perl + +=item * + +L<The experimental declared_refs feature is not enabled|perldiag/"The experimental declared_refs feature is not enabled"> + +(F) To declare references to variables, as in C<my \%x>, you must first enable +the feature: + + no warnings "experimental::declared_refs"; + use feature "declared_refs"; + +See L</Declaring a reference to a variable>. + +=item * + +L<Illegal character following sigil in a subroutine signature +|perldiag/Illegal character following sigil in a subroutine signature> + +=item * + +L<Indentation on line %d of here-doc doesn't match delimiter +|perldiag/Indentation on line %d of here-doc doesn't match delimiter> + +=item * + +L<Infinite recursion via empty pattern|perldiag/"Infinite recursion via empty pattern">. + +Using the empty pattern (which re-executes the last successfully-matched +pattern) inside a code block in another regex, as in C</(?{ s!!new! })/>, has +always previously yielded a segfault. It now produces this error. + +=item * + +L<Malformed UTF-8 string in "%s" +|perldiag/Malformed UTF-8 string in "%s"> + +=item * + +L<Multiple slurpy parameters not allowed +|perldiag/Multiple slurpy parameters not allowed> + +=item * + +L<C<'#'> not allowed immediately following a sigil in a subroutine signature +|perldiag/C<'#'> not allowed immediately following a sigil in a subroutine signature> + +=item * + +L<panic: unknown OA_*: %x +|perldiag/panic: unknown OA_*: %x> + +=item * + +L<Unescaped left brace in regex is illegal here|perldiag/Unescaped left brace in regex is illegal here in regex; marked by S<E<lt>-- HERE> in mE<sol>%sE<sol>> + +Unescaped left braces are now illegal in some contexts in regular expression +patterns. In other contexts, they are still just deprecated; they will +be illegal in Perl 5.30. + +=item * + +L<Version control conflict marker|perldiag/"Version control conflict marker"> + +(F) The parser found a line starting with C<E<lt>E<lt>E<lt>E<lt>E<lt>E<lt>E<lt>>, +C<E<gt>E<gt>E<gt>E<gt>E<gt>E<gt>E<gt>>, or C<=======>. These may be left by a +version control system to mark conflicts after a failed merge operation. + +=back + +=head3 New Warnings + +=over 4 + +=item * + +L<Can't determine class of operator %s, assuming C<BASEOP> +|perldiag/Can't determine class of operator %s, assuming C<BASEOP>> + +=item * + +L<Declaring references is experimental|perldiag/"Declaring references is experimental"> + +(S experimental::declared_refs) This warning is emitted if you use a reference +constructor on the right-hand side of C<my()>, C<state()>, C<our()>, or +C<local()>. Simply suppress the warning if you want to use the feature, but +know that in doing so you are taking the risk of using an experimental feature +which may change or be removed in a future Perl version: + + no warnings "experimental::declared_refs"; + use feature "declared_refs"; + $fooref = my \$foo; + +See L</Declaring a reference to a variable>. + +=item * + +L<do "%s" failed, '.' is no longer in @INC|perldiag/do "%s" failed, '.' is no longer in @INC; did you mean do ".E<sol>%s"?> + +Since C<"."> is now removed from C<@INC> by default, C<do> will now trigger a warning recommending to fix the C<do> statement. + +=item * + +L<C<File::Glob::glob()> will disappear in perl 5.30. Use C<File::Glob::bsd_glob()> instead. +|perldiag/C<File::Glob::glob()> will disappear in perl 5.30. Use C<File::Glob::bsd_glob()> instead.> + +=item * + +L<Unescaped literal '%c' in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol> +|perldiag/Unescaped literal '%c' in regex; marked by <-- HERE in mE<sol>%sE<sol>> + +=item * + +L<Use of unassigned code point or non-standalone grapheme for a delimiter will be a fatal error starting in Perl 5.30|perldiag/"Use of unassigned code point or non-standalone grapheme for a delimiter will be a fatal error starting in Perl 5.30"> + +See L</Deprecations> + +=back + +=head2 Changes to Existing Diagnostics + +=over 4 + +=item * + +When a C<require> fails, we now do not provide C<@INC> when the C<require> +is for a file instead of a module. + +=item * + +When C<@INC> is not scanned for a C<require> call, we no longer display +C<@INC> to avoid confusion. + +=item * + +L<Attribute "locked" is deprecated, and will disappear in Perl 5.28 +|perldiag/Attribute "locked" is deprecated, and will disappear in Perl 5.28> + +This existing warning has had the I<and will disappear> text added in this +release. + +=item * + +L<Attribute "unique" is deprecated, and will disappear in Perl 5.28 +|perldiag/Attribute "unique" is deprecated, and will disappear in Perl 5.28> + +This existing warning has had the I<and will disappear> text added in this +release. + +=item * + +Calling POSIX::%s() is deprecated + +This warning has been removed, as the deprecated functions have been +removed from POSIX. + +=item * + +L<Constants from lexical variables potentially modified elsewhere are deprecated. This will not be allowed in Perl 5.32 +|perldiag/Constants from lexical variables potentially modified elsewhere are deprecated. This will not be allowed in Perl 5.32> + +This existing warning has had the I<this will not be allowed> text added +in this release. + +=item * + +L<Deprecated use of C<my()> in false conditional. This will be a fatal error in Perl 5.30 +|perldiag/Deprecated use of C<my()> in false conditional. This will be a fatal error in Perl 5.30> + +This existing warning has had the I<this will be a fatal error> text added +in this release. + +=item * + +L<C<dump()> better written as C<CORE::dump()>. C<dump()> will no longer be available in Perl 5.30 +|perldiag/C<dump()> better written as C<CORE::dump()>. C<dump()> will no longer be available in Perl 5.30> + +This existing warning has had the I<no longer be available> text added in +this release. + +=item * + +L<Experimental %s on scalar is now forbidden +|perldiag/Experimental %s on scalar is now forbidden> + +This message is now followed by more helpful text. +L<[perl #127976]|https://rt.perl.org/Public/Bug/Display.html?id=127976> + +=item * + +Experimental "%s" subs not enabled + +This warning was been removed, as lexical subs are no longer experimental. + +=item * + +Having more than one /%c regexp modifier is deprecated + +This deprecation warning has been removed, since C</xx> now has a new +meaning. + +=item * + +L<%s() is deprecated on C<:utf8> handles. This will be a fatal error in Perl 5.30 +|perldiag/%s() is deprecated on C<:utf8> handles. This will be a fatal error in Perl 5.30>. + +where "%s" is one of C<sysread>, C<recv>, C<syswrite>, or C<send>. + +This existing warning has had the I<this will be a fatal error> text added +in this release. + +This warning is now enabled by default, as all C<deprecated> category +warnings should be. + +=item * + +L<C<$*> is no longer supported. Its use will be fatal in Perl 5.30 +|perldiag/C<$*> is no longer supported. Its use will be fatal in Perl 5.30> + +This existing warning has had the I<its use will be fatal> text added in +this release. + +=item * + +L<C<$#> is no longer supported. Its use will be fatal in Perl 5.30 +|perldiag/C<$#> is no longer supported. Its use will be fatal in Perl 5.30> + +This existing warning has had the I<its use will be fatal> text added in +this release. + +=item * + +L<Malformed UTF-8 character%s +|perldiag/Malformed UTF-8 character%s> + +Details as to the exact problem have been added at the end of this +message + +=item * + +L<Missing or undefined argument to %s +|perldiag/Missing or undefined argument to %s> + +This warning used to warn about C<require>, even if it was actually C<do> +which being executed. It now gets the operation name right. + +=item * + +NO-BREAK SPACE in a charnames alias definition is deprecated + +This warning has been removed as the behavior is now an error. + +=item * + +L<Odd nameE<sol>value argument for subroutine '%s' +|perldiag/"Odd nameE<sol>value argument for subroutine '%s'"> + +This warning now includes the name of the offending subroutine. + +=item * + +L<Opening dirhandle %s also as a file. This will be a fatal error in Perl 5.28 +|perldiag/Opening dirhandle %s also as a file. This will be a fatal error in Perl 5.28> + +This existing warning has had the I<this will be a fatal error> text added +in this release. + +=item * + +L<Opening filehandle %s also as a directory. This will be a fatal error in Perl 5.28 +|perldiag/Opening filehandle %s also as a directory. This will be a fatal error in Perl 5.28> + +This existing warning has had the I<this will be a fatal error> text added +in this release. + +=item * + +panic: ck_split, type=%u + +panic: pp_split, pm=%p, s=%p + +These panic errors have been removed. + +=item * + +Passing malformed UTF-8 to "%s" is deprecated + +This warning has been changed to the fatal +L<Malformed UTF-8 string in "%s" +|perldiag/Malformed UTF-8 string in "%s"> + +=item * + +L<Setting C<< $E<sol> >> to a reference to %s as a form of slurp is deprecated, treating as undef. This will be fatal in Perl 5.28 +|perldiag/Setting C<< $E<sol> >> to a reference to %s as a form of slurp is deprecated, treating as undef. This will be fatal in Perl 5.28> + +This existing warning has had the I<this will be fatal> text added in +this release. + +=item * + +L<C<${^ENCODING}> is no longer supported. Its use will be fatal in Perl 5.28|perldiag/"${^ENCODING} is no longer supported. Its use will be fatal in Perl 5.28"> + +This warning used to be: "Setting C<${^ENCODING}> is deprecated". + +The special action of the variable C<${^ENCODING}> was formerly used to +implement the C<encoding> pragma. As of Perl 5.26, rather than being +deprecated, assigning to this variable now has no effect except to issue +the warning. + +=item * + +L<Too few arguments for subroutine '%s' +|perldiag/Too few arguments for subroutine '%s'> + +This warning now includes the name of the offending subroutine. + +=item * + +L<Too many arguments for subroutine '%s' +|perldiag/Too many arguments for subroutine '%s'> + +This warning now includes the name of the offending subroutine. + +=item * + +L<Unescaped left brace in regex is deprecated here (and will be fatal in Perl 5.30), passed through in regex; marked by S<< E<lt>-- HERE >> in mE<sol>%sE<sol> +|perldiag/Unescaped left brace in regex is deprecated here (and will be fatal in Perl 5.30), passed through in regex; marked by S<< E<lt>-- HERE >> in mE<sol>%sE<sol>> + +This existing warning has had the I<here (and will be fatal...)> text +added in this release. + +=item * + +L<Unknown charname '' is deprecated. Its use will be fatal in Perl 5.28 +|perldiag/Unknown charname '' is deprecated. Its use will be fatal in Perl 5.28> + +This existing warning has had the I<its use will be fatal> text added in +this release. + +=item * + +L<Use of bare E<lt>E<lt> to mean E<lt>E<lt>"" is deprecated. Its use will be fatal in Perl 5.28 +|perldiag/Use of bare E<lt>E<lt> to mean E<lt>E<lt>"" is deprecated. Its use will be fatal in Perl 5.28> + +This existing warning has had the I<its use will be fatal> text added in +this release. + +=item * + +L<Use of code point 0x%s is deprecated; the permissible max is 0x%s. This will be fatal in Perl 5.28 +|perldiag/Use of code point 0x%s is deprecated; the permissible max is 0x%s. This will be fatal in Perl 5.28> + +This existing warning has had the I<this will be fatal> text added in +this release. + +=item * + +L<Use of comma-less variable list is deprecated. Its use will be fatal in Perl 5.28 +|perldiag/Use of comma-less variable list is deprecated. Its use will be fatal in Perl 5.28> + +This existing warning has had the I<its use will be fatal> text added in +this release. + +=item * + +L<Use of inherited C<AUTOLOAD> for non-method %s() is deprecated. This will be fatal in Perl 5.28 +|perldiag/Use of inherited C<AUTOLOAD> for non-method %s() is deprecated. This will be fatal in Perl 5.28> + +This existing warning has had the I<this will be fatal> text added in +this release. + +=item * + +L<Use of strings with code points over 0xFF as arguments to %s operator is deprecated. This will be a fatal error in Perl 5.28 +|perldiag/Use of strings with code points over 0xFF as arguments to %s operator is deprecated. This will be a fatal error in Perl 5.28> + +This existing warning has had the I<this will be a fatal error> text added in +this release. + +=back + +=head1 Utility Changes + +=head2 F<c2ph> and F<pstruct> + +=over 4 + +=item * + +These old utilities have long since superceded by L<h2xs>, and are +now gone from the distribution. + +=back + +=head2 F<Porting/pod_lib.pl> + +=over 4 + +=item * + +Removed spurious executable bit. + +=item * + +Account for the possibility of DOS file endings. + +=back + +=head2 F<Porting/sync-with-cpan> + +=over 4 + +=item * + +Many improvements. + +=back + +=head2 F<perf/benchmarks> + +=over 4 + +=item * + +Tidy file, rename some symbols. + +=back + +=head2 F<Porting/checkAUTHORS.pl> + +=over 4 + +=item * + +Replace obscure character range with C<\w>. + +=back + +=head2 F<t/porting/regen.t> + +=over 4 + +=item * + +Try to be more helpful when tests fail. + +=back + +=head2 F<utils/h2xs.PL> + +=over 4 + +=item * + +Avoid infinite loop for enums. + +=back + +=head2 L<perlbug> + +=over 4 + +=item * + +Long lines in the message body are now wrapped at 900 characters, to stay +well within the 1000-character limit imposed by SMTP mail transfer agents. +This is particularly likely to be important for the list of arguments to +F<Configure>, which can readily exceed the limit if, for example, it names +several non-default installation paths. This change also adds the first unit +tests for perlbug. +L<[perl #128020]|https://rt.perl.org/Public/Bug/Display.html?id=128020> + +=back + +=head1 Configuration and Compilation + +=over 4 + +=item * + +C<-Ddefault_inc_excludes_dot> has added, and enabled by default. + +=item * + +The C<dtrace> build process has further changes +L<[perl #130108]|https://rt.perl.org/Public/Bug/Display.html?id=130108>: + +=over + +=item * + +If the C<-xnolibs> is available, use that so a F<dtrace> perl can be +built within a FreeBSD jail. + +=item * + +On systems that build a F<dtrace> object file (FreeBSD, Solaris, and +SystemTap's dtrace emulation), copy the input objects to a separate +directory and process them there, and use those objects in the link, +since C<dtrace -G> also modifies these objects. + +=item * + +Add F<libelf> to the build on FreeBSD 10.x, since F<dtrace> adds +references to F<libelf> symbols. + +=item * + +Generate a dummy F<dtrace_main.o> if C<dtrace -G> fails to build it. A +default build on Solaris generates probes from the unused inline +functions, while they don't on FreeBSD, which causes C<dtrace -G> to +fail. + +=back + +=item * + +You can now disable perl's use of the C<PERL_HASH_SEED> and +C<PERL_PERTURB_KEYS> environment variables by configuring perl with +C<-Accflags=NO_PERL_HASH_ENV>. + +=item * + +You can now disable perl's use of the C<PERL_HASH_SEED_DEBUG> environment +variable by configuring perl with +C<-Accflags=-DNO_PERL_HASH_SEED_DEBUG>. + +=item * + +F<Configure> now zeroes out the alignment bytes when calculating the bytes +for 80-bit C<NaN> and C<Inf> to make builds more reproducible. +L<[perl #130133]|https://rt.perl.org/Public/Bug/Display.html?id=130133> + +=item * + +Since v5.18, for testing purposes we have included support for +building perl with a variety of non-standard, and non-recommended +hash functions. Since we do not recommend the use of these functions, +we have removed them and their corresponding build options. Specifically +this includes the following build options: + + PERL_HASH_FUNC_SDBM + PERL_HASH_FUNC_DJB2 + PERL_HASH_FUNC_SUPERFAST + PERL_HASH_FUNC_MURMUR3 + PERL_HASH_FUNC_ONE_AT_A_TIME + PERL_HASH_FUNC_ONE_AT_A_TIME_OLD + PERL_HASH_FUNC_MURMUR_HASH_64A + PERL_HASH_FUNC_MURMUR_HASH_64B + +=item * + +Remove "Warning: perl appears in your path" + +This install warning is more or less obsolete, since most platforms already +B<will> have a F</usr/bin/perl> or similar provided by the OS. + +=item * + +Reduce verbosity of C<make install.man> + +Previously, two progress messages were emitted for each manpage: one by +installman itself, and one by the function in F<install_lib.pl> that it calls to +actually install the file. Disabling the second of those in each case saves +over 750 lines of unhelpful output. + +=item * + +Cleanup for C<clang -Weverything> support. +L<[perl #129961]|https://rt.perl.org/Public/Bug/Display.html?id=129961> + +=item * + +F<Configure>: signbit scan was assuming too much, stop assuming negative 0. + +=item * + +Various compiler warnings have been silenced. + +=item * + +Several smaller changes have been made to remove impediments to compiling +under C++11. + +=item * + +Builds using C<USE_PAD_RESET> now work again; this configuration had +bit-rotted. + +=item * + +A probe for C<gai_strerror> was added to F<Configure> that checks if +the C<gai_strerror()> routine is available and can be used to +translate error codes returned by C<getaddrinfo()> into human +readable strings. + +=item * + +F<Configure> now aborts if both C<-Duselongdouble> and C<-Dusequadmath> are +requested. +L<[perl #126203]|https://rt.perl.org/Public/Bug/Display.html?id=126203> + +=item * + +Fixed a bug in which F<Configure> could append C<-quadmath> to the +archname even if it was already present. +L<[perl #128538]|https://rt.perl.org/Public/Bug/Display.html?id=128538> + +=item * + +Clang builds with C<-DPERL_GLOBAL_STRUCT> or +C<-DPERL_GLOBAL_STRUCT_PRIVATE> have +been fixed (by disabling Thread Safety Analysis for these configurations). + +=item * + +F<make_ext.pl> no longer updates a module's F<pm_to_blib> file when no +files require updates. This could cause dependencies, F<perlmain.c> +in particular, to be rebuilt unnecessarily. +L<[perl #126710]|https://rt.perl.org/Public/Bug/Display.html?id=126710> + +=item * + +The output of C<perl -V> has been reformatted so that each configuration +and compile-time option is now listed one per line, to improve +readability. + +=item * + +F<Configure> now builds C<miniperl> and C<generate_uudmap> if you +invoke it with C<-Dusecrosscompiler> but not C<-Dtargethost=somehost>. +This means you can supply your target platform C<config.sh>, generate +the headers and proceed to build your cross-target perl. +L<[perl #127234]|https://rt.perl.org/Public/Bug/Display.html?id=127234> + +=item * + +Perl built with C<-Accflags=-DPERL_TRACE_OPS> now only dumps the operator +counts when the environment variable C<PERL_TRACE_OPS> is set to a +non-zero integer. This allows C<make test> to pass on such a build. + +=item * + +When building with GCC 6 and link-time optimization (the C<-flto> option to +C<gcc>), F<Configure> was treating all probed symbols as present on the +system, regardless of whether they actually exist. This has been fixed. +L<[perl #128131]|https://rt.perl.org/Public/Bug/Display.html?id=128131> + +=item * + +The F<t/test.pl> library is used for internal testing of Perl itself, and +also copied by several CPAN modules. Some of those modules must work on +older versions of Perl, so F<t/test.pl> must in turn avoid newer Perl +features. Compatibility with Perl 5.8 was inadvertently removed some time +ago; it has now been restored. +L<[perl #128052]|https://rt.perl.org/Public/Bug/Display.html?id=128052> + +=item * + +The build process no longer emits an extra blank line before building each +"simple" extension (those with only F<*.pm> and F<*.pod> files). + +=back + +=head1 Testing + +Tests were added and changed to reflect the other additions and changes +in this release. Furthermore, these substantive changes were made: + +=over 4 + +=item * + +A new test script, F<comp/parser_run.t>, has been added that is like +F<comp/parser.t> but with F<test.pl> included so that C<runperl()> and the +like are available for use. + +=item * + +Tests for locales were erroneously using locales incompatible with Perl. + +=item * + +Some parts of the test suite that try to exhaustively test edge cases in the +regex implementation have been restricted to running for a maximum of five +minutes. On slow systems they could otherwise take several hours, without +significantly improving our understanding of the correctness of the code +under test. + +=item * + +A new internal facility allows analysing the time taken by the individual +tests in Perl's own test suite; see F<Porting/harness-timer-report.pl>. + +=item * + +F<t/re/regexp_nonull.t> has been added to test that the regular expression +engine can handle scalars that do not have a null byte just past the end of +the string. + +=item * + +A new test script, F<t/op/decl-refs.t>, has been added to test the new feature +L</Declaring a reference to a variable>. + +=item * + +A new test script, F<t/re/keep_tabs.t> has been added to contain tests +where C<\t> characters should not be expanded into spaces. + +=item * + +A new test script, F<t/re/anyof.t>, has been added to test that the ANYOF nodes +generated by bracketed character classes are as expected. + +=item * + +There is now more extensive testing of the Unicode-related API macros +and functions. + +=item * + +Several of the longer running API test files have been split into +multiple test files so that they can be run in parallel. + +=item * + +F<t/harness> now tries really hard not to run tests which are located +outside of the Perl source tree. +L<[perl #124050]|https://rt.perl.org/Public/Bug/Display.html?id=124050> + +=item * + +Prevent debugger tests (F<lib/perl5db.t>) from failing due to the contents +of C<$ENV{PERLDB_OPTS}>. +L<[perl #130445]|https://rt.perl.org/Public/Bug/Display.html?id=130445> + +=back + +=head1 Platform Support + +=head2 New Platforms + +=over 4 + +=item NetBSD/VAX + +Perl now compiles under NetBSD on VAX machines. However, it's not +possible for that platform to implement floating-point infinities and +NaNs compatible with most modern systems, which implement the IEEE-754 +floating point standard. The hexadecimal floating point (C<0x...p[+-]n> +literals, C<printf %a>) is not implemented, either. +The C<make test> passes 98% of tests. + +=over 4 + +=item * + +Test fixes and minor updates. + +=item * + +Account for lack of C<inf>, C<nan>, and C<-0.0> support. + +=back + +=back + +=head2 Platform-Specific Notes + +=over 4 + +=item Darwin + +=over 4 + +=item * + +Don't treat C<-Dprefix=/usr> as special: instead require an extra option +C<-Ddarwin_distribution> to produce the same results. + +=item * + +OS X El Capitan doesn't implement the C<clock_gettime()> or +C<clock_getres()> APIs; emulate them as necessary. + +=item * + +Deprecated C<syscall(2)> on macOS 10.12. + +=back + +=item EBCDIC + +Several tests have been updated to work (or be skipped) on EBCDIC platforms. + +=item HP-UX + +The L<Net::Ping> UDP test is now skipped on HP-UX. + +=item Hurd + +The hints for Hurd have been improved, enabling malloc wrap and reporting the +GNU libc used (previously it was an empty string when reported). + +=item VAX + +VAX floating point formats are now supported on NetBSD. + +=item VMS + +=over 4 + +=item * + +The path separator for the C<PERL5LIB> and C<PERLLIB> environment entries is +now a colon (C<":">) when running under a Unix shell. There is no change when +running under DCL (it's still C<"|">). + +=item * + +F<configure.com> now recognizes the VSI-branded C compiler and no longer +recognizes the "DEC"-branded C compiler (as there hasn't been such a thing for +15 or more years). + +=back + +=item Windows + +=over 4 + +=item * + +Support for compiling perl on Windows using Microsoft Visual Studio 2015 +(containing Visual C++ 14.0) has been added. + +This version of VC++ includes a completely rewritten C run-time library, some +of the changes in which mean that work done to resolve a socket +C<close()> bug in +perl #120091 and perl #118059 is not workable in its current state with this +version of VC++. Therefore, we have effectively reverted that bug fix for +VS2015 onwards on the basis that being able to build with VS2015 onwards is +more important than keeping the bug fix. We may revisit this in the future to +attempt to fix the bug again in a way that is compatible with VS2015. + +These changes do not affect compilation with GCC or with Visual Studio versions +up to and including VS2013, I<i.e.>, the bug fix is retained (unchanged) for those +compilers. + +Note that you may experience compatibility problems if you mix a perl built +with GCC or VS E<lt>= VS2013 with XS modules built with VS2015, or if you mix a +perl built with VS2015 with XS modules built with GCC or VS E<lt>= VS2013. +Some incompatibility may arise because of the bug fix that has been reverted +for VS2015 builds of perl, but there may well be incompatibility anyway because +of the rewritten CRT in VS2015 (I<e.g.>, see discussion at +L<http://stackoverflow.com/questions/30412951>). + +=item * + +It now automatically detects GCC versus Visual C and sets the VC version +number on Win32. + +=back + +=item Linux + +Drop support for Linux F<a.out> executable format. Linux has used ELF for +over twenty years. + +=item OpenBSD 6 + +OpenBSD 6 still does not support returning C<pid>, C<gid>, or C<uid> with +C<SA_SIGINFO>. Make sure to account for it. + +=item FreeBSD + +F<t/uni/overload.t>: Skip hanging test on FreeBSD. + +=item DragonFly BSD + +DragonFly BSD now has support for C<setproctitle()>. +L<[perl #130068]|https://rt.perl.org/Public/Bug/Display.html?id=130068>. + +=back + +=head1 Internal Changes + +=over 4 + +=item * + +A new API function L<C<sv_setpv_bufsize()>|perlapi/sv_setpv_bufsize> +allows simultaneously setting the +length and the allocated size of the buffer in an C<SV>, growing the +buffer if necessary. + +=item * + +A new API macro L<C<SvPVCLEAR()>|perlapi/SvPVCLEAR> sets its C<SV> +argument to an empty string, +like Perl-space C<$x = ''>, but with several optimisations. + +=item * + +Several new macros and functions for dealing with Unicode and +UTF-8-encoded strings have been added to the API, as well as some +changes in the +functionality of existing functions (see L<perlapi/Unicode Support> for +more details): + +=over + +=item * + +New versions of the API macros like C<isALPHA_utf8> and C<toLOWER_utf8> +have been added, each with the suffix C<_safe>, like +L<C<isSPACE_utf8_safe>|perlapi/isSPACE>. These take an extra +parameter, giving an upper +limit of how far into the string it is safe to read. Using the old +versions could cause attempts to read beyond the end of the input buffer +if the UTF-8 is not well-formed, and their use now raises a deprecation +warning. Details are at L<perlapi/Character classification>. + +=item * + +Macros like L<C<isALPHA_utf8>|perlapi/isALPHA> and +L<C<toLOWER_utf8>|perlapi/toLOWER_utf8> now die if they detect +that their input UTF-8 is malformed. A deprecation warning had been +issued since Perl 5.18. + +=item * + +Several new macros for analysing the validity of utf8 sequences. These +are: + +L<C<UTF8_GOT_ABOVE_31_BIT>|perlapi/UTF8_GOT_ABOVE_31_BIT> +L<C<UTF8_GOT_CONTINUATION>|perlapi/UTF8_GOT_CONTINUATION> +L<C<UTF8_GOT_EMPTY>|perlapi/UTF8_GOT_EMPTY> +L<C<UTF8_GOT_LONG>|perlapi/UTF8_GOT_LONG> +L<C<UTF8_GOT_NONCHAR>|perlapi/UTF8_GOT_NONCHAR> +L<C<UTF8_GOT_NON_CONTINUATION>|perlapi/UTF8_GOT_NON_CONTINUATION> +L<C<UTF8_GOT_OVERFLOW>|perlapi/UTF8_GOT_OVERFLOW> +L<C<UTF8_GOT_SHORT>|perlapi/UTF8_GOT_SHORT> +L<C<UTF8_GOT_SUPER>|perlapi/UTF8_GOT_SUPER> +L<C<UTF8_GOT_SURROGATE>|perlapi/UTF8_GOT_SURROGATE> +L<C<UTF8_IS_INVARIANT>|perlapi/UTF8_IS_INVARIANT> +L<C<UTF8_IS_NONCHAR>|perlapi/UTF8_IS_NONCHAR> +L<C<UTF8_IS_SUPER>|perlapi/UTF8_IS_SUPER> +L<C<UTF8_IS_SURROGATE>|perlapi/UTF8_IS_SURROGATE> +L<C<UVCHR_IS_INVARIANT>|perlapi/UVCHR_IS_INVARIANT> +L<C<isUTF8_CHAR_flags>|perlapi/isUTF8_CHAR_flags> +L<C<isSTRICT_UTF8_CHAR>|perlapi/isSTRICT_UTF8_CHAR> +L<C<isC9_STRICT_UTF8_CHAR>|perlapi/isC9_STRICT_UTF8_CHAR> + +=item * + +Functions that are all extensions of the C<is_utf8_string_I<*>()> functions, +that apply various restrictions to the UTF-8 recognized as valid: + +L<C<is_strict_utf8_string>|perlapi/is_strict_utf8_string>, +L<C<is_strict_utf8_string_loc>|perlapi/is_strict_utf8_string_loc>, +L<C<is_strict_utf8_string_loclen>|perlapi/is_strict_utf8_string_loclen>, + +L<C<is_c9strict_utf8_string>|perlapi/is_c9strict_utf8_string>, +L<C<is_c9strict_utf8_string_loc>|perlapi/is_c9strict_utf8_string_loc>, +L<C<is_c9strict_utf8_string_loclen>|perlapi/is_c9strict_utf8_string_loclen>, + +L<C<is_utf8_string_flags>|perlapi/is_utf8_string_flags>, +L<C<is_utf8_string_loc_flags>|perlapi/is_utf8_string_loc_flags>, +L<C<is_utf8_string_loclen_flags>|perlapi/is_utf8_string_loclen_flags>, + +L<C<is_utf8_fixed_width_buf_flags>|perlapi/is_utf8_fixed_width_buf_flags>, +L<C<is_utf8_fixed_width_buf_loc_flags>|perlapi/is_utf8_fixed_width_buf_loc_flags>, +L<C<is_utf8_fixed_width_buf_loclen_flags>|perlapi/is_utf8_fixed_width_buf_loclen_flags>. + +L<C<is_utf8_invariant_string>|perlapi/is_utf8_invariant_string>. +L<C<is_utf8_valid_partial_char>|perlapi/is_utf8_valid_partial_char>. +L<C<is_utf8_valid_partial_char_flags>|perlapi/is_utf8_valid_partial_char_flags>. + +=item * + +The functions L<C<utf8n_to_uvchr>|perlapi/utf8n_to_uvchr> and its +derivatives have had several changes of behaviour. + +Calling them, while passing a string length of 0 is now asserted against +in DEBUGGING builds, and otherwise, returns the Unicode REPLACEMENT +CHARACTER. If you have nothing to decode, you shouldn't call the decode +function. + +They now return the Unicode REPLACEMENT CHARACTER if called with UTF-8 +that has the overlong malformation and that malformation is allowed by +the input parameters. This malformation is where the UTF-8 looks valid +syntactically, but there is a shorter sequence that yields the same code +point. This has been forbidden since Unicode version 3.1. + +They now accept an input +flag to allow the overflow malformation. This malformation is when the +UTF-8 may be syntactically valid, but the code point it represents is +not capable of being represented in the word length on the platform. +What "allowed" means, in this case, is that the function doesn't return an +error, and it advances the parse pointer to beyond the UTF-8 in +question, but it returns the Unicode REPLACEMENT CHARACTER as the value +of the code point (since the real value is not representable). + +They no longer abandon searching for other malformations when the first +one is encountered. A call to one of these functions thus can generate +multiple diagnostics, instead of just one. + +=item * + +L<C<valid_utf8_to_uvchr()>|perlapi/valid_utf8_to_uvchr> has been added +to the API (although it was +present in core earlier). Like C<utf8_to_uvchr_buf()>, but assumes that +the next character is well-formed. Use with caution. + +=item * + +A new function, L<C<utf8n_to_uvchr_error>|perlapi/utf8n_to_uvchr_error>, +has been added for +use by modules that need to know the details of UTF-8 malformations +beyond pass/fail. Previously, the only ways to know why a sequence was +ill-formed was to capture and parse the generated diagnostics or to do +your own analysis. + +=item * + +There is now a safer version of utf8_hop(), called +L<C<utf8_hop_safe()>|perlapi/utf8_hop_safe>. +Unlike utf8_hop(), utf8_hop_safe() won't navigate before the beginning or +after the end of the supplied buffer. + +=item * + +Two new functions, L<C<utf8_hop_forward()>|perlapi/utf8_hop_forward> and +L<C<utf8_hop_back()>|perlapi/utf8_hop_back> are +similar to C<utf8_hop_safe()> but are for when you know which direction +you wish to travel. + +=item * + +Two new macros which return useful utf8 byte sequences: + +L<C<BOM_UTF8>|perlapi/BOM_UTF8> + +L<C<REPLACEMENT_CHARACTER_UTF8>|perlapi/REPLACEMENT_CHARACTER_UTF8> + +=back + +=item * + +Perl is now built with the C<PERL_OP_PARENT> compiler define enabled by +default. To disable it, use the C<PERL_NO_OP_PARENT> compiler define. +This flag alters how the C<op_sibling> field is used in C<OP> structures, +and has been available optionally since perl 5.22. + +See L<perl5220delta/"Internal Changes"> for more details of what this +build option does. + +=item * + +Three new ops, C<OP_ARGELEM>, C<OP_ARGDEFELEM>, and C<OP_ARGCHECK> have +been added. These are intended principally to implement the individual +elements of a subroutine signature, plus any overall checking required. + +=item * + +The C<OP_PUSHRE> op has been eliminated and the C<OP_SPLIT> op has been +changed from class C<LISTOP> to C<PMOP>. + +Formerly the first child of a split would be a C<pushre>, which would have the +C<split>'s regex attached to it. Now the regex is attached directly to the +C<split> op, and the C<pushre> has been eliminated. + +=item * + +The L<C<op_class()>|perlapi/op_class> API function has been added. This +is like the existing +C<OP_CLASS()> macro, but can more accurately determine what struct an op +has been allocated as. For example C<OP_CLASS()> might return +C<OA_BASEOP_OR_UNOP> indicating that ops of this type are usually +allocated as an C<OP> or C<UNOP>; while C<op_class()> will return +C<OPclass_BASEOP> or C<OPclass_UNOP> as appropriate. + +=item * + +All parts of the internals now agree that the C<sassign> op is a C<BINOP>; +previously it was listed as a C<BASEOP> in F<regen/opcodes>, which meant +that several parts of the internals had to be special-cased to accommodate +it. This oddity's original motivation was to handle code like C<$x ||= 1>; +that is now handled in a simpler way. + +=item * + +The output format of the L<C<op_dump()>|perlapi/op_dump> function (as +used by C<perl -Dx>) +has changed: it now displays an "ASCII-art" tree structure, and shows more +low-level details about each op, such as its address and class. + +=item * + +The C<PADOFFSET> type has changed from being unsigned to signed, and +several pad-related variables such as C<PL_padix> have changed from being +of type C<I32> to type C<PADOFFSET>. + +=item * + +The C<DEBUGGING>-mode output for regex compilation and execution has been +enhanced. + +=item * + +Several obscure SV flags have been eliminated, sometimes along with the +macros which manipulate them: C<SVpbm_VALID>, C<SVpbm_TAIL>, C<SvTAIL_on>, +C<SvTAIL_off>, C<SVrepl_EVAL>, C<SvEVALED>. + +=item * + +An OP C<op_private> flag has been eliminated: C<OPpRUNTIME>. This used to +often get set on C<PMOP> ops, but had become meaningless over time. + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +Perl no longer panics when switching into some locales on machines with +buggy C<strxfrm()> implementations in their F<libc>. +L<[perl #121734]|https://rt.perl.org/Public/Bug/Display.html?id=121734> + +=item * + +C< $-{$name} > would leak an C<AV> on each access if the regular +expression had no named captures. The same applies to access to any +hash tied with L<Tie::Hash::NamedCapture> and C<< all =E<gt> 1 >>. +L<[perl #130822]|https://rt.perl.org/Public/Bug/Display.html?id=130822> + +=item * + +Attempting to use the deprecated variable C<$#> as the object in an +indirect object method call could cause a heap use after free or +buffer overflow. +L<[perl #129274]|https://rt.perl.org/Public/Bug/Display.html?id=129274> + +=item * + +When checking for an indirect object method call, in some rare cases +the parser could reallocate the line buffer but then continue to use +pointers to the old buffer. +L<[perl #129190]|https://rt.perl.org/Public/Bug/Display.html?id=129190> + +=item * + +Supplying a glob as the format argument to +L<C<formline>|perlfunc/formline> would +cause an assertion failure. +L<[perl #130722]|https://rt.perl.org/Public/Bug/Display.html?id=130722> + +=item * + +Code like C< $value1 =~ qr/.../ ~~ $value2 > would have the match +converted into a C<qr//> operator, leaving extra elements on the stack to +confuse any surrounding expression. +L<[perl #130705]|https://rt.perl.org/Public/Bug/Display.html?id=130705> + +=item * + +Since v5.24 in some obscure cases, a regex which included code blocks +from multiple sources (I<e.g.>, via embedded via C<qr//> objects) could end up +with the wrong current pad and crash or give weird results. +L<[perl #129881]|https://rt.perl.org/Public/Bug/Display.html?id=129881> + +=item * + +Occasionally C<local()>s in a code block within a patterns weren't being +undone when the pattern matching backtracked over the code block. +L<[perl #126697]|https://rt.perl.org/Public/Bug/Display.html?id=126697> + +=item * + +Using C<substr()> to modify a magic variable could access freed memory +in some cases. +L<[perl #129340]|https://rt.perl.org/Public/Bug/Display.html?id=129340> + +=item * + +Under C<use utf8>, the entire source code is now checked for being UTF-8 +well formed, not just quoted strings as before. +L<[perl #126310]|https://rt.perl.org/Public/Bug/Display.html?id=126310>. + +=item * + +The range operator C<".."> on strings now handles its arguments correctly when in +the scope of the L<< C<unicode_strings>|feature/"The 'unicode_strings' feature" >> +feature. The previous behaviour was sufficiently unexpected that we believe no +correct program could have made use of it. + +=item * + +The C<split> operator did not ensure enough space was allocated for +its return value in scalar context. It could then write a single +pointer immediately beyond the end of the memory block allocated for +the stack. +L<[perl #130262]|https://rt.perl.org/Public/Bug/Display.html?id=130262> + +=item * + +Using a large code point with the C<"W"> pack template character with +the current output position aligned at just the right point could +cause a write of a single zero byte immediately beyond the end of an +allocated buffer. +L<[perl #129149]|https://rt.perl.org/Public/Bug/Display.html?id=129149> + +=item * + +Supplying a format's picture argument as part of the format argument list +where the picture specifies modifying the argument could cause an +access to the new freed compiled form.at. +L<[perl #129125]|https://rt.perl.org/Public/Bug/Display.html?id=129125> + +=item * + +The L<sort()|perlfunc/sort> operator's built-in numeric comparison +function didn't handle large integers that weren't exactly +representable by a double. This now uses the same code used to +implement the C<< E<lt>=E<gt> >> operator. +L<[perl #130335]|https://rt.perl.org/Public/Bug/Display.html?id=130335> + +=item * + +Fix issues with C</(?{ ... E<lt>E<lt>EOF })/> that broke +L<Method::Signatures>. +L<[perl #130398]|https://rt.perl.org/Public/Bug/Display.html?id=130398> + +=item * + +Fixed an assertion failure with C<chop> and C<chomp>, which +could be triggered by C<chop(@x =~ tr/1/1/)>. +L<[perl #130198]|https://rt.perl.org/Public/Bug/Display.html?id=130198>. + +=item * + +Fixed a comment skipping error in patterns under C</x>; it could stop +skipping a byte early, which could be in the middle of a UTF-8 +character. +L<[perl #130495]|https://rt.perl.org/Public/Bug/Display.html?id=130495>. + +=item * + +F<perldb> now ignores F</dev/tty> on non-Unix systems. +L<[perl #113960]|https://rt.perl.org/Public/Bug/Display.html?id=113960>; + +=item * + +Fix assertion failure for C<{}-E<gt>$x> when C<$x> isn't defined. +L<[perl #130496]|https://rt.perl.org/Public/Bug/Display.html?id=130496>. + +=item * + +Fix an assertion error which could be triggered when a lookahead string +in patterns exceeded a minimum length. +L<[perl #130522]|https://rt.perl.org/Public/Bug/Display.html?id=130522>. + +=item * + +Only warn once per literal number about a misplaced C<"_">. +L<[perl #70878]|https://rt.perl.org/Public/Bug/Display.html?id=70878>. + +=item * + +The C<tr///> parse code could be looking at uninitialized data after a +perse error. +L<[perl #129342]|https://rt.perl.org/Public/Bug/Display.html?id=129342>. + +=item * + +In a pattern match, a back-reference (C<\1>) to an unmatched capture could +read back beyond the start of the string being matched. +L<[perl #129377]|https://rt.perl.org/Public/Bug/Display.html?id=129377>. + +=item * + +C<use re 'strict'> is supposed to warn if you use a range (such as +C</(?[ [ X-Y ] ])/>) whose start and end digit aren't from the same group +of 10. It didn't do that for five groups of mathematical digits starting +at C<U+1D7E>. + +=item * + +A sub containing a "forward" declaration with the same name (I<e.g.>, +C<sub c { sub c; }>) could sometimes crash or loop infinitely. +L<[perl #129090]|https://rt.perl.org/Public/Bug/Display.html?id=129090> + +=item * + +A crash in executing a regex with a non-anchored UTF-8 substring against a +target string that also used UTF-8 has been fixed. +L<[perl #129350]|https://rt.perl.org/Public/Bug/Display.html?id=129350> + +=item * + +Previously, a shebang line like C<#!perl -i u> could be erroneously +interpreted as requesting the C<-u> option. This has been fixed. +L<[perl #129336]|https://rt.perl.org/Public/Bug/Display.html?id=129336> + +=item * + +The regex engine was previously producing incorrect results in some rare +situations when backtracking past an alternation that matches only one +thing; this +showed up as capture buffers (C<$1>, C<$2>, I<etc.>) erroneously containing data +from regex execution paths that weren't actually executed for the final +match. +L<[perl #129897]|https://rt.perl.org/Public/Bug/Display.html?id=129897> + +=item * + +Certain regexes making use of the experimental C<regex_sets> feature could +trigger an assertion failure. This has been fixed. +L<[perl #129322]|https://rt.perl.org/Public/Bug/Display.html?id=129322> + +=item * + +Invalid assignments to a reference constructor (I<e.g.>, C<\eval=time>) could +sometimes crash in addition to giving a syntax error. +L<[perl #125679]|https://rt.perl.org/Public/Bug/Display.html?id=125679> + +=item * + +The parser could sometimes crash if a bareword came after C<evalbytes>. +L<[perl #129196]|https://rt.perl.org/Public/Bug/Display.html?id=129196> + +=item * + +Autoloading via a method call would warn erroneously ("Use of inherited +AUTOLOAD for non-method") if there was a stub present in the package into +which the invocant had been blessed. The warning is no longer emitted in +such circumstances. +L<[perl #47047]|https://rt.perl.org/Public/Bug/Display.html?id=47047> + +=item * + +The use of C<splice> on arrays with non-existent elements could cause other +operators to crash. +L<[perl #129164]|https://rt.perl.org/Public/Bug/Display.html?id=129164> + +=item * + +A possible buffer overrun when a pattern contains a fixed utf8 substring. +L<[perl #129012]|https://rt.perl.org/Public/Bug/Display.html?id=129012> + +=item * + +Fixed two possible use-after-free bugs in perl's lexer. +L<[perl #129069]|https://rt.perl.org/Public/Bug/Display.html?id=129069> + +=item * + +Fixed a crash with C<s///l> where it thought it was dealing with UTF-8 +when it wasn't. +L<[perl #129038]|https://rt.perl.org/Public/Bug/Display.html?id=129038> + +=item * + +Fixed a place where the regex parser was not setting the syntax error +correctly on a syntactically incorrect pattern. +L<[perl #129122]|https://rt.perl.org/Public/Bug/Display.html?id=129122> + +=item * + +The C<&.> operator (and the C<"&"> operator, when it treats its arguments as +strings) were failing to append a trailing null byte if at least one string +was marked as utf8 internally. Many code paths (system calls, regexp +compilation) still expect there to be a null byte in the string buffer +just past the end of the logical string. An assertion failure was the +result. +L<[perl #129287]|https://rt.perl.org/Public/Bug/Display.html?id=129287> + +=item * + +Avoid a heap-after-use error in the parser when creating an error messge +for a syntactically invalid heredoc. +L<[perl #128988]|https://rt.perl.org/Public/Bug/Display.html?id=128988> + +=item * + +Fix a segfault when run with C<-DC> options on DEBUGGING builds. +L<[perl #129106]|https://rt.perl.org/Public/Bug/Display.html?id=129106> + +=item * + +Fixed the parser error handling in subroutine attributes for an +'C<:attr(foo>' that does not have an ending 'C<")">'. + +=item * + +Fix the perl lexer to correctly handle a backslash as the last char in +quoted-string context. This actually fixed two bugs, +L<[perl #129064]|https://rt.perl.org/Public/Bug/Display.html?id=129064> and +L<[perl #129176]|https://rt.perl.org/Public/Bug/Display.html?id=129176>. + +=item * + +In the API function C<gv_fetchmethod_pvn_flags>, rework separator parsing +to prevent possible string overrun with an invalid C<len> argument. +L<[perl #129267]|https://rt.perl.org/Public/Bug/Display.html?id=129267> + +=item * + +Problems with in-place array sorts: code like C<@a = sort { ... } @a>, +where the source and destination of the sort are the same plain array, are +optimised to do less copying around. Two side-effects of this optimisation +were that the contents of C<@a> as seen by sort routines were +partially sorted; and under some circumstances accessing C<@a> during the +sort could crash the interpreter. Both these issues have been fixed, and +Sort functions see the original value of C<@a>. +L<[perl #128340]|https://rt.perl.org/Public/Bug/Display.html?id=128340> + +=item * + +Non-ASCII string delimiters are now reported correctly in error messages +for unterminated strings. +L<[perl #128701]|https://rt.perl.org/Public/Bug/Display.html?id=128701> + +=item * + +C<pack("p", ...)> used to emit its warning ("Attempt to pack pointer to +temporary value") erroneously in some cases, but has been fixed. + +=item * + +C<@DB::args> is now exempt from "used once" warnings. The warnings only +occurred under B<-w>, because F<warnings.pm> itself uses C<@DB::args> +multiple times. + +=item * + +The use of built-in arrays or hash slices in a double-quoted string no +longer issues a warning ("Possible unintended interpolation...") if the +variable has not been mentioned before. This affected code like +C<qq|@DB::args|> and C<qq|@SIG{'CHLD', 'HUP'}|>. (The special variables +C<@-> and C<@+> were already exempt from the warning.) + +=item * + +C<gethostent> and similar functions now perform a null check internally, to +avoid crashing with the torsocks library. This was a regression from v5.22. +L<[perl #128740]|https://rt.perl.org/Public/Bug/Display.html?id=128740> + +=item * + +C<defined *{'!'}>, C<defined *{'['}>, and C<defined *{'-'}> no longer leak +memory if the typeglob in question has never been accessed before. + +=item * + +Mentioning the same constant twice in a row (which is a syntax error) no +longer fails an assertion under debugging builds. This was a regression +from v5.20. +L<[perl #126482]|https://rt.perl.org/Public/Bug/Display.html?id=126482> + +=item * + +Many issues relating to C<printf "%a"> of hexadecimal floating point +were fixed. In addition, the "subnormals" (formerly known as "denormals") +floating point numbers are now supported both with the plain IEEE 754 +floating point numbers (64-bit or 128-bit) and the x86 80-bit +"extended precision". Note that subnormal hexadecimal floating +point literals will give a warning about "exponent underflow". +L<[perl #128843]|https://rt.perl.org/Public/Bug/Display.html?id=128843> +L<[perl #128889]|https://rt.perl.org/Public/Bug/Display.html?id=128889> +L<[perl #128890]|https://rt.perl.org/Public/Bug/Display.html?id=128890> +L<[perl #128893]|https://rt.perl.org/Public/Bug/Display.html?id=128893> +L<[perl #128909]|https://rt.perl.org/Public/Bug/Display.html?id=128909> +L<[perl #128919]|https://rt.perl.org/Public/Bug/Display.html?id=128919> + +=item * + +A regression in v5.24 with C<tr/\N{U+...}/foo/> when the code point was between +128 and 255 has been fixed. +L<[perl #128734]|https://rt.perl.org/Public/Bug/Display.html?id=128734>. + +=item * + +Use of a string delimiter whose code point is above 2**31 now works +correctly on platforms that allow this. Previously, certain characters, +due to truncation, would be confused with other delimiter characters +with special meaning (such as C<"?"> in C<m?...?>), resulting +in inconsistent behaviour. Note that this is non-portable, +and is based on Perl's extension to UTF-8, and is probably not +displayable nor enterable by any editor. +L<[perl #128738]|https://rt.perl.org/Public/Bug/Display.html?id=128738> + +=item * + +C<@{x> followed by a newline where C<"x"> represents a control or non-ASCII +character no longer produces a garbled syntax error message or a crash. +L<[perl #128951]|https://rt.perl.org/Public/Bug/Display.html?id=128951> + +=item * + +An assertion failure with C<%: = 0> has been fixed. +L<[perl #128238]|https://rt.perl.org/Public/Bug/Display.html?id=128238> + +=item * + +In Perl 5.18, the parsing of C<"$foo::$bar"> was accidentally changed, such +that it would be treated as C<$foo."::".$bar>. The previous behavior, which +was to parse it as C<$foo:: . $bar>, has been restored. +L<[perl #128478]|https://rt.perl.org/Public/Bug/Display.html?id=128478> + +=item * + +Since Perl 5.20, line numbers have been off by one when perl is invoked with +the B<-x> switch. This has been fixed. +L<[perl #128508]|https://rt.perl.org/Public/Bug/Display.html?id=128508> + +=item * + +Vivifying a subroutine stub in a deleted stash (I<e.g.>, +C<delete $My::{"Foo::"}; \&My::Foo::foo>) no longer crashes. It had begun +crashing in Perl 5.18. +L<[perl #128532]|https://rt.perl.org/Public/Bug/Display.html?id=128532> + +=item * + +Some obscure cases of subroutines and file handles being freed at the same time +could result in crashes, but have been fixed. The crash was introduced in Perl +5.22. +L<[perl #128597]|https://rt.perl.org/Public/Bug/Display.html?id=128597> + +=item * + +Code that looks for a variable name associated with an uninitialized value +could cause an assertion failure in cases where magic is involved, such as +C<$ISA[0][0]>. This has now been fixed. +L<[perl #128253]|https://rt.perl.org/Public/Bug/Display.html?id=128253> + +=item * + +A crash caused by code generating the warning "Subroutine STASH::NAME +redefined" in cases such as C<sub P::f{} undef *P::; *P::f =sub{};> has been +fixed. In these cases, where the STASH is missing, the warning will now appear +as "Subroutine NAME redefined". +L<[perl #128257]|https://rt.perl.org/Public/Bug/Display.html?id=128257> + +=item * + +Fixed an assertion triggered by some code that handles deprecated behavior in +formats, I<e.g.>, in cases like this: + + format STDOUT = + @ + 0"$x" + +L<[perl #128255]|https://rt.perl.org/Public/Bug/Display.html?id=128255> + +=item * + +A possible divide by zero in string transformation code on Windows has been +avoided, fixing a crash when collating an empty string. +L<[perl #128618]|https://rt.perl.org/Public/Bug/Display.html?id=128618> + +=item * + +Some regular expression parsing glitches could lead to assertion failures with +regular expressions such as C</(?E<lt>=/> and C</(?E<lt>!/>. This has now been fixed. +L<[perl #128170]|https://rt.perl.org/Public/Bug/Display.html?id=128170> + +=item * + +C< until ($x = 1) { ... } > and C< ... until $x = 1 > now properly +warn when syntax warnings are enabled. +L<[perl #127333]|https://rt.perl.org/Public/Bug/Display.html?id=127333> + +=item * + +socket() now leaves the error code returned by the system in C<$!> on +failure. +L<[perl #128316]|https://rt.perl.org/Public/Bug/Display.html?id=128316> + +=item * + +Assignment variants of any bitwise ops under the C<bitwise> feature would +crash if the left-hand side was an array or hash. +L<[perl #128204]|https://rt.perl.org/Public/Bug/Display.html?id=128204> + +=item * + +C<require> followed by a single colon (as in C<foo() ? require : ...> is +now parsed correctly as C<require> with implicit C<$_>, rather than +C<require "">. +L<[perl #128307]|https://rt.perl.org/Public/Bug/Display.html?id=128307> + +=item * + +Scalar C<keys %hash> can now be assigned to consistently in all scalar +lvalue contexts. Previously it worked for some contexts but not others. + +=item * + +List assignment to C<vec> or C<substr> with an array or hash for its first +argument used to result in crashes or "Can't coerce" error messages at run +time, unlike scalar assignment, which would give an error at compile time. +List assignment now gives a compile-time error, too. +L<[perl #128260]|https://rt.perl.org/Public/Bug/Display.html?id=128260> + +=item * + +Expressions containing an C<&&> or C<||> operator (or their synonyms C<and> +and C<or>) were being compiled incorrectly in some cases. If the left-hand +side consisted of either a negated bareword constant or a negated C<do {}> +block containing a constant expression, and the right-hand side consisted of +a negated non-foldable expression, one of the negations was effectively +ignored. The same was true of C<if> and C<unless> statement modifiers, +though with the left-hand and right-hand sides swapped. This long-standing +bug has now been fixed. +L<[perl #127952]|https://rt.perl.org/Public/Bug/Display.html?id=127952> + +=item * + +C<reset> with an argument no longer crashes when encountering stash entries +other than globs. +L<[perl #128106]|https://rt.perl.org/Public/Bug/Display.html?id=128106> + +=item * + +Assignment of hashes to, and deletion of, typeglobs named C<*::::::> no +longer causes crashes. +L<[perl #128086]|https://rt.perl.org/Public/Bug/Display.html?id=128086> + +=item * + +Perl wasn't correctly handling true/false values in the LHS of a list +assign; specifically the truth values returned by boolean operators. +This could trigger an assertion failure in something like the following: + + for ($x > $y) { + ($_, ...) = (...); # here $_ is aliased to a truth value + } + +This was a regression from v5.24. +L<[perl #129991]|https://rt.perl.org/Public/Bug/Display.html?id=129991> + +=item * + +Assertion failure with user-defined Unicode-like properties. +L<[perl #130010]|https://rt.perl.org/Public/Bug/Display.html?id=130010> + +=item * + +Fix error message for unclosed C<\N{> in a regex. An unclosed C<\N{> +could give the wrong error message: +C<"\N{NAME} must be resolved by the lexer">. + +=item * + +List assignment in list context where the LHS contained aggregates and +where there were not enough RHS elements, used to skip scalar lvalues. +Previously, C<(($a,$b,@c,$d) = (1))> in list context returned C<($a)>; now +it returns C<($a,$b,$d)>. C<(($a,$b,$c) = (1))> is unchanged: it still +returns C<($a,$b,$c)>. This can be seen in the following: + + sub inc { $_++ for @_ } + inc(($a,$b,@c,$d) = (10)) + +Formerly, the values of C<($a,$b,$d)> would be left as C<(11,undef,undef)>; +now they are C<(11,1,1)>. + +=item * + +Code like this: C</(?{ s!!! })/> could trigger infinite recursion on the C +stack (not the normal perl stack) when the last successful pattern in +scope is itself. We avoid the segfault by simply forbidding the use of +the empty pattern when it would resolve to the currently executing +pattern. +L<[perl #129903]|https://rt.perl.org/Public/Bug/Display.html?id=129903> + +=item * + +Avoid reading beyond the end of the line buffer in perl's lexer when +there's a short UTF-8 character at the end. +L<[perl #128997]|https://rt.perl.org/Public/Bug/Display.html?id=128997> + +=item * + +Alternations in regular expressions were sometimes failing to match +a utf8 string against a utf8 alternate. +L<[perl #129950]|https://rt.perl.org/Public/Bug/Display.html?id=129950> + +=item * + +Make C<do "a\0b"> fail silently (and return C<undef> and set C<$!>) +instead of throwing an error. +L<[perl #129928]|https://rt.perl.org/Public/Bug/Display.html?id=129928> + +=item * + +C<chdir> with no argument didn't ensure that there was stack space +available for returning its result. +L<[perl #129130]|https://rt.perl.org/Public/Bug/Display.html?id=129130> + +=item * + +All error messages related to C<do> now refer to C<do>; some formerly +claimed to be from C<require> instead. + +=item * + +Executing C<undef $x> where C<$x> is tied or magical no longer incorrectly +blames the variable for an uninitialized-value warning encountered by the +tied/magical code. + +=item * + +Code like C<$x = $x . "a"> was incorrectly failing to yield a +L<use of uninitialized value|perldiag/"Use of uninitialized value%s"> +warning when C<$x> was a lexical variable with an undefined value. That has +now been fixed. +L<[perl #127877]|https://rt.perl.org/Public/Bug/Display.html?id=127877> + +=item * + +C<undef *_; shift> or C<undef *_; pop> inside a subroutine, with no +argument to C<shift> or C<pop>, began crashing in Perl 5.14, but has now +been fixed. + +=item * + +C<< "string$scalar-E<gt>$*" >> now correctly prefers concatenation +overloading to string overloading if C<< $scalar-E<gt>$* >> returns an +overloaded object, bringing it into consistency with C<$$scalar>. + +=item * + +C<< /@0{0*-E<gt>@*/*0 >> and similar contortions used to crash, but no longer +do, but merely produce a syntax error. +L<[perl #128171]|https://rt.perl.org/Public/Bug/Display.html?id=128171> + +=item * + +C<do> or C<require> with an argument which is a reference or typeglob +which, when stringified, +contains a null character, started crashing in Perl 5.20, but has now been +fixed. +L<[perl #128182]|https://rt.perl.org/Public/Bug/Display.html?id=128182> + +=item * + +Improve the error message for a missing C<tie()> package/method. This +brings the error messages in line with the ones used for normal method +calls. + +=item * + +Parsing bad POSIX charclasses no longer leaks memory. +L<[perl #128313]|https://rt.perl.org/Public/Bug/Display.html?id=128313> + +=back + +=head1 Known Problems + +=over 4 + +=item * + +G++ 6 handles subnormal (denormal) floating point values differently +than gcc 6 or g++ 5 resulting in "flush-to-zero". The end result is +that if you specify very small values using the hexadecimal floating +point format, like C<0x1.fffffffffffffp-1022>, they become zeros. +L<[perl #131388]|https://rt.perl.org/Ticket/Display.html?id=131388> + +=back + +=head1 Errata From Previous Releases + +=over 4 + +=item * + +Fixed issues with recursive regexes. The behavior was fixed in Perl 5.24. +L<[perl #126182]|https://rt.perl.org/Public/Bug/Display.html?id=126182> + +=back + +=head1 Obituary + +Jon Portnoy (AVENJ), a prolific Perl author and admired Gentoo community +member, has passed away on August 10, 2016. He will be remembered and +missed by all those who he came in contact with, and enriched with his +intellect, wit, and spirit. + +It is with great sadness that we also note Kip Hampton's passing. Probably +best known as the author of the Perl & XML column on XML.com, he was a +core contributor to AxKit, an XML server platform that became an Apache +Foundation project. He was a frequent speaker in the early days at +OSCON, and most recently at YAPC::NA in Madison. He was frequently on +irc.perl.org as ubu, generally in the #axkit-dahut community, the +group responsible for YAPC::NA Asheville in 2011. + +Kip and his constant contributions to the community will be greatly +missed. + +=head1 Acknowledgements + +Perl 5.26.0 represents approximately 13 months of development since Perl 5.24.0 +and contains approximately 360,000 lines of changes across 2,600 files from 86 +authors. + +Excluding auto-generated files, documentation and release tools, there were +approximately 230,000 lines of changes to 1,800 .pm, .t, .c and .h files. + +Perl continues to flourish into its third decade thanks to a vibrant community +of users and developers. The following people are known to have contributed the +improvements that became Perl 5.26.0: + +Aaron Crane, Abigail, Ævar Arnfjörð Bjarmason, Alex Vandiver, Andreas +König, Andreas Voegele, Andrew Fresh, Andy Lester, Aristotle Pagaltzis, Chad +Granum, Chase Whitener, Chris 'BinGOs' Williams, Chris Lamb, Christian Hansen, +Christian Millour, Colin Newell, Craig A. Berry, Dagfinn Ilmari Mannsåker, Dan +Collins, Daniel Dragan, Dave Cross, Dave Rolsky, David Golden, David H. +Gutteridge, David Mitchell, Dominic Hargreaves, Doug Bell, E. Choroba, Ed Avis, +Father Chrysostomos, François Perrad, Hauke D, H.Merijn Brand, Hugo van der +Sanden, Ivan Pozdeev, James E Keenan, James Raspass, Jarkko Hietaniemi, Jerry +D. Hedden, Jim Cromie, J. Nick Koston, John Lightsey, Karen Etheridge, Karl +Williamson, Leon Timmermans, Lukas Mai, Matthew Horsfall, Maxwell Carey, Misty +De Meo, Neil Bowers, Nicholas Clark, Nicolas R., Niko Tyni, Pali, Paul +Marquess, Peter Avalos, Petr Písař, Pino Toscano, Rafael Garcia-Suarez, Reini +Urban, Renee Baecker, Ricardo Signes, Richard Levitte, Rick Delaney, Salvador +Fandiño, Samuel Thibault, Sawyer X, Sébastien Aperghis-Tramoni, Sergey +Aleynikov, Shlomi Fish, Smylers, Stefan Seifert, Steffen Müller, Stevan +Little, Steve Hay, Steven Humphrey, Sullivan Beck, Theo Buehler, Thomas Sibley, +Todd Rinaldo, Tomasz Konojacki, Tony Cook, Unicode Consortium, Yaroslav Kuzmin, +Yves Orton, Zefram. + +The list above is almost certainly incomplete as it is automatically generated +from version control history. In particular, it does not include the names of +the (very much appreciated) contributors who reported issues to the Perl bug +tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please see +the F<AUTHORS> file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the perl bug database at +L<https://rt.perl.org/>. There may also be information at +L<http://www.perl.org/>, the Perl Home Page. + +If you believe you have an unreported bug, please run the L<perlbug> program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C<perl -V>, +will be sent off to C<perlbug@perl.org> to be analysed by the Perl porting team. + +If the bug you are reporting has security implications which make it +inappropriate to send to a publicly archived mailing list, then see +L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION> +for details of how to report the issue. + +=head1 Give Thanks + +If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, +you can do so by running the C<perlthanks> program: + + perlthanks + +This will send an email to the Perl 5 Porters list with your show of thanks. + +=head1 SEE ALSO + +The F<Changes> file for an explanation of how to view exhaustive details on +what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut diff --git a/gnu/usr.bin/perl/pod/perl5261delta.pod b/gnu/usr.bin/perl/pod/perl5261delta.pod new file mode 100644 index 00000000000..227fc6e39f6 --- /dev/null +++ b/gnu/usr.bin/perl/pod/perl5261delta.pod @@ -0,0 +1,247 @@ +=encoding utf8 + +=head1 NAME + +perl5261delta - what is new for perl v5.26.1 + +=head1 DESCRIPTION + +This document describes differences between the 5.26.0 release and the 5.26.1 +release. + +If you are upgrading from an earlier release such as 5.24.0, first read +L<perl5260delta>, which describes differences between 5.24.0 and 5.26.0. + +=head1 Security + +=head2 [CVE-2017-12837] Heap buffer overflow in regular expression compiler + +Compiling certain regular expression patterns with the case-insensitive +modifier could cause a heap buffer overflow and crash perl. This has now been +fixed. +L<[perl #131582]|https://rt.perl.org/Public/Bug/Display.html?id=131582> + +=head2 [CVE-2017-12883] Buffer over-read in regular expression parser + +For certain types of syntax error in a regular expression pattern, the error +message could either contain the contents of a random, possibly large, chunk of +memory, or could crash perl. This has now been fixed. +L<[perl #131598]|https://rt.perl.org/Public/Bug/Display.html?id=131598> + +=head2 [CVE-2017-12814] C<$ENV{$key}> stack buffer overflow on Windows + +A possible stack buffer overflow in the C<%ENV> code on Windows has been fixed +by removing the buffer completely since it was superfluous anyway. +L<[perl #131665]|https://rt.perl.org/Public/Bug/Display.html?id=131665> + +=head1 Incompatible Changes + +There are no changes intentionally incompatible with 5.26.0. If any exist, +they are bugs, and we request that you submit a report. See L</Reporting +Bugs> below. + +=head1 Modules and Pragmata + +=head2 Updated Modules and Pragmata + +=over 4 + +=item * + +L<base> has been upgraded from version 2.25 to 2.26. + +The effects of dotless C<@INC> on this module have been limited by the +introduction of a more refined and accurate solution for removing C<'.'> from +C<@INC> while reducing the false positives. + +=item * + +L<charnames> has been upgraded from version 1.44 to 1.45. + +=item * + +L<Module::CoreList> has been upgraded from version 5.20170530 to 5.20170922_26. + +=back + +=head1 Platform Support + +=head2 Platform-Specific Notes + +=over 4 + +=item FreeBSD + +=over 4 + +=item * + +Building with B<g++> on FreeBSD-11.0 has been fixed. +L<[perl #131337]|https://rt.perl.org/Public/Bug/Display.html?id=131337> + +=back + +=item Windows + +=over 4 + +=item * + +Support for compiling perl on Windows using Microsoft Visual Studio 2017 +(containing Visual C++ 14.1) has been added. + +=item * + +Building XS modules with GCC 6 in a 64-bit build of Perl failed due to +incorrect mapping of C<strtoll> and C<strtoull>. This has now been fixed. +L<[perl #131726]|https://rt.perl.org/Public/Bug/Display.html?id=131726> +L<[cpan #121683]|https://rt.cpan.org/Public/Bug/Display.html?id=121683> +L<[cpan #122353]|https://rt.cpan.org/Public/Bug/Display.html?id=122353> + +=back + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +Several built-in functions previously had bugs that could cause them to write +to the internal stack without allocating room for the item being written. In +rare situations, this could have led to a crash. These bugs have now been +fixed, and if any similar bugs are introduced in future, they will be detected +automatically in debugging builds. +L<[perl #131732]|https://rt.perl.org/Public/Bug/Display.html?id=131732> + +=item * + +Using a symbolic ref with postderef syntax as the key in a hash lookup was +yielding an assertion failure on debugging builds. +L<[perl #131627]|https://rt.perl.org/Public/Bug/Display.html?id=131627> + +=item * + +List assignment (C<aassign>) could in some rare cases allocate an entry on the +mortal stack and leave the entry uninitialized. +L<[perl #131570]|https://rt.perl.org/Public/Bug/Display.html?id=131570> + +=item * + +Attempting to apply an attribute to an C<our> variable where a function of that +name already exists could result in a NULL pointer being supplied where an SV +was expected, crashing perl. +L<[perl #131597]|https://rt.perl.org/Public/Bug/Display.html?id=131597> + +=item * + +The code that vivifies a typeglob out of a code ref made some false assumptions +that could lead to a crash in cases such as C<< $::{"A"} = sub {}; \&{"A"} >>. +This has now been fixed. +L<[perl #131085]|https://rt.perl.org/Public/Bug/Display.html?id=131085> + +=item * + +C<my_atof2> no longer reads beyond the terminating NUL, which previously +occurred if the decimal point is immediately before the NUL. +L<[perl #131526]|https://rt.perl.org/Public/Bug/Display.html?id=131526> + +=item * + +Occasional "Malformed UTF-8 character" crashes in C<s//> on utf8 strings have +been fixed. +L<[perl #131575]|https://rt.perl.org/Public/Bug/Display.html?id=131575> + +=item * + +C<perldoc -f s> now finds C<s///>. +L<[perl #131371]|https://rt.perl.org/Public/Bug/Display.html?id=131371> + +=item * + +Some erroneous warnings after utf8 conversion have been fixed. +L<[perl #131190]|https://rt.perl.org/Public/Bug/Display.html?id=131190> + +=item * + +The C<jmpenv> frame to catch Perl exceptions is set up lazily, and this used to +be a bit too lazy. The catcher is now set up earlier, preventing some possible +crashes. +L<[perl #105930]|https://rt.perl.org/Public/Bug/Display.html?id=105930> + +=item * + +Spurious "Assuming NOT a POSIX class" warnings have been removed. +L<[perl #131522]|https://rt.perl.org/Public/Bug/Display.html?id=131522> + +=back + +=head1 Acknowledgements + +Perl 5.26.1 represents approximately 4 months of development since Perl 5.26.0 +and contains approximately 8,900 lines of changes across 85 files from 23 +authors. + +Excluding auto-generated files, documentation and release tools, there were +approximately 990 lines of changes to 38 .pm, .t, .c and .h files. + +Perl continues to flourish into its third decade thanks to a vibrant community +of users and developers. The following people are known to have contributed +the improvements that became Perl 5.26.1: + +Aaron Crane, Andy Dougherty, Aristotle Pagaltzis, Chris 'BinGOs' Williams, +Craig A. Berry, Dagfinn Ilmari Mannsåker, David Mitchell, E. Choroba, Eric +Herman, Father Chrysostomos, Jacques Germishuys, James E Keenan, John SJ +Anderson, Karl Williamson, Ken Brown, Lukas Mai, Matthew Horsfall, Ricardo +Signes, Sawyer X, Steve Hay, Tony Cook, Yves Orton, Zefram. + +The list above is almost certainly incomplete as it is automatically generated +from version control history. In particular, it does not include the names of +the (very much appreciated) contributors who reported issues to the Perl bug +tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please see +the F<AUTHORS> file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the perl bug database +at L<https://rt.perl.org/> . There may also be information at +L<http://www.perl.org/> , the Perl Home Page. + +If you believe you have an unreported bug, please run the L<perlbug> program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C<perl -V>, +will be sent off to perlbug@perl.org to be analysed by the Perl porting team. + +If the bug you are reporting has security implications which make it +inappropriate to send to a publicly archived mailing list, then see +L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION> for details of how to +report the issue. + +=head1 Give Thanks + +If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, you +can do so by running the C<perlthanks> program: + + perlthanks + +This will send an email to the Perl 5 Porters list with your show of thanks. + +=head1 SEE ALSO + +The F<Changes> file for an explanation of how to view exhaustive details on +what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut diff --git a/gnu/usr.bin/perl/pod/perl5262delta.pod b/gnu/usr.bin/perl/pod/perl5262delta.pod new file mode 100644 index 00000000000..5e528ea89f8 --- /dev/null +++ b/gnu/usr.bin/perl/pod/perl5262delta.pod @@ -0,0 +1,245 @@ +=encoding utf8 + +=head1 NAME + +perl5262delta - what is new for perl v5.26.2 + +=head1 DESCRIPTION + +This document describes differences between the 5.26.1 release and the 5.26.2 +release. + +If you are upgrading from an earlier release such as 5.26.0, first read +L<perl5261delta>, which describes differences between 5.26.0 and 5.26.1. + +=head1 Security + +=head2 [CVE-2018-6797] heap-buffer-overflow (WRITE of size 1) in S_regatom (regcomp.c) + +A crafted regular expression could cause a heap buffer write overflow, with +control over the bytes written. +L<[perl #132227]|https://rt.perl.org/Public/Bug/Display.html?id=132227> + +=head2 [CVE-2018-6798] Heap-buffer-overflow in Perl__byte_dump_string (utf8.c) + +Matching a crafted locale dependent regular expression could cause a heap +buffer read overflow and potentially information disclosure. +L<[perl #132063]|https://rt.perl.org/Public/Bug/Display.html?id=132063> + +=head2 [CVE-2018-6913] heap-buffer-overflow in S_pack_rec + +C<pack()> could cause a heap buffer write overflow with a large item count. +L<[perl #131844]|https://rt.perl.org/Public/Bug/Display.html?id=131844> + +=head2 Assertion failure in Perl__core_swash_init (utf8.c) + +Control characters in a supposed Unicode property name could cause perl to +crash. This has been fixed. +L<[perl #132055]|https://rt.perl.org/Public/Bug/Display.html?id=132055> +L<[perl #132553]|https://rt.perl.org/Public/Bug/Display.html?id=132553> +L<[perl #132658]|https://rt.perl.org/Public/Bug/Display.html?id=132658> + +=head1 Incompatible Changes + +There are no changes intentionally incompatible with 5.26.1. If any exist, +they are bugs, and we request that you submit a report. See L</Reporting +Bugs> below. + +=head1 Modules and Pragmata + +=head2 Updated Modules and Pragmata + +=over 4 + +=item * + +L<Module::CoreList> has been upgraded from version 5.20170922_26 to 5.20180414_26. + +=item * + +L<PerlIO::via> has been upgraded from version 0.16 to 0.17. + +=item * + +L<Term::ReadLine> has been upgraded from version 1.16 to 1.17. + +=item * + +L<Unicode::UCD> has been upgraded from version 0.68 to 0.69. + +=back + +=head1 Documentation + +=head2 Changes to Existing Documentation + +=head3 L<perluniprops> + +=over 4 + +=item * + +This has been updated to note that C<\p{Word}> now includes code points +matching the C<\p{Join_Control}> property. The change to the property was made +in Perl 5.18, but not documented until now. There are currently only two code +points that match this property: U+200C (ZERO WIDTH NON-JOINER) and U+200D +(ZERO WIDTH JOINER). + +=back + +=head1 Platform Support + +=head2 Platform-Specific Notes + +=over 4 + +=item Windows + +Visual C++ compiler version detection has been improved to work on non-English +language systems. +L<[perl #132421]|https://rt.perl.org/Public/Bug/Display.html?id=132421> + +We now set C<$Config{libpth}> correctly for 64-bit builds using Visual C++ +versions earlier than 14.1. +L<[perl #132484]|https://rt.perl.org/Public/Bug/Display.html?id=132484> + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +The C<readpipe()> built-in function now checks at compile time that it has only +one parameter expression, and puts it in scalar context, thus ensuring that it +doesn't corrupt the stack at runtime. +L<[perl #4574]|https://rt.perl.org/Public/Bug/Display.html?id=4574> + +=item * + +Fixed a use after free bug in C<pp_list> introduced in Perl 5.27.1. +L<[perl #131954]|https://rt.perl.org/Public/Bug/Display.html?id=131954> + +=item * + +Parsing a C<sub> definition could cause a use after free if the C<sub> keyword +was followed by whitespace including newlines (and comments). +L<[perl #131836]|https://rt.perl.org/Public/Bug/Display.html?id=131836> + +=item * + +The tokenizer now correctly adjusts a parse pointer when skipping whitespace in +an C< ${identifier} > construct. +L<[perl #131949]|https://rt.perl.org/Public/Bug/Display.html?id=131949> + +=item * + +Accesses to C<${^LAST_FH}> no longer assert after using any of a variety of I/O +operations on a non-glob. +L<[perl #128263]|https://rt.perl.org/Public/Bug/Display.html?id=128263> + +=item * + +C<sort> now performs correct reference counting when aliasing C<$a> and C<$b>, +thus avoiding premature destruction and leakage of scalars if they are +re-aliased during execution of the sort comparator. +L<[perl #92264]|https://rt.perl.org/Public/Bug/Display.html?id=92264> + +=item * + +Some convoluted kinds of regexp no longer cause an arithmetic overflow when +compiled. +L<[perl #131893]|https://rt.perl.org/Public/Bug/Display.html?id=131893> + +=item * + +Fixed a duplicate symbol failure with B<-flto -mieee-fp> builds. F<pp.c> +defined C<_LIB_VERSION> which B<-lieee> already defines. +L<[perl #131786]|https://rt.perl.org/Public/Bug/Display.html?id=131786> + +=item * + +A NULL pointer dereference in the C<S_regmatch()> function has been fixed. +L<[perl #132017]|https://rt.perl.org/Public/Bug/Display.html?id=132017> + +=item * + +Failures while compiling code within other constructs, such as with string +interpolation and the right part of C<s///e> now cause compilation to abort +earlier. + +Previously compilation could continue in order to report other errors, but the +failed sub-parse could leave partly parsed constructs on the parser +shift-reduce stack, confusing the parser, leading to perl crashes. +L<[perl #125351]|https://rt.perl.org/Public/Bug/Display.html?id=125351> + +=back + +=head1 Acknowledgements + +Perl 5.26.2 represents approximately 7 months of development since Perl 5.26.1 +and contains approximately 3,300 lines of changes across 82 files from 17 +authors. + +Excluding auto-generated files, documentation and release tools, there were +approximately 1,800 lines of changes to 36 .pm, .t, .c and .h files. + +Perl continues to flourish into its third decade thanks to a vibrant community +of users and developers. The following people are known to have contributed +the improvements that became Perl 5.26.2: + +Aaron Crane, Abigail, Chris 'BinGOs' Williams, H.Merijn Brand, James E Keenan, +Jarkko Hietaniemi, John SJ Anderson, Karen Etheridge, Karl Williamson, Lukas +Mai, Renee Baecker, Sawyer X, Steve Hay, Todd Rinaldo, Tony Cook, Yves Orton, +Zefram. + +The list above is almost certainly incomplete as it is automatically generated +from version control history. In particular, it does not include the names of +the (very much appreciated) contributors who reported issues to the Perl bug +tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please see +the F<AUTHORS> file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the perl bug database +at L<https://rt.perl.org/> . There may also be information at +L<http://www.perl.org/> , the Perl Home Page. + +If you believe you have an unreported bug, please run the L<perlbug> program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C<perl -V>, +will be sent off to perlbug@perl.org to be analysed by the Perl porting team. + +If the bug you are reporting has security implications which make it +inappropriate to send to a publicly archived mailing list, then see +L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION> +for details of how to report the issue. + +=head1 Give Thanks + +If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, +you can do so by running the C<perlthanks> program: + + perlthanks + +This will send an email to the Perl 5 Porters list with your show of thanks. + +=head1 SEE ALSO + +The F<Changes> file for an explanation of how to view exhaustive details on +what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut diff --git a/gnu/usr.bin/perl/pod/perl5280delta.pod b/gnu/usr.bin/perl/pod/perl5280delta.pod new file mode 100644 index 00000000000..0ecd260ca5a --- /dev/null +++ b/gnu/usr.bin/perl/pod/perl5280delta.pod @@ -0,0 +1,2438 @@ +=encoding utf8 + +=head1 NAME + +perl5280delta - what is new for perl v5.28.0 + +=head1 DESCRIPTION + +This document describes differences between the 5.26.0 release and the 5.28.0 +release. + +If you are upgrading from an earlier release such as 5.24.0, first read +L<perl5260delta>, which describes differences between 5.24.0 and 5.26.0. + +=head1 Core Enhancements + +=head2 Unicode 10.0 is supported + +A list of changes is at +L<http://www.unicode.org/versions/Unicode10.0.0>. + +=head2 L<C<delete>|perlfunc/delete EXPR> on key/value hash slices + +L<C<delete>|perlfunc/delete EXPR> can now be used on +L<keyE<sol>value hash slices|perldata/KeyE<sol>Value Hash Slices>, +returning the keys along with the deleted values. +L<[perl #131328]|https://rt.perl.org/Ticket/Display.html?id=131328> + +=head2 Experimentally, there are now alphabetic synonyms for some regular expression assertions + +If you find it difficult to remember how to write certain of the pattern +assertions, there are now alphabetic synonyms. + + CURRENT NEW SYNONYMS + ------ ------------ + (?=...) (*pla:...) or (*positive_lookahead:...) + (?!...) (*nla:...) or (*negative_lookahead:...) + (?<=...) (*plb:...) or (*positive_lookbehind:...) + (?<!...) (*nlb:...) or (*negative_lookbehind:...) + (?>...) (*atomic:...) + +These are considered experimental, so using any of these will raise +(unless turned off) a warning in the C<experimental::alpha_assertions> +category. + +=head2 Mixed Unicode scripts are now detectable + +A mixture of scripts, such as Cyrillic and Latin, in a string is often +the sign of a spoofing attack. A new regular expression construct +now allows for easy detection of these. For example, you can say + + qr/(*script_run: \d+ \b )/x + +And the digits matched will all be from the same set of 10. You won't +get a look-alike digit from a different script that has a different +value than what it appears to be. + +Or: + + qr/(*sr: \b \w+ \b )/x + +makes sure that all the characters come from the same script. + +You can also combine script runs with C<(?E<gt>...)> (or +C<*atomic:...)>). + +Instead of writing: + + (*sr:(?<...)) + +you can now run: + + (*asr:...) + # or + (*atomic_script_run:...) + +This is considered experimental, so using it will raise (unless turned +off) a warning in the C<experimental::script_run> category. + +See L<perlre/Script Runs>. + +=head2 In-place editing with C<perl -i> is now safer + +Previously in-place editing (C<perl -i>) would delete or rename the +input file as soon as you started working on a new file. + +Without backups this would result in loss of data if there was an +error, such as a full disk, when writing to the output file. + +This has changed so that the input file isn't replaced until the +output file has been completely written and successfully closed. + +This works by creating a work file in the same directory, which is +renamed over the input file once the output file is complete. + +Incompatibilities: + +=over + +=item * + +Since this renaming needs to only happen once, if you create a thread +or child process, that renaming will only happen in the original +thread or process. + +=item * + +If you change directories while processing a file, and your operating +system doesn't provide the C<unlinkat()>, C<renameat()> and C<fchmodat()> +functions, the final rename step may fail. + +=back + +L<[perl #127663]|https://rt.perl.org/Public/Bug/Display.html?id=127663> + +=head2 Initialisation of aggregate state variables + +A persistent lexical array or hash variable can now be initialized, +by an expression such as C<state @a = qw(x y z)>. Initialization of a +list of persistent lexical variables is still not possible. + +=head2 Full-size inode numbers + +On platforms where inode numbers are of a type larger than perl's native +integer numerical types, L<stat|perlfunc/stat> will preserve the full +content of large inode numbers by returning them in the form of strings of +decimal digits. Exact comparison of inode numbers can thus be achieved by +comparing with C<eq> rather than C<==>. Comparison with C<==>, and other +numerical operations (which are usually meaningless on inode numbers), +work as well as they did before, which is to say they fall back to +floating point, and ultimately operate on a fairly useless rounded inode +number if the real inode number is too big for the floating point format. + +=head2 The C<sprintf> C<%j> format size modifier is now available with pre-C99 compilers + +The actual size used depends on the platform, so remains unportable. + +=head2 Close-on-exec flag set atomically + +When opening a file descriptor, perl now generally opens it with its +close-on-exec flag already set, on platforms that support doing so. +This improves thread safety, because it means that an C<exec> initiated +by one thread can no longer cause a file descriptor in the process +of being opened by another thread to be accidentally passed to the +executed program. + +Additionally, perl now sets the close-on-exec flag more reliably, whether +it does so atomically or not. Most file descriptors were getting the +flag set, but some were being missed. + +=head2 String- and number-specific bitwise ops are no longer experimental + +The new string-specific (C<&. |. ^. ~.>) and number-specific (C<& | ^ ~>) +bitwise operators introduced in Perl 5.22 that are available within the +scope of C<use feature 'bitwise'> are no longer experimental. +Because the number-specific ops are spelled the same way as the existing +operators that choose their behaviour based on their operands, these +operators must still be enabled via the "bitwise" feature, in either of +these two ways: + + use feature "bitwise"; + + use v5.28; # "bitwise" now included + +They are also now enabled by the B<-E> command-line switch. + +The "bitwise" feature no longer emits a warning. Existing code that +disables the "experimental::bitwise" warning category that the feature +previously used will continue to work. + +One caveat that module authors ought to be aware of is that the numeric +operators now pass a fifth TRUE argument to overload methods. Any methods +that check the number of operands may croak if they do not expect so many. +XS authors in particular should be aware that this: + + SV * + bitop_handler (lobj, robj, swap) + +may need to be changed to this: + + SV * + bitop_handler (lobj, robj, swap, ...) + +=head2 Locales are now thread-safe on systems that support them + +These systems include Windows starting with Visual Studio 2005, and in +POSIX 2008 systems. + +The implication is that you are now free to use locales and change them +in a threaded environment. Your changes affect only your thread. +See L<perllocale/Multi-threaded operation> + +=head2 New read-only predefined variable C<${^SAFE_LOCALES}> + +This variable is 1 if the Perl interpreter is operating in an +environment where it is safe to use and change locales (see +L<perllocale>.) This variable is true when the perl is +unthreaded, or compiled in a platform that supports thread-safe locale +operation (see previous item). + +=head1 Security + +=head2 [CVE-2017-12837] Heap buffer overflow in regular expression compiler + +Compiling certain regular expression patterns with the case-insensitive +modifier could cause a heap buffer overflow and crash perl. This has now been +fixed. +L<[perl #131582]|https://rt.perl.org/Public/Bug/Display.html?id=131582> + +=head2 [CVE-2017-12883] Buffer over-read in regular expression parser + +For certain types of syntax error in a regular expression pattern, the error +message could either contain the contents of a random, possibly large, chunk of +memory, or could crash perl. This has now been fixed. +L<[perl #131598]|https://rt.perl.org/Public/Bug/Display.html?id=131598> + +=head2 [CVE-2017-12814] C<$ENV{$key}> stack buffer overflow on Windows + +A possible stack buffer overflow in the C<%ENV> code on Windows has been fixed +by removing the buffer completely since it was superfluous anyway. +L<[perl #131665]|https://rt.perl.org/Public/Bug/Display.html?id=131665> + +=head2 Default Hash Function Change + +Perl 5.28.0 retires various older hash functions which are not viewed as +sufficiently secure for use in Perl. We now support four general purpose +hash functions, Siphash (2-4 and 1-3 variants), and Zaphod32, and StadtX +hash. In addition we support SBOX32 (a form of tabular hashing) for hashing +short strings, in conjunction with any of the other hash functions provided. + +By default Perl is configured to support SBOX hashing of strings up to 24 +characters, in conjunction with StadtX hashing on 64 bit builds, and +Zaphod32 hashing for 32 bit builds. + +You may control these settings with the following options to Configure: + + -DPERL_HASH_FUNC_SIPHASH + -DPERL_HASH_FUNC_SIPHASH13 + -DPERL_HASH_FUNC_STADTX + -DPERL_HASH_FUNC_ZAPHOD32 + +To disable SBOX hashing you can use + + -DPERL_HASH_USE_SBOX32_ALSO=0 + +And to set the maximum length to use SBOX32 hashing on with: + + -DSBOX32_MAX_LEN=16 + +The maximum length allowed is 256. There probably isn't much point +in setting it higher than the default. + +=head1 Incompatible Changes + +=head2 Subroutine attribute and signature order + +The experimental subroutine signatures feature has been changed so that +subroutine attributes must now come before the signature rather than +after. This is because attributes like C<:lvalue> can affect the +compilation of code within the signature, for example: + + sub f :lvalue ($a = do { $x = "abc"; return substr($x,0,1)}) { ...} + +Note that this the second time they have been flipped: + + sub f :lvalue ($a, $b) { ... }; # 5.20; 5.28 onwards + sub f ($a, $b) :lvalue { ... }; # 5.22 - 5.26 + +=head2 Comma-less variable lists in formats are no longer allowed + +Omitting the commas between variables passed to formats is no longer +allowed. This has been deprecated since Perl 5.000. + +=head2 The C<:locked> and C<:unique> attributes have been removed + +These have been no-ops and deprecated since Perl 5.12 and 5.10, +respectively. + +=head2 C<\N{}> with nothing between the braces is now illegal + +This has been deprecated since Perl 5.24. + +=head2 Opening the same symbol as both a file and directory handle is no longer allowed + +Using C<open()> and C<opendir()> to associate both a filehandle and a dirhandle +to the same symbol (glob or scalar) has been deprecated since Perl 5.10. + +=head2 Use of bare C<< << >> to mean C<< <<"" >> is no longer allowed + +Use of a bare terminator has been deprecated since Perl 5.000. + +=head2 Setting $/ to a reference to a non-positive integer no longer allowed + +This used to work like setting it to C<undef>, but has been deprecated +since Perl 5.20. + +=head2 Unicode code points with values exceeding C<IV_MAX> are now fatal + +This was deprecated since Perl 5.24. + +=head2 The C<B::OP::terse> method has been removed + +Use C<B::Concise::b_terse> instead. + +=head2 Use of inherited AUTOLOAD for non-methods is no longer allowed + +This was deprecated in Perl 5.004. + +=head2 Use of strings with code points over 0xFF is not allowed for bitwise string operators + +Code points over C<0xFF> do not make sense for bitwise operators and such +an operation will now croak, except for a few remaining cases. See +L<perldeprecation>. + +This was deprecated in Perl 5.24. + +=head2 Setting C<${^ENCODING}> to a defined value is now illegal + +This has been deprecated since Perl 5.22 and a no-op since Perl 5.26. + +=head2 Backslash no longer escapes colon in PATH for the C<-S> switch + +Previously the C<-S> switch incorrectly treated backslash ("\") as an +escape for colon when traversing the C<PATH> environment variable. +L<[perl #129183]|https://rt.perl.org/Ticket/Display.html?id=129183> + +=head2 the -DH (DEBUG_H) misfeature has been removed + +On a perl built with debugging support, the C<H> flag to the C<-D> +debugging option has been removed. This was supposed to dump hash values, +but has been broken for many years. + +=head2 Yada-yada is now strictly a statement + +By the time of its initial stable release in Perl 5.12, the C<...> +(yada-yada) operator was explicitly intended to serve as a statement, +not an expression. However, the original implementation was confused +on this point, leading to inconsistent parsing. The operator was +accidentally accepted in a few situations where it did not serve as a +complete statement, such as + + ... . "foo"; + ... if $a < $b; + +The parsing has now been made consistent, permitting yada-yada only as +a statement. Affected code can use C<do{...}> to put a yada-yada into +an arbitrary expression context. + +=head2 Sort algorithm can no longer be specified + +Since Perl 5.8, the L<sort> pragma has had subpragmata C<_mergesort>, +C<_quicksort>, and C<_qsort> that can be used to specify which algorithm +perl should use to implement the L<sort|perlfunc/sort> builtin. +This was always considered a dubious feature that might not last, +hence the underscore spellings, and they were documented as not being +portable beyond Perl 5.8. These subpragmata have now been deleted, +and any attempt to use them is an error. The L<sort> pragma otherwise +remains, and the algorithm-neutral C<stable> subpragma can be used to +control sorting behaviour. +L<[perl #119635]|https://rt.perl.org/Ticket/Display.html?id=119635> + +=head2 Over-radix digits in floating point literals + +Octal and binary floating point literals used to permit any hexadecimal +digit to appear after the radix point. The digits are now restricted +to those appropriate for the radix, as digits before the radix point +always were. + +=head2 Return type of C<unpackstring()> + +The return types of the C API functions C<unpackstring()> and +C<unpack_str()> have changed from C<I32> to C<SSize_t>, in order to +accommodate datasets of more than two billion items. + +=head1 Deprecations + +=head2 Use of L<C<vec>|perlfunc/vec EXPR,OFFSET,BITS> on strings with code points above 0xFF is deprecated + +Such strings are represented internally in UTF-8, and C<vec> is a +bit-oriented operation that will likely give unexpected results on those +strings. + +=head2 Some uses of unescaped C<"{"> in regexes are no longer fatal + +Perl 5.26.0 fatalized some uses of an unescaped left brace, but an +exception was made at the last minute, specifically crafted to be a +minimal change to allow GNU Autoconf to work. That tool is heavily +depended upon, and continues to use the deprecated usage. Its use of an +unescaped left brace is one where we have no intention of repurposing +C<"{"> to be something other than itself. + +That exception is now generalized to include various other such cases +where the C<"{"> will not be repurposed. + +Note that these uses continue to raise a deprecation message. + +=head2 Use of unescaped C<"{"> immediately after a C<"("> in regular expression patterns is deprecated + +Using unescaped left braces is officially deprecated everywhere, but it +is not enforced in contexts where their use does not interfere with +expected extensions to the language. A deprecation is added in this +release when the brace appears immediately after an opening parenthesis. +Before this, even if the brace was part of a legal quantifier, it was +not interpreted as such, but as the literal characters, unlike other +quantifiers that follow a C<"("> which are considered errors. Now, +their use will raise a deprecation message, unless turned off. + +=head2 Assignment to C<$[> will be fatal in Perl 5.30 + +Assigning a non-zero value to L<C<$[>|perlvar/$[> has been deprecated +since Perl 5.12, but was never given a deadline for removal. This has +now been scheduled for Perl 5.30. + +=head2 hostname() won't accept arguments in Perl 5.32 + +Passing arguments to C<Sys::Hostname::hostname()> was already deprecated, +but didn't have a removal date. This has now been scheduled for Perl +5.32. L<[perl #124349]|https://rt.perl.org/Ticket/Display.html?id=124349> + +=head2 Module removals + +The following modules will be removed from the core distribution in a +future release, and will at that time need to be installed from CPAN. +Distributions on CPAN which require these modules will need to list them as +prerequisites. + +The core versions of these modules will now issue C<"deprecated">-category +warnings to alert you to this fact. To silence these deprecation warnings, +install the modules in question from CPAN. + +Note that these are (with rare exceptions) fine modules that you are encouraged +to continue to use. Their disinclusion from core primarily hinges on their +necessity to bootstrapping a fully functional, CPAN-capable Perl installation, +not usually on concerns over their design. + +=over + +=item B::Debug + +=item L<Locale::Codes> and its associated Country, Currency and Language modules + +=back + +=head1 Performance Enhancements + +=over 4 + +=item * + +The start up overhead for creating regular expression patterns with +Unicode properties (C<\p{...}>) has been greatly reduced in most cases. + +=item * + +Many string concatenation expressions are now considerably faster, due +to the introduction internally of a C<multiconcat> opcode which combines +multiple concatenations, and optionally a C<=> or C<.=>, into a single +action. For example, apart from retrieving C<$s>, C<$a> and C<$b>, this +whole expression is now handled as a single op: + + $s .= "a=$a b=$b\n" + +As a special case, if the LHS of an assignment is a lexical variable or +C<my $s>, the op itself handles retrieving the lexical variable, which +is faster. + +In general, the more the expression includes a mix of constant strings and +variable expressions, the longer the expression, and the more it mixes +together non-utf8 and utf8 strings, the more marked the performance +improvement. For example on a C<x86_64> system, this code has been +benchmarked running four times faster: + + my $s; + my $a = "ab\x{100}cde"; + my $b = "fghij"; + my $c = "\x{101}klmn"; + + for my $i (1..10_000_000) { + $s = "\x{100}wxyz"; + $s .= "foo=$a bar=$b baz=$c"; + } + +In addition, C<sprintf> expressions which have a constant format +containing only C<%s> and C<%%> format elements, and which have a fixed +number of arguments, are now also optimised into a C<multiconcat> op. + +=item * + +The C<ref()> builtin is now much faster in boolean context, since it no +longer bothers to construct a temporary string like C<Foo=ARRAY(0x134af48)>. + +=item * + +C<keys()> in void and scalar contexts is now more efficient. + +=item * + +The common idiom of comparing the result of index() with -1 is now +specifically optimised, e.g. + + if (index(...) != -1) { ... } + +=item * + +C<for()> loops and similar constructs are now more efficient in most cases. + +=item * + +L<File::Glob> has been modified to remove unnecessary backtracking and +recursion, thanks to Russ Cox. See L<https://research.swtch.com/glob> +for more details. + +=item * + +The XS-level C<SvTRUE()> API function is now more efficient. + +=item * + +Various integer-returning ops are now more efficient in scalar/boolean context. + +=item * + +Slightly improved performance when parsing stash names. +L<[perl #129990]|https://rt.perl.org/Public/Bug/Display.html?id=129990> + +=item * + +Calls to C<require> for an already loaded module are now slightly faster. +L<[perl #132171]|https://rt.perl.org/Public/Bug/Display.html?id=132171> + +=item * + +The performance of pattern matching C<[[:ascii:]]> and C<[[:^ascii:]]> +has been improved significantly except on EBCDIC platforms. + +=item * + +Various optimizations have been applied to matching regular expression +patterns, so under the right circumstances, significant performance +gains may be noticed. But in an application with many varied patterns, +little overall improvement likely will be seen. + +=item * + +Other optimizations have been applied to UTF-8 handling, but these are +not typically a major factor in most applications. + +=back + +=head1 Modules and Pragmata + +Key highlights in this release across several modules: + +=head2 Removal of use vars + +The usage of C<use vars> has been discouraged since the introduction of +C<our> in Perl 5.6.0. Where possible the usage of this pragma has now been +removed from the Perl source code. + +This had a slight effect (for the better) on the output of WARNING_BITS in +L<B::Deparse>. + +=head2 Use of DynaLoader changed to XSLoader in many modules + +XSLoader is more modern, and most modules already require perl 5.6 or +greater, so no functionality is lost by switching. In some cases, we have +also made changes to the local implementation that may not be reflected in +the version on CPAN due to a desire to maintain more backwards +compatibility. + +=head2 Updated Modules and Pragmata + +=over 4 + +=item * + +L<Archive::Tar> has been upgraded from version 2.24 to 2.30. + +This update also handled CVE-2018-12015: directory traversal +vulnerability. +L<[cpan #125523]|https://rt.cpan.org/Ticket/Display.html?id=125523> + +=item * + +L<arybase> has been upgraded from version 0.12 to 0.15. + +=item * + +L<Attribute::Handlers> has been upgraded from version 0.99 to 1.01. + +=item * + +L<attributes> has been upgraded from version 0.29 to 0.33. + +=item * + +L<B> has been upgraded from version 1.68 to 1.74. + +=item * + +L<B::Concise> has been upgraded from version 0.999 to 1.003. + +=item * + +L<B::Debug> has been upgraded from version 1.24 to 1.26. + +NOTE: L<B::Debug> is deprecated and may be removed from a future version +of Perl. + +=item * + +L<B::Deparse> has been upgraded from version 1.40 to 1.48. + +It includes many bug fixes, and in particular, it now deparses variable +attributes correctly: + + my $x :foo; # used to deparse as + # 'attributes'->import('main', \$x, 'foo'), my $x; + +=item * + +L<base> has been upgraded from version 2.25 to 2.27. + +=item * + +L<bignum> has been upgraded from version 0.47 to 0.49. + +=item * + +L<blib> has been upgraded from version 1.06 to 1.07. + +=item * + +L<bytes> has been upgraded from version 1.05 to 1.06. + +=item * + +L<Carp> has been upgraded from version 1.42 to 1.50. + +If a package on the call stack contains a constant named C<ISA>, Carp no +longer throws a "Not a GLOB reference" error. + +L<Carp>, when generating stack traces, now attempts to work around +longstanding bugs resulting from Perl's non-reference-counted stack. +L<[perl #52610]|https://rt.perl.org/Ticket/Display.html?id=52610> + +Carp has been modified to avoid assuming that objects cannot be +overloaded without the L<overload> module loaded (this can happen with +objects created by XS modules). Previously, infinite recursion would +result if an XS-defined overload method itself called Carp. +L<[perl #132828]|https://rt.perl.org/Ticket/Display.html?id=132828> + +Carp now avoids using C<overload::StrVal>, partly because older versions +of L<overload> (included with perl 5.14 and earlier) load L<Scalar::Util> +at run time, which will fail if Carp has been invoked after a syntax error. + +=item * + +L<charnames> has been upgraded from version 1.44 to 1.45. + +=item * + +L<Compress::Raw::Zlib> has been upgraded from version 2.074 to 2.076. + +This addresses a security vulnerability in older versions of the 'zlib' library +(which is bundled with Compress-Raw-Zlib). + +=item * + +L<Config::Extensions> has been upgraded from version 0.01 to 0.02. + +=item * + +L<Config::Perl::V> has been upgraded from version 0.28 to 0.29. + +=item * + +L<CPAN> has been upgraded from version 2.18 to 2.20. + +=item * + +L<Data::Dumper> has been upgraded from version 2.167 to 2.170. + +Quoting of glob names now obeys the Useqq option +L<[perl #119831]|https://rt.perl.org/Ticket/Display.html?id=119831>. + +Attempts to set an option to C<undef> through a combined getter/setter +method are no longer mistaken for getter calls +L<[perl #113090]|https://rt.perl.org/Ticket/Display.html?id=113090>. + +=item * + +L<Devel::Peek> has been upgraded from version 1.26 to 1.27. + +=item * + +L<Devel::PPPort> has been upgraded from version 3.35 to 3.40. + +L<Devel::PPPort> has moved from cpan-first to perl-first maintenance + +Primary responsibility for the code in Devel::PPPort has moved into core perl. +In a practical sense there should be no change except that hopefully it will +stay more up to date with changes made to symbols in perl, rather than needing +to be updated after the fact. + +=item * + +L<Digest::SHA> has been upgraded from version 5.96 to 6.01. + +=item * + +L<DirHandle> has been upgraded from version 1.04 to 1.05. + +=item * + +L<DynaLoader> has been upgraded from version 1.42 to 1.45. + +Its documentation now shows the use of C<__PACKAGE__> and direct object +syntax +L<[perl #132247]|https://rt.perl.org/Ticket/Display.html?id=132247>. + +=item * + +L<Encode> has been upgraded from version 2.88 to 2.97. + +=item * + +L<encoding> has been upgraded from version 2.19 to 2.22. + +=item * + +L<Errno> has been upgraded from version 1.28 to 1.29. + +=item * + +L<experimental> has been upgraded from version 0.016 to 0.019. + +=item * + +L<Exporter> has been upgraded from version 5.72 to 5.73. + +=item * + +L<ExtUtils::CBuilder> has been upgraded from version 0.280225 to 0.280230. + +=item * + +L<ExtUtils::Constant> has been upgraded from version 0.23 to 0.25. + +=item * + +L<ExtUtils::Embed> has been upgraded from version 1.34 to 1.35. + +=item * + +L<ExtUtils::Install> has been upgraded from version 2.04 to 2.14. + +=item * + +L<ExtUtils::MakeMaker> has been upgraded from version 7.24 to 7.34. + +=item * + +L<ExtUtils::Miniperl> has been upgraded from version 1.06 to 1.08. + +=item * + +L<ExtUtils::ParseXS> has been upgraded from version 3.34 to 3.39. + +=item * + +L<ExtUtils::Typemaps> has been upgraded from version 3.34 to 3.38. + +=item * + +L<ExtUtils::XSSymSet> has been upgraded from version 1.3 to 1.4. + +=item * + +L<feature> has been upgraded from version 1.47 to 1.52. + +=item * + +L<fields> has been upgraded from version 2.23 to 2.24. + +=item * + +L<File::Copy> has been upgraded from version 2.32 to 2.33. + +It will now use the sub-second precision variant of utime() supplied by +L<Time::HiRes> where available. +L<[perl #132401]|https://rt.perl.org/Ticket/Display.html?id=132401>. + +=item * + +L<File::Fetch> has been upgraded from version 0.52 to 0.56. + +=item * + +L<File::Glob> has been upgraded from version 1.28 to 1.31. + +=item * + +L<File::Path> has been upgraded from version 2.12_01 to 2.15. + +=item * + +L<File::Spec> and L<Cwd> have been upgraded from version 3.67 to 3.74. + +=item * + +L<File::stat> has been upgraded from version 1.07 to 1.08. + +=item * + +L<FileCache> has been upgraded from version 1.09 to 1.10. + +=item * + +L<Filter::Simple> has been upgraded from version 0.93 to 0.95. + +=item * + +L<Filter::Util::Call> has been upgraded from version 1.55 to 1.58. + +=item * + +L<GDBM_File> has been upgraded from version 1.15 to 1.17. + +Its documentation now explains that C<each> and C<delete> don't mix in +hashes tied to this module +L<[perl #117449]|https://rt.perl.org/Ticket/Display.html?id=117449>. + +It will now retry opening with an acceptable block size if asking gdbm +to default the block size failed +L<[perl #119623]|https://rt.perl.org/Ticket/Display.html?id=119623>. + +=item * + +L<Getopt::Long> has been upgraded from version 2.49 to 2.5. + +=item * + +L<Hash::Util::FieldHash> has been upgraded from version 1.19 to 1.20. + +=item * + +L<I18N::Langinfo> has been upgraded from version 0.13 to 0.17. + +This module is now available on all platforms, emulating the system +L<nl_langinfo(3)> on systems that lack it. Some caveats apply, as +L<detailed in its documentation|I18N::Langinfo>, the most severe being +that, except for MS Windows, the C<CODESET> item is not implemented on +those systems, always returning C<"">. + +It now sets the UTF-8 flag in its returned scalar if the string contains +legal non-ASCII UTF-8, and the locale is UTF-8 +L<[perl #127288]|https://rt.perl.org/Ticket/Display.html?id=127288>. + +This update also fixes a bug in which the underlying locale was ignored +for the C<RADIXCHAR> (always was returned as a dot) and the C<THOUSEP> +(always empty). Now the locale-appropriate values are returned. + +=item * + +L<I18N::LangTags> has been upgraded from version 0.42 to 0.43. + +=item * + +L<if> has been upgraded from version 0.0606 to 0.0608. + +=item * + +L<IO> has been upgraded from version 1.38 to 1.39. + +=item * + +L<IO::Socket::IP> has been upgraded from version 0.38 to 0.39. + +=item * + +L<IPC::Cmd> has been upgraded from version 0.96 to 1.00. + +=item * + +L<JSON::PP> has been upgraded from version 2.27400_02 to 2.97001. + +=item * + +The C<libnet> distribution has been upgraded from version 3.10 to 3.11. + +=item * + +L<List::Util> has been upgraded from version 1.46_02 to 1.49. + +=item * + +L<Locale::Codes> has been upgraded from version 3.42 to 3.56. + +B<NOTE>: L<Locale::Codes> scheduled to be removed from core in Perl 5.30. + +=item * + +L<Locale::Maketext> has been upgraded from version 1.28 to 1.29. + +=item * + +L<Math::BigInt> has been upgraded from version 1.999806 to 1.999811. + +=item * + +L<Math::BigInt::FastCalc> has been upgraded from version 0.5005 to 0.5006. + +=item * + +L<Math::BigRat> has been upgraded from version 0.2611 to 0.2613. + +=item * + +L<Module::CoreList> has been upgraded from version 5.20170530 to 5.20180622. + +=item * + +L<mro> has been upgraded from version 1.20 to 1.22. + +=item * + +L<Net::Ping> has been upgraded from version 2.55 to 2.62. + +=item * + +L<NEXT> has been upgraded from version 0.67 to 0.67_01. + +=item * + +L<ODBM_File> has been upgraded from version 1.14 to 1.15. + +=item * + +L<Opcode> has been upgraded from version 1.39 to 1.43. + +=item * + +L<overload> has been upgraded from version 1.28 to 1.30. + +=item * + +L<PerlIO::encoding> has been upgraded from version 0.25 to 0.26. + +=item * + +L<PerlIO::scalar> has been upgraded from version 0.26 to 0.29. + +=item * + +L<PerlIO::via> has been upgraded from version 0.16 to 0.17. + +=item * + +L<Pod::Functions> has been upgraded from version 1.11 to 1.13. + +=item * + +L<Pod::Html> has been upgraded from version 1.2202 to 1.24. + +A title for the HTML document will now be automatically generated by +default from a "NAME" section in the POD document, as it used to be +before the module was rewritten to use L<Pod::Simple::XHTML> to do the +core of its job +L<[perl #110520]|https://rt.perl.org/Ticket/Display.html?id=110520>. + +=item * + +L<Pod::Perldoc> has been upgraded from version 3.28 to 3.2801. + +=item * + +The C<podlators> distribution has been upgraded from version 4.09 to 4.10. + +Man page references and function names now follow the Linux man page +formatting standards, instead of the Solaris standard. + +=item * + +L<POSIX> has been upgraded from version 1.76 to 1.84. + +Some more cautions were added about using locale-specific functions in +threaded applications. + +=item * + +L<re> has been upgraded from version 0.34 to 0.36. + +=item * + +L<Scalar::Util> has been upgraded from version 1.46_02 to 1.50. + +=item * + +L<SelfLoader> has been upgraded from version 1.23 to 1.25. + +=item * + +L<Socket> has been upgraded from version 2.020_03 to 2.027. + +=item * + +L<sort> has been upgraded from version 2.02 to 2.04. + +=item * + +L<Storable> has been upgraded from version 2.62 to 3.08. + +=item * + +L<Sub::Util> has been upgraded from version 1.48 to 1.49. + +=item * + +L<subs> has been upgraded from version 1.02 to 1.03. + +=item * + +L<Sys::Hostname> has been upgraded from version 1.20 to 1.22. + +=item * + +L<Term::ReadLine> has been upgraded from version 1.16 to 1.17. + +=item * + +L<Test> has been upgraded from version 1.30 to 1.31. + +=item * + +L<Test::Harness> has been upgraded from version 3.38 to 3.42. + +=item * + +L<Test::Simple> has been upgraded from version 1.302073 to 1.302133. + +=item * + +L<threads> has been upgraded from version 2.15 to 2.22. + +The documentation now better describes the problems that arise when +returning values from threads, and no longer warns about creating threads +in C<BEGIN> blocks. +L<[perl #96538]|https://rt.perl.org/Ticket/Display.html?id=96538> + +=item * + +L<threads::shared> has been upgraded from version 1.56 to 1.58. + +=item * + +L<Tie::Array> has been upgraded from version 1.06 to 1.07. + +=item * + +L<Tie::StdHandle> has been upgraded from version 4.4 to 4.5. + +=item * + +L<Time::gmtime> has been upgraded from version 1.03 to 1.04. + +=item * + +L<Time::HiRes> has been upgraded from version 1.9741 to 1.9759. + +=item * + +L<Time::localtime> has been upgraded from version 1.02 to 1.03. + +=item * + +L<Time::Piece> has been upgraded from version 1.31 to 1.3204. + +=item * + +L<Unicode::Collate> has been upgraded from version 1.19 to 1.25. + +=item * + +L<Unicode::Normalize> has been upgraded from version 1.25 to 1.26. + +=item * + +L<Unicode::UCD> has been upgraded from version 0.68 to 0.70. + +The function C<num> now accepts an optional parameter to help in +diagnosing error returns. + +=item * + +L<User::grent> has been upgraded from version 1.01 to 1.02. + +=item * + +L<User::pwent> has been upgraded from version 1.00 to 1.01. + +=item * + +L<utf8> has been upgraded from version 1.19 to 1.21. + +=item * + +L<vars> has been upgraded from version 1.03 to 1.04. + +=item * + +L<version> has been upgraded from version 0.9917 to 0.9923. + +=item * + +L<VMS::DCLsym> has been upgraded from version 1.08 to 1.09. + +=item * + +L<VMS::Stdio> has been upgraded from version 2.41 to 2.44. + +=item * + +L<warnings> has been upgraded from version 1.37 to 1.42. + +It now includes new functions with names ending in C<_at_level>, allowing +callers to specify the exact call frame. +L<[perl #132468]|https://rt.perl.org/Ticket/Display.html?id=132468> + +=item * + +L<XS::Typemap> has been upgraded from version 0.15 to 0.16. + +=item * + +L<XSLoader> has been upgraded from version 0.27 to 0.30. + +Its documentation now shows the use of C<__PACKAGE__>, and direct object +syntax for example C<DynaLoader> usage +L<[perl #132247]|https://rt.perl.org/Ticket/Display.html?id=132247>. + +Platforms that use C<mod2fname> to edit the names of loadable +libraries now look for bootstrap (.bs) files under the correct, +non-edited name. + +=back + +=head2 Removed Modules and Pragmata + +=over 4 + +=item * + +The C<VMS::stdio> compatibility shim has been removed. + +=back + +=head1 Documentation + +=head2 Changes to Existing Documentation + +We have attempted to update the documentation to reflect the changes +listed in this document. If you find any we have missed, send email +to L<perlbug@perl.org|mailto:perlbug@perl.org>. + +Additionally, the following selected changes have been made: + +=head3 L<perlapi> + +=over 4 + +=item * + +The API functions C<perl_parse()>, C<perl_run()>, and C<perl_destruct()> +are now documented comprehensively, where previously the only +documentation was a reference to the L<perlembed> tutorial. + +=item * + +The documentation of C<newGIVENOP()> has been belatedly updated to +account for the removal of lexical C<$_>. + +=item * + +The API functions C<newCONSTSUB()> and C<newCONSTSUB_flags()> are +documented much more comprehensively than before. + +=back + +=head3 L<perldata> + +=over 4 + +=item * + +The section "Truth and Falsehood" in L<perlsyn> has been moved into +L<perldata>. + +=back + +=head3 L<perldebguts> + +=over 4 + +=item * + +The description of the conditions under which C<DB::sub()> will be called +has been clarified. +L<[perl #131672]|https://rt.perl.org/Ticket/Display.html?id=131672> + +=back + +=head3 L<perldiag> + +=over 4 + +=item * L<perldiag/Variable length lookbehind not implemented in regex mE<sol>%sE<sol>> + +This now gives more ideas as to workarounds to the issue that was +introduced in Perl 5.18 (but not documented explicitly in its perldelta) +for the fact that some Unicode C</i> rules cause a few sequences such as + + (?<!st) + +to be considered variable length, and hence disallowed. + +=item * "Use of state $_ is experimental" in L<perldiag> + +This entry has been removed, as the experimental support of this construct was +removed in perl 5.24.0. + +=item * + +The diagnostic C<Initialization of state variables in list context +currently forbidden> has changed to C<Initialization of state variables +in list currently forbidden>, because list-context initialization of +single aggregate state variables is now permitted. + +=back + +=head3 L<perlembed> + +=over 4 + +=item * + +The examples in L<perlembed> have been made more portable in the way +they exit, and the example that gets an exit code from the embedded Perl +interpreter now gets it from the right place. The examples that pass +a constructed argv to Perl now show the mandatory null C<argv[argc]>. + +=item * + +An example in L<perlembed> used the string value of C<ERRSV> as a +format string when calling croak(). If that string contains format +codes such as C<%s> this could crash the program. + +This has been changed to a call to croak_sv(). + +An alternative could have been to supply a trivial format string: + + croak("%s", SvPV_nolen(ERRSV)); + +or as a special case for C<ERRSV> simply: + + croak(NULL); + +=back + +=head3 L<perlfunc> + +=over 4 + +=item * + +There is now a note that warnings generated by built-in functions are +documented in L<perldiag> and L<warnings>. +L<[perl #116080]|https://rt.perl.org/Ticket/Display.html?id=116080> + +=item * + +The documentation for the C<exists> operator no longer says that +autovivification behaviour "may be fixed in a future release". +We've determined that we're not going to change the default behaviour. +L<[perl #127712]|https://rt.perl.org/Ticket/Display.html?id=127712> + +=item * + +A couple of small details in the documentation for the C<bless> operator +have been clarified. +L<[perl #124428]|https://rt.perl.org/Ticket/Display.html?id=124428> + +=item * + +The description of C<@INC> hooks in the documentation for C<require> +has been corrected to say that filter subroutines receive a useless +first argument. +L<[perl #115754]|https://rt.perl.org/Ticket/Display.html?id=115754> + +=item * + +The documentation of C<ref> has been rewritten for clarity. + +=item * + +The documentation of C<use> now explains what syntactically qualifies +as a version number for its module version checking feature. + +=item * + +The documentation of C<warn> has been updated to reflect that since Perl +5.14 it has treated complex exception objects in a manner equivalent +to C<die>. +L<[perl #121372]|https://rt.perl.org/Ticket/Display.html?id=121372> + +=item * + +The documentation of C<die> and C<warn> has been revised for clarity. + +=item * + +The documentation of C<each> has been improved, with a slightly more +explicit description of the sharing of iterator state, and with +caveats regarding the fragility of while-each loops. +L<[perl #132644]|https://rt.perl.org/Ticket/Display.html?id=132644> + +=item * + +Clarification to C<require> was added to explain the differences between + + require Foo::Bar; + require "Foo/Bar.pm"; + +=back + +=head3 L<perlgit> + +=over 4 + +=item * + +The precise rules for identifying C<smoke-me> branches are now stated. + +=back + +=head3 L<perlguts> + +=over 4 + +=item * + +The section on reference counting in L<perlguts> has been heavily revised, +to describe references in the way a programmer needs to think about them +rather than in terms of the physical data structures. + +=item * + +Improve documentation related to UTF-8 multibytes. + +=back + +=head3 L<perlintern> + +=over 4 + +=item * + +The internal functions C<newXS_len_flags()> and C<newATTRSUB_x()> are +now documented. + +=back + +=head3 L<perlobj> + +=over 4 + +=item * + +The documentation about C<DESTROY> methods has been corrected, updated, +and revised, especially in regard to how they interact with exceptions. +L<[perl #122753]|https://rt.perl.org/Ticket/Display.html?id=122753> + +=back + +=head3 L<perlop> + +=over 4 + +=item * + +The description of the C<x> operator in L<perlop> has been clarified. +L<[perl #132460]|https://rt.perl.org/Ticket/Display.html?id=132460> + +=item * + +L<perlop> has been updated to note that C<qw>'s whitespace rules differ +from that of C<split>'s in that only ASCII whitespace is used. + +=item * + +The general explanation of operator precedence and associativity has +been corrected and clarified. +L<[perl #127391]|https://rt.perl.org/Ticket/Display.html?id=127391> + +=item * + +The documentation for the C<\> referencing operator now explains the +unusual context that it supplies to its operand. +L<[perl #131061]|https://rt.perl.org/Ticket/Display.html?id=131061> + +=back + +=head3 L<perlrequick> + +=over 4 + +=item * + +Clarifications on metacharacters and character classes + +=back + +=head3 L<perlretut> + +=over 4 + +=item * + +Clarify metacharacters. + +=back + +=head3 L<perlrun> + +=over 4 + +=item * + +Clarify the differences between B<< -M >> and B<< -m >>. +L<[perl #131518]|https://rt.perl.org/Ticket/Display.html?id=131518> + +=back + +=head3 L<perlsec> + +=over 4 + +=item * + +The documentation about set-id scripts has been updated and revised. +L<[perl #74142]|https://rt.perl.org/Ticket/Display.html?id=74142> + +=item * + +A section about using C<sudo> to run Perl scripts has been added. + +=back + +=head3 L<perlsyn> + +=over 4 + +=item * + +The section "Truth and Falsehood" in L<perlsyn> has been removed from +that document, where it didn't belong, and merged into the existing +paragraph on the same topic in L<perldata>. + +=item * + +The means to disambiguate between code blocks and hash constructors, +already documented in L<perlref>, are now documented in L<perlsyn> too. +L<[perl #130958]|https://rt.perl.org/Ticket/Display.html?id=130958> + +=back + +=head3 L<perluniprops> + +=over 4 + +=item * + +L<perluniprops> has been updated to note that C<\p{Word}> now includes +code points matching the C<\p{Join_Control}> property. The change to +the property was made in Perl 5.18, but not documented until now. There +are currently only two code points that match this property U+200C (ZERO +WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER). + +=item * + +For each binary table or property, the documentation now includes which +characters in the range C<\x00-\xFF> it matches, as well as a list of +the first few ranges of code points matched above that. + +=back + +=head3 L<perlvar> + +=over 4 + +=item * + +The entry for C<$+> in perlvar has been expanded upon to describe handling of +multiply-named capturing groups. + +=back + +=head3 L<perlfunc>, L<perlop>, L<perlsyn> + +=over 4 + +=item * + +In various places, improve the documentation of the special cases +in the condition expression of a while loop, such as implicit C<defined> +and assignment to C<$_>. +L<[perl #132644]|https://rt.perl.org/Ticket/Display.html?id=132644> + +=back + +=head1 Diagnostics + +The following additions or changes have been made to diagnostic output, +including warnings and fatal error messages. For the complete list of +diagnostic messages, see L<perldiag>. + +=head2 New Diagnostics + +=head3 New Errors + +=over 4 + +=item * + +L<Can't "goto" into a "given" block|perldiag/"Can't E<quot>gotoE<quot> into a E<quot>givenE<quot> block"> + +(F) A "goto" statement was executed to jump into the middle of a C<given> +block. You can't get there from here. See L<perlfunc/goto>. + +=item * + +L<Can't "goto" into a binary or list expression|perldiag/"Can't E<quot>gotoE<quot> into a binary or list expression"> + +Use of C<goto> to jump into the parameter of a binary or list operator has +been prohibited, to prevent crashes and stack corruption. +L<[perl #130936]|https://rt.perl.org/Ticket/Display.html?id=130936> + +You may only enter the I<first> argument of an operator that takes a fixed +number of arguments, since this is a case that will not cause stack +corruption. +L<[perl #132854]|https://rt.perl.org/Ticket/Display.html?id=132854> + +=back + +=head3 New Warnings + +=over 4 + +=item * + +L<Old package separator used in string|perldiag/"Old package separator used in string"> + +(W syntax) You used the old package separator, "'", in a variable +named inside a double-quoted string; e.g., C<"In $name's house">. This +is equivalent to C<"In $name::s house">. If you meant the former, put +a backslash before the apostrophe (C<"In $name\'s house">). + +=item * + +L<perldiag/Locale '%s' contains (at least) the following characters which +have unexpected meanings: %s The Perl program will use the expected +meanings> + +=back + +=head2 Changes to Existing Diagnostics + +=over 4 + +=item * + +A false-positive warning that was issued when using a +numerically-quantified sub-pattern in a recursive regex has been +silenced. L<[perl #131868]|https://rt.perl.org/Public/Bug/Display.html?id=131868> + +=item * + +The warning about useless use of a concatenation operator in void context +is now generated for expressions with multiple concatenations, such as +C<$a.$b.$c>, which used to mistakenly not warn. +L<[perl #6997]|https://rt.perl.org/Ticket/Display.html?id=6997> + +=item * + +Warnings that a variable or subroutine "masks earlier declaration in same +...", or that an C<our> variable has been redeclared, have been moved to a +new warnings category "shadow". Previously they were in category "misc". + +=item * + +The deprecation warning from C<Sys::Hostname::hostname()> saying that +it doesn't accept arguments now states the Perl version in which the +warning will be upgraded to an error. +L<[perl #124349]|https://rt.perl.org/Ticket/Display.html?id=124349> + +=item * + +The L<perldiag> entry for the error regarding a set-id script has been +expanded to make clear that the error is reporting a specific security +vulnerability, and to advise how to fix it. + +=item * + +The C<< Unable to flush stdout >> error message was missing a trailing +newline. [debian #875361] + +=back + +=head1 Utility Changes + +=head2 L<perlbug> + +=over 4 + +=item * + +C<--help> and C<--version> options have been added. + +=back + +=head1 Configuration and Compilation + +=over 4 + +=item * C89 requirement + +Perl has been documented as requiring a C89 compiler to build since October +1998. A variety of simplifications have now been made to Perl's internals to +rely on the features specified by the C89 standard. We believe that this +internal change hasn't altered the set of platforms that Perl builds on, but +please report a bug if Perl now has new problems building on your platform. + +=item * + +On GCC, C<-Werror=pointer-arith> is now enabled by default, +disallowing arithmetic on void and function pointers. + +=item * + +Where an HTML version of the documentation is installed, the HTML +documents now use relative links to refer to each other. Links from +the index page of L<perlipc> to the individual section documents are +now correct. +L<[perl #110056]|https://rt.perl.org/Ticket/Display.html?id=110056> + +=item * + +F<lib/unicore/mktables> now correctly canonicalizes the names of the +dependencies stored in the files it generates. + +F<regen/mk_invlists.pl>, unlike the other F<regen/*.pl> scripts, used +C<$0> to name itself in the dependencies stored in the files it +generates. It now uses a literal so that the path stored in the +generated files doesn't depend on how F<regen/mk_invlists.pl> is +invoked. + +This lack of canonical names could cause test failures in F<t/porting/regen.t>. +L<[perl #132925]|https://rt.perl.org/Ticket/Display.html?id=132925> + +=item * New probes + +=over 2 + +=item HAS_BUILTIN_ADD_OVERFLOW + +=item HAS_BUILTIN_MUL_OVERFLOW + +=item HAS_BUILTIN_SUB_OVERFLOW + +=item HAS_THREAD_SAFE_NL_LANGINFO_L + +=item HAS_LOCALECONV_L + +=item HAS_MBRLEN + +=item HAS_MBRTOWC + +=item HAS_MEMRCHR + +=item HAS_NANOSLEEP + +=item HAS_STRNLEN + +=item HAS_STRTOLD_L + +=item I_WCHAR + +=back + +=back + +=head1 Testing + +=over 4 + +=item * + +Testing of the XS-APItest directory is now done in parallel, where +applicable. + +=item * + +Perl now includes a default F<.travis.yml> file for Travis CI testing +on github mirrors. +L<[perl #123981]|https://rt.perl.org/Ticket/Display.html?id=123981> + +=item * + +The watchdog timer count in F<re/pat_psycho.t> can now be overridden. + +This test can take a long time to run, so there is a timer to keep +this in check (currently, 5 minutes). This commit adds checking +the environment variable C<< PERL_TEST_TIME_OUT_FACTOR >>; if set, +the time out setting is multiplied by its value. + +=item * + +F<harness> no longer waits for 30 seconds when running F<t/io/openpid.t>. +L<[perl #121028]|https://rt.perl.org/Ticket/Display.html?id=121028> +L<[perl #132867]|https://rt.perl.org/Ticket/Display.html?id=132867> + +=back + +=head1 Packaging + +For the past few years we have released perl using three different archive +formats: bzip (C<.bz2>), LZMA2 (C<.xz>) and gzip (C<.gz>). Since xz compresses +better and decompresses faster, and gzip is more compatible and uses less +memory, we have dropped the C<.bz2> archive format with this release. +(If this poses a problem, do let us know; see L</Reporting Bugs>, below.) + +=head1 Platform Support + +=head2 Discontinued Platforms + +=over 4 + +=item PowerUX / Power MAX OS + +Compiler hints and other support for these apparently long-defunct +platforms has been removed. + +=back + +=head2 Platform-Specific Notes + +=over 4 + +=item CentOS + +Compilation on CentOS 5 is now fixed. + +=item Cygwin + +A build with the quadmath library can now be done on Cygwin. + +=item Darwin + +Perl now correctly uses reentrant functions, like C<asctime_r>, on +versions of Darwin that have support for them. + +=item FreeBSD + +FreeBSD's F<< /usr/share/mk/sys.mk >> specifies C<< -O2 >> for +architectures other than ARM and MIPS. By default, perl is now compiled +with the same optimization levels. + +=item VMS + +Several fix-ups for F<configure.com>, marking function VMS has +(or doesn't have). + +CRTL features can now be set by embedders before invoking Perl by using +the C<decc$feature_set> and C<decc$feature_set_value> functions. +Previously any attempt to set features after image initialization were +ignored. + +=item Windows + +=over 4 + +=item * + +Support for compiling perl on Windows using Microsoft Visual Studio 2017 +(containing Visual C++ 14.1) has been added. + +=item * + +Visual C++ compiler version detection has been improved to work on non-English +language systems. + +=item * + +We now set C<$Config{libpth}> correctly for 64-bit builds using Visual C++ +versions earlier than 14.1. + +=back + +=back + +=head1 Internal Changes + +=over 4 + +=item * + +A new optimisation phase has been added to the compiler, +C<optimize_optree()>, which does a top-down scan of a complete optree +just before the peephole optimiser is run. This phase is not currently +hookable. + +=item * + +An C<OP_MULTICONCAT> op has been added. At C<optimize_optree()> time, a +chain of C<OP_CONCAT> and C<OP_CONST> ops, together optionally with an +C<OP_STRINGIFY> and/or C<OP_SASSIGN>, are combined into a single +C<OP_MULTICONCAT> op. The op is of type C<UNOP_AUX>, and the aux array +contains the argument count, plus a pointer to a constant string and a set +of segment lengths. For example with + + my $x = "foo=$foo, bar=$bar\n"; + +the constant string would be C<"foo=, bar=\n"> and the segment lengths +would be (4,6,1). If the string contains characters such as C<\x80>, whose +representation changes under utf8, two sets of strings plus lengths are +precomputed and stored. + +=item * + +Direct access to L<C<PL_keyword_plugin>|perlapi/PL_keyword_plugin> is not +safe in the presence of multithreading. A new +L<C<wrap_keyword_plugin>|perlapi/wrap_keyword_plugin> function has been +added to allow XS modules to safely define custom keywords even when +loaded from a thread, analogous to L<C<PL_check>|perlapi/PL_check> / +L<C<wrap_op_checker>|perlapi/wrap_op_checker>. + +=item * + +The C<PL_statbuf> interpreter variable has been removed. + +=item * + +The deprecated function C<to_utf8_case()>, accessible from XS code, has +been removed. + +=item * + +A new function +L<C<is_utf8_invariant_string_loc()>|perlapi/is_utf8_invariant_string_loc> +has been added that is like +L<C<is_utf8_invariant_string()>|perlapi/is_utf8_invariant_string> +but takes an extra pointer parameter into which is stored the location +of the first variant character, if any are found. + +=item * + +A new function, L<C<Perl_langinfo()>|perlapi/Perl_langinfo> has been +added. It is an (almost) drop-in replacement for the system +C<nl_langinfo(3)>, but works on platforms that lack that; as well as +being more thread-safe, and hiding some gotchas with locale handling +from the caller. Code that uses this, needn't use L<C<localeconv(3)>> +(and be affected by the gotchas) to find the decimal point, thousands +separator, or currency symbol. See L<perlapi/Perl_langinfo>. + +=item * + +A new API function L<C<sv_rvunweaken()>|perlapi/sv_rvunweaken> has +been added to complement L<C<sv_rvweaken()>|perlapi/sv_rvweaken>. +The implementation was taken from L<Scalar::Util/unweaken>. + +=item * + +A new flag, C<SORTf_UNSTABLE>, has been added. This will allow a +future commit to make mergesort unstable when the user specifies ‘no +sort stable’, since it has been decided that mergesort should remain +stable by default. + +=item * + +XS modules can now automatically get reentrant versions of system +functions on threaded perls. + +By adding + + #define PERL_REENTRANT + +near the beginning of an C<XS> file, it will be compiled so that +whatever reentrant functions perl knows about on that system will +automatically and invisibly be used instead of the plain, non-reentrant +versions. For example, if you write C<getpwnam()> in your code, on a +system that has C<getpwnam_r()> all calls to the former will be translated +invisibly into the latter. This does not happen except on threaded +perls, as they aren't needed otherwise. Be aware that which functions +have reentrant versions varies from system to system. + +=item * + +The C<PERL_NO_OP_PARENT> build define is no longer supported, which means +that perl is now always built with C<PERL_OP_PARENT> enabled. + +=item * + +The format and content of the non-utf8 transliteration table attached to +the C<op_pv> field of C<OP_TRANS>/C<OP_TRANSR> ops has changed. It's now a +C<struct OPtrans_map>. + +=item * + +A new compiler C<#define>, C<dTHX_DEBUGGING>. has been added. This is +useful for XS or C code that only need the thread context because their +debugging statements that get compiled only under C<-DDEBUGGING> need +one. + +=item * + +A new API function L<perlapi/Perl_setlocale> has been added. + +=item * + +L<perlapi/sync_locale> has been revised to return a boolean as to +whether the system was using the global locale or not. + +=item * + +A new kind of magic scalar, called a "nonelem" scalar, has been introduced. +It is stored in an array to denote a non-existent element, whenever such an +element is accessed in a potential lvalue context. It replaces the +existing "defelem" (deferred element) magic wherever this is possible, +being significantly more efficient. This means that +C<some_sub($sparse_array[$nonelem])> no longer has to create a new magic +defelem scalar each time, as long as the element is within the array. + +It partially fixes the rare bug of deferred elements getting out of synch +with their arrays when the array is shifted or unshifted. +L<[perl #132729]|https://rt.perl.org/Ticket/Display.html?id=132729> + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +List assignment (C<aassign>) could in some rare cases allocate an +entry on the mortals stack and leave the entry uninitialized, leading to +possible crashes. +L<[perl #131570]|https://rt.perl.org/Ticket/Display.html?id=131570> + +=item * + +Attempting to apply an attribute to an C<our> variable where a +function of that name already exists could result in a NULL pointer +being supplied where an SV was expected, crashing perl. +L<[perl #131597]|https://rt.perl.org/Ticket/Display.html?id=131597> + +=item * + +C<split ' '> now correctly handles the argument being split when in the +scope of the L<< C<unicode_strings>|feature/"The 'unicode_strings' feature" +>> feature. Previously, when a string using the single-byte internal +representation contained characters that are whitespace by Unicode rules but +not by ASCII rules, it treated those characters as part of fields rather +than as field separators. +L<[perl #130907]|https://rt.perl.org/Ticket/Display.html?id=130907> + +=item * + +Several built-in functions previously had bugs that could cause them to +write to the internal stack without allocating room for the item being +written. In rare situations, this could have led to a crash. These bugs have +now been fixed, and if any similar bugs are introduced in future, they will +be detected automatically in debugging builds. + +These internal stack usage checks introduced are also done +by the C<entersub> operator when calling XSUBs. This means we can +report which XSUB failed to allocate enough stack space. +L<[perl #131975]|https://rt.perl.org/Public/Bug/Display.html?id=131975> + +=item * + +Using a symbolic ref with postderef syntax as the key in a hash lookup was +yielding an assertion failure on debugging builds. +L<[perl #131627]|https://rt.perl.org/Ticket/Display.html?id=131627> + +=item * + +Array and hash variables whose names begin with a caret now admit indexing +inside their curlies when interpolated into strings, as in C<< +"${^CAPTURE[0]}" >> to index C<@{^CAPTURE}>. +L<[perl #131664]|https://rt.perl.org/Ticket/Display.html?id=131664> + +=item * + +Fetching the name of a glob that was previously UTF-8 but wasn't any +longer would return that name flagged as UTF-8. +L<[perl #131263]|https://rt.perl.org/Ticket/Display.html?id=131263> + +=item * + +The perl C<sprintf()> function (via the underlying C function +C<Perl_sv_vcatpvfn_flags()>) has been heavily reworked to fix many minor +bugs, including the integer wrapping of large width and precision +specifiers and potential buffer overruns. It has also been made faster in +many cases. + +=item * + +Exiting from an C<eval>, whether normally or via an exception, now always +frees temporary values (possibly calling destructors) I<before> setting +C<$@>. For example: + + sub DESTROY { eval { die "died in DESTROY"; } } + eval { bless []; }; + # $@ used to be equal to "died in DESTROY" here; it's now "". + +=item * + +Fixed a duplicate symbol failure with C<-flto -mieee-fp> builds. +F<pp.c> defined C<_LIB_VERSION> which C<-lieee> already defines. +L<[perl #131786]|https://rt.perl.org/Ticket/Display.html?id=131786> + +=item * + +The tokenizer no longer consumes the exponent part of a floating +point number if it's incomplete. +L<[perl #131725]|https://rt.perl.org/Ticket/Display.html?id=131725> + +=item * + +On non-threaded builds, for C<m/$null/> where C<$null> is an empty +string is no longer treated as if the C</o> flag was present when the +previous matching match operator included the C</o> flag. The +rewriting used to implement this behavior could confuse the +interpreter. This matches the behaviour of threaded builds. +L<[perl #124368]|https://rt.perl.org/Ticket/Display.html?id=124368> + +=item * + +Parsing a C<sub> definition could cause a use after free if the C<sub> +keyword was followed by whitespace including newlines (and comments.) +L<[perl #131836]|https://rt.perl.org/Public/Bug/Display.html?id=131836> + +=item * + +The tokenizer now correctly adjusts a parse pointer when skipping +whitespace in a C<< ${identifier} >> construct. +L<[perl #131949]|https://rt.perl.org/Public/Bug/Display.html?id=131949> + +=item * + +Accesses to C<${^LAST_FH}> no longer assert after using any of a +variety of I/O operations on a non-glob. +L<[perl #128263]|https://rt.perl.org/Public/Bug/Display.html?id=128263> + +=item * + +The XS-level C<Copy()>, C<Move()>, C<Zero()> macros and their variants now +assert if the pointers supplied are C<NULL>. ISO C considers +supplying NULL pointers to the functions these macros are built upon +as undefined behaviour even when their count parameters are zero. +Based on these assertions and the original bug report three macro +calls were made conditional. +L<[perl #131746]|https://rt.perl.org/Public/Bug/Display.html?id=131746> +L<[perl #131892]|https://rt.perl.org/Public/Bug/Display.html?id=131892> + +=item * + +Only the C<=> operator is permitted for defining defaults for +parameters in subroutine signatures. Previously other assignment +operators, e.g. C<+=>, were also accidentally permitted. +L<[perl #131777]|https://rt.perl.org/Public/Bug/Display.html?id=131777> + +=item * + +Package names are now always included in C<:prototype> warnings +L<[perl #131833]|https://rt.perl.org/Public/Bug/Display.html?id=131833> + +=item * + +The C<je_old_stack_hwm> field, previously only found in the C<jmpenv> +structure on debugging builds, has been added to non-debug builds as +well. This fixes an issue with some CPAN modules caused by the size of +this structure varying between debugging and non-debugging builds. +L<[perl #131942]|https://rt.perl.org/Public/Bug/Display.html?id=131942> + +=item * + +The arguments to the C<ninstr()> macro are now correctly parenthesized. + +=item * + +A NULL pointer dereference in the C<S_regmatch()> function has been +fixed. +L<[perl #132017]|https://rt.perl.org/Public/Bug/Display.html?id=132017> + +=item * + +Calling L<exec PROGRAM LIST|perlfunc/exec PROGRAM LIST> with an empty C<LIST> +has been fixed. This should call C<execvp()> with an empty C<argv> array +(containing only the terminating C<NULL> pointer), but was instead just +returning false (and not setting L<C<$!>|perlvar/$!>). +L<[perl #131730]|https://rt.perl.org/Public/Bug/Display.html?id=131730> + +=item * + +The C<gv_fetchmeth_sv> C function stopped working properly in Perl 5.22 when +fetching a constant with a UTF-8 name if that constant subroutine was stored in +the stash as a simple scalar reference, rather than a full typeglob. This has +been corrected. + +=item * + +Single-letter debugger commands followed by an argument which starts with +punctuation (e.g. C<p$^V> and C<x@ARGV>) now work again. They had been +wrongly requiring a space between the command and the argument. +L<[perl #120174]|https://rt.perl.org/Public/Bug/Display.html?id=120174> + +=item * + +L<splice|perlfunc/splice ARRAY,OFFSET,LENGTH,LIST> now throws an exception +("Modification of a read-only value attempted") when modifying a read-only +array. Until now it had been silently modifying the array. The new behaviour +is consistent with the behaviour of L<push|perlfunc/push ARRAY,LIST> and +L<unshift|perlfunc/unshift ARRAY,LIST>. +L<[perl #131000]|https://rt.perl.org/Public/Bug/Display.html?id=131000> + +=item * + +C<stat()>, C<lstat()>, and file test operators now fail if given a +filename containing a nul character, in the same way that C<open()> +already fails. + +=item * + +C<stat()>, C<lstat()>, and file test operators now reliably set C<$!> when +failing due to being applied to a closed or otherwise invalid file handle. + +=item * + +File test operators for Unix permission bits that don't exist on a +particular platform, such as C<-k> (sticky bit) on Windows, now check that +the file being tested exists before returning the blanket false result, +and yield the appropriate errors if the argument doesn't refer to a file. + +=item * + +Fixed a 'read before buffer' overrun when parsing a range starting with +C<\N{}> at the beginning of the character set for the transliteration +operator. +L<[perl #132245]|https://rt.perl.org/Ticket/Display.html?id=132245> + +=item * + +Fixed a leaked scalar when parsing an empty C<\N{}> at compile-time. +L<[perl #132245]|https://rt.perl.org/Ticket/Display.html?id=132245> + +=item * + +Calling C<do $path> on a directory or block device now yields a meaningful +error code in C<$!>. +L<[perl #125774]|https://rt.perl.org/Ticket/Display.html?id=125774> + +=item * + +Regexp substitution using an overloaded replacement value that provides +a tainted stringification now correctly taints the resulting string. +L<[perl #115266]|https://rt.perl.org/Ticket/Display.html?id=115266> + +=item * + +Lexical sub declarations in C<do> blocks such as C<do { my sub lex; 123 }> +could corrupt the stack, erasing items already on the stack in the +enclosing statement. This has been fixed. +L<[perl #132442]|https://rt.perl.org/Ticket/Display.html?id=132442> + +=item * + +C<pack> and C<unpack> can now handle repeat counts and lengths that +exceed two billion. +L<[perl #119367]|https://rt.perl.org/Ticket/Display.html?id=119367> + +=item * + +Digits past the radix point in octal and binary floating point literals +now have the correct weight on platforms where a floating point +significand doesn't fit into an integer type. + +=item * + +The canonical truth value no longer has a spurious special meaning as a +callable subroutine. It used to be a magic placeholder for a missing +C<import> or C<unimport> method, but is now treated like any other string +C<1>. +L<[perl #126042]|https://rt.perl.org/Ticket/Display.html?id=126042> + +=item * + +C<system> now reduces its arguments to strings in the parent process, so +any effects of stringifying them (such as overload methods being called +or warnings being emitted) are visible in the way the program expects. +L<[perl #121105]|https://rt.perl.org/Ticket/Display.html?id=121105> + +=item * + +The C<readpipe()> built-in function now checks at compile time that +it has only one parameter expression, and puts it in scalar context, +thus ensuring that it doesn't corrupt the stack at runtime. +L<[perl #4574]|https://rt.perl.org/Ticket/Display.html?id=4574> + +=item * + +C<sort> now performs correct reference counting when aliasing C<$a> and +C<$b>, thus avoiding premature destruction and leakage of scalars if they +are re-aliased during execution of the sort comparator. +L<[perl #92264]|https://rt.perl.org/Ticket/Display.html?id=92264> + +=item * + +C<reverse> with no operand, reversing C<$_> by default, is no longer in +danger of corrupting the stack. +L<[perl #132544]|https://rt.perl.org/Ticket/Display.html?id=132544> + +=item * + +C<exec>, C<system>, et al are no longer liable to have their argument +lists corrupted by reentrant calls and by magic such as tied scalars. +L<[perl #129888]|https://rt.perl.org/Ticket/Display.html?id=129888> + +=item * + +Perl's own C<malloc> no longer gets confused by attempts to allocate +more than a gigabyte on a 64-bit platform. +L<[perl #119829]|https://rt.perl.org/Ticket/Display.html?id=119829> + +=item * + +Stacked file test operators in a sort comparator expression no longer +cause a crash. +L<[perl #129347]|https://rt.perl.org/Ticket/Display.html?id=129347> + +=item * + +An identity C<tr///> transformation on a reference is no longer mistaken +for that reference for the purposes of deciding whether it can be +assigned to. +L<[perl #130578]|https://rt.perl.org/Ticket/Display.html?id=130578> + +=item * + +Lengthy hexadecimal, octal, or binary floating point literals no +longer cause undefined behaviour when parsing digits that are of such +low significance that they can't affect the floating point value. +L<[perl #131894]|https://rt.perl.org/Ticket/Display.html?id=131894> + +=item * + +C<open $$scalarref...> and similar invocations no longer leak the file +handle. +L<[perl #115814]|https://rt.perl.org/Ticket/Display.html?id=115814> + +=item * + +Some convoluted kinds of regexp no longer cause an arithmetic overflow +when compiled. +L<[perl #131893]|https://rt.perl.org/Ticket/Display.html?id=131893> + +=item * + +The default typemap, by avoiding C<newGVgen>, now no longer leaks when +XSUBs return file handles (C<PerlIO *> or C<FILE *>). +L<[perl #115814]|https://rt.perl.org/Ticket/Display.html?id=115814> + +=item * + +Creating a C<BEGIN> block as an XS subroutine with a prototype no longer +crashes because of the early freeing of the subroutine. + +=item * + +The C<printf> format specifier C<%.0f> no longer rounds incorrectly +L<[perl #47602]|https://rt.perl.org/Ticket/Display.html?id=47602>, +and now shows the correct sign for a negative zero. + +=item * + +Fixed an issue where the error C<< Scalar value @arrayname[0] better +written as $arrayname >> would give an error C<< Cannot printf Inf with 'c' >> +when arrayname starts with C<< Inf >>. +L<[perl #132645]|https://rt.perl.org/Ticket/Display.html?id=132645> + +=item * + +The Perl implementation of C<< getcwd() >> in C<< Cwd >> in the PathTools +distribution now behaves the same as XS implementation on errors: it +returns an error, and sets C<< $! >>. +L<[perl #132648]|https://rt.perl.org/Ticket/Display.html?id=132648> + +=item * + +Vivify array elements when putting them on the stack. +Fixes L<[perl #8910]|https://rt.perl.org/Ticket/Display.html?id=8910> +(reported in April 2002). + +=item * + +Fixed parsing of braced subscript after parens. Fixes +L<[perl #8045]|https://rt.perl.org/Ticket/Display.html?id=8045> +(reported in December 2001). + +=item * + +C<tr/non_utf8/long_non_utf8/c> could give the wrong results when the +length of the replacement character list was greater than 0x7fff. + +=item * + +C<tr/non_utf8/non_utf8/cd> failed to add the implied +C<\x{100}-\x{7fffffff}> to the search character list. + +=item * + +Compilation failures within "perl-within-perl" constructs, such as with +string interpolation and the right part of C<s///e>, now cause +compilation to abort earlier. + +Previously compilation could continue in order to report other errors, +but the failed sub-parse could leave partly parsed constructs on the +parser shift-reduce stack, confusing the parser, leading to perl +crashes. +L<[perl #125351]|https://rt.perl.org/Ticket/Display.html?id=125351> + +=item * + +On threaded perls where the decimal point (radix) character is not a +dot, it has been possible for a race to occur between threads when one +needs to use the real radix character (such as with C<sprintf>). This has +now been fixed by use of a mutex on systems without thread-safe locales, +and the problem just doesn't come up on those with thread-safe locales. + +=item * + +Errors while compiling a regex character class could sometime trigger an +assertion failure. +L<[perl #132163]|https://rt.perl.org/Ticket/Display.html?id=132163> + +=back + +=head1 Acknowledgements + +Perl 5.28.0 represents approximately 13 months of development since Perl +5.26.0 and contains approximately 730,000 lines of changes across 2,200 +files from 77 authors. + +Excluding auto-generated files, documentation and release tools, there were +approximately 580,000 lines of changes to 1,300 .pm, .t, .c and .h files. + +Perl continues to flourish into its fourth decade thanks to a vibrant +community of users and developers. The following people are known to have +contributed the improvements that became Perl 5.28.0: + +Aaron Crane, Abigail, Ævar Arnfjörð Bjarmason, Alberto Simões, Alexandr +Savca, Andrew Fresh, Andy Dougherty, Andy Lester, Aristotle Pagaltzis, Ask +Bjørn Hansen, Chris 'BinGOs' Williams, Craig A. Berry, Dagfinn Ilmari +Mannsåker, Dan Collins, Daniel Dragan, David Cantrell, David Mitchell, +Dmitry Ulanov, Dominic Hargreaves, E. Choroba, Eric Herman, Eugen Konkov, +Father Chrysostomos, Gene Sullivan, George Hartzell, Graham Knop, Harald +Jörg, H.Merijn Brand, Hugo van der Sanden, Jacques Germishuys, James E +Keenan, Jarkko Hietaniemi, Jerry D. Hedden, J. Nick Koston, John Lightsey, +John Peacock, John P. Linderman, John SJ Anderson, Karen Etheridge, Karl +Williamson, Ken Brown, Ken Cotterill, Leon Timmermans, Lukas Mai, Marco +Fontani, Marc-Philip Werner, Matthew Horsfall, Neil Bowers, Nicholas Clark, +Nicolas R., Niko Tyni, Pali, Paul Marquess, Peter John Acklam, Reini Urban, +Renee Baecker, Ricardo Signes, Robin Barker, Sawyer X, Scott Lanning, Sergey +Aleynikov, Shirakata Kentaro, Shoichi Kaji, Slaven Rezic, Smylers, Steffen +Müller, Steve Hay, Sullivan Beck, Thomas Sibley, Todd Rinaldo, Tomasz +Konojacki, Tom Hukins, Tom Wyant, Tony Cook, Vitali Peil, Yves Orton, +Zefram. + +The list above is almost certainly incomplete as it is automatically +generated from version control history. In particular, it does not include +the names of the (very much appreciated) contributors who reported issues to +the Perl bug tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please +see the F<AUTHORS> file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the perl bug database +at L<https://rt.perl.org/> . There may also be information at +L<http://www.perl.org/> , the Perl Home Page. + +If you believe you have an unreported bug, please run the L<perlbug> program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C<perl -V>, +will be sent off to perlbug@perl.org to be analysed by the Perl porting team. + +If the bug you are reporting has security implications which make it +inappropriate to send to a publicly archived mailing list, then see +L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION> +for details of how to report the issue. + +=head1 Give Thanks + +If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, +you can do so by running the C<perlthanks> program: + + perlthanks + +This will send an email to the Perl 5 Porters list with your show of thanks. + +=head1 SEE ALSO + +The F<Changes> file for an explanation of how to view exhaustive details on +what changed. + +The F<INSTALL> file for how to build Perl. + +The F<README> file for general stuff. + +The F<Artistic> and F<Copying> files for copyright information. + +=cut diff --git a/gnu/usr.bin/perl/pod/perl561delta.pod b/gnu/usr.bin/perl/pod/perl561delta.pod index 49ff54f8983..1ccc85a2653 100644 --- a/gnu/usr.bin/perl/pod/perl561delta.pod +++ b/gnu/usr.bin/perl/pod/perl561delta.pod @@ -744,7 +744,7 @@ than C<$]> (a numeric value). (This is a potential incompatibility. Send us a report via perlbug if you are affected by this.) The v1.2.3 syntax is also now legal in Perl. -See L<Support for strings represented as a vector of ordinals> for more on that. +See L</Support for strings represented as a vector of ordinals> for more on that. To cope with the new versioning system's use of at least three significant digits for each version component, the method used for incrementing the @@ -2092,7 +2092,7 @@ capabilities. In other words: if your operating system has the necessary APIs and datatypes, you should be able just to go ahead and use them, for threads by Configure -Dusethreads, and for 64 bits either explicitly by Configure -Duse64bitint or implicitly if your -system has 64-bit wide datatypes. See also L<"64-bit support">. +system has 64-bit wide datatypes. See also L</"64-bit support">. =head2 Long Doubles @@ -2103,7 +2103,7 @@ Perl's scalars, use -Duselongdouble. =head2 -Dusemorebits You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits. -See also L<"64-bit support">. +See also L</"64-bit support">. =head2 -Duselargefiles @@ -2111,7 +2111,7 @@ Some platforms support system APIs that are capable of handling large files (typically, files larger than two gigabytes). Perl will try to use these APIs if you ask for -Duselargefiles. -See L<"Large file support"> for more information. +See L</"Large file support"> for more information. =head2 installusrbinperl diff --git a/gnu/usr.bin/perl/pod/perl56delta.pod b/gnu/usr.bin/perl/pod/perl56delta.pod index 24c2072c253..8b6272b2427 100644 --- a/gnu/usr.bin/perl/pod/perl56delta.pod +++ b/gnu/usr.bin/perl/pod/perl56delta.pod @@ -146,7 +146,7 @@ than C<$]> (a numeric value). (This is a potential incompatibility. Send us a report via perlbug if you are affected by this.) The v1.2.3 syntax is also now legal in Perl. -See L<Support for strings represented as a vector of ordinals> for more on that. +See L</Support for strings represented as a vector of ordinals> for more on that. To cope with the new versioning system's use of at least three significant digits for each version component, the method used for incrementing the @@ -1494,7 +1494,7 @@ capabilities. In other words: if your operating system has the necessary APIs and datatypes, you should be able just to go ahead and use them, for threads by Configure -Dusethreads, and for 64 bits either explicitly by Configure -Duse64bitint or implicitly if your -system has 64-bit wide datatypes. See also L<"64-bit support">. +system has 64-bit wide datatypes. See also L</"64-bit support">. =head2 Long Doubles @@ -1505,7 +1505,7 @@ Perl's scalars, use -Duselongdouble. =head2 -Dusemorebits You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits. -See also L<"64-bit support">. +See also L</"64-bit support">. =head2 -Duselargefiles @@ -1513,7 +1513,7 @@ Some platforms support system APIs that are capable of handling large files (typically, files larger than two gigabytes). Perl will try to use these APIs if you ask for -Duselargefiles. -See L<"Large file support"> for more information. +See L</"Large file support"> for more information. =head2 installusrbinperl diff --git a/gnu/usr.bin/perl/pod/perl581delta.pod b/gnu/usr.bin/perl/pod/perl581delta.pod index cd88c73ba62..f870172ae86 100644 --- a/gnu/usr.bin/perl/pod/perl581delta.pod +++ b/gnu/usr.bin/perl/pod/perl581delta.pod @@ -120,7 +120,7 @@ by anyone, it has been repurposed. The behavior that this switch enabled in 5.6.x releases may be supported in a transparent, data-dependent fashion in a future release. -For the new life of this switch, see L<"UTF-8 no longer default under +For the new life of this switch, see L</"UTF-8 no longer default under UTF-8 locales">, and L<perlrun/-C>. =head2 (Win32) The /d Switch Of cmd.exe @@ -559,7 +559,7 @@ to build a Perl for PASE is to use an AIX host as a cross-compilation environment. See README.os400. Yet another cross-compilation option has been added: now Perl builds -on OpenZaurus, an Linux distribution based on Mandrake + Embedix for +on OpenZaurus, a Linux distribution based on Mandrake + Embedix for the Sharp Zaurus PDA. See the Cross/README file. Tru64 when using gcc 3 drops the optimisation for F<toke.c> to C<-O2> diff --git a/gnu/usr.bin/perl/pod/perl588delta.pod b/gnu/usr.bin/perl/pod/perl588delta.pod index b2203bcf71d..52992729345 100644 --- a/gnu/usr.bin/perl/pod/perl588delta.pod +++ b/gnu/usr.bin/perl/pod/perl588delta.pod @@ -530,7 +530,7 @@ C<File::Spec> upgraded to version 3.12 =item * -C<File::Spec->rootdir()> now returns C<\> on Win32, instead of C</> +C<< File::Spec->rootdir() >> now returns C<\> on Win32, instead of C</> =item * @@ -1243,7 +1243,7 @@ Now implements UCA Revision 14 (based on Unicode 4.1.0). =item * -C<Unicode::Collate->new> method no longer overwrites user's C<$_> +C<< Unicode::Collate->new >> method no longer overwrites user's C<$_> =item * @@ -1535,7 +1535,7 @@ This is a new warning, produced in situations such as this: =head2 Non-string passed as bitmask -This is a new warning, produced when number has been passed as a argument to +This is a new warning, produced when number has been passed as an argument to select(), instead of a bitmask. # Wrong, will now warn diff --git a/gnu/usr.bin/perl/pod/perl589delta.pod b/gnu/usr.bin/perl/pod/perl589delta.pod index f10099ccfa4..4eeaf302f5c 100644 --- a/gnu/usr.bin/perl/pod/perl589delta.pod +++ b/gnu/usr.bin/perl/pod/perl589delta.pod @@ -314,7 +314,7 @@ properly deparse C<print readpipe $x, $y>. =item * -now handles C<''->()>, C<::()>, C<sub :: {}>, I<etc.> correctly [RT #43010]. +now handles C<< ''->() >>, C<::()>, C<sub :: {}>, I<etc.> correctly [RT #43010]. All bugs in parsing these kinds of syntax are now fixed: perl -MO=Deparse -e '"my %h = "->()' diff --git a/gnu/usr.bin/perl/pod/perlartistic.pod b/gnu/usr.bin/perl/pod/perlartistic.pod index 63813ff4fb9..65565018ad9 100644 --- a/gnu/usr.bin/perl/pod/perlartistic.pod +++ b/gnu/usr.bin/perl/pod/perlartistic.pod @@ -213,7 +213,7 @@ products derived from this software without specific prior written permission. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED -WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. =back diff --git a/gnu/usr.bin/perl/pod/perldeprecation.pod b/gnu/usr.bin/perl/pod/perldeprecation.pod new file mode 100644 index 00000000000..40ad2ecbe96 --- /dev/null +++ b/gnu/usr.bin/perl/pod/perldeprecation.pod @@ -0,0 +1,540 @@ +=head1 NAME + +perldeprecation - list Perl deprecations + +=head1 DESCRIPTION + +The purpose of this document is to document what has been deprecated +in Perl, and by which version the deprecated feature will disappear, +or, for already removed features, when it was removed. + +This document will try to discuss what alternatives for the deprecated +features are available. + +The deprecated features will be grouped by the version of Perl in +which they will be removed. + +=head2 Perl 5.32 + +=head3 Constants from lexical variables potentially modified elsewhere + +You wrote something like + + my $var; + $sub = sub () { $var }; + +but $var is referenced elsewhere and could be modified after the C<sub> +expression is evaluated. Either it is explicitly modified elsewhere +(C<$var = 3>) or it is passed to a subroutine or to an operator like +C<printf> or C<map>, which may or may not modify the variable. + +Traditionally, Perl has captured the value of the variable at that +point and turned the subroutine into a constant eligible for inlining. +In those cases where the variable can be modified elsewhere, this +breaks the behavior of closures, in which the subroutine captures +the variable itself, rather than its value, so future changes to the +variable are reflected in the subroutine's return value. + +If you intended for the subroutine to be eligible for inlining, then +make sure the variable is not referenced elsewhere, possibly by +copying it: + + my $var2 = $var; + $sub = sub () { $var2 }; + +If you do want this subroutine to be a closure that reflects future +changes to the variable that it closes over, add an explicit C<return>: + + my $var; + $sub = sub () { return $var }; + +This usage has been deprecated, and will no longer be allowed in Perl 5.32. + +=head3 Use of strings with code points over 0xFF as arguments to C<vec> + +C<vec> views its string argument as a sequence of bits. A string +containing a code point over 0xFF is nonsensical. This usage is +deprecated in Perl 5.28, and will be removed in Perl 5.32. + +=head3 Use of code points over 0xFF in string bitwise operators + +The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat their +operands as strings of bytes. As such, values above 0xFF are +nonsensical. Some instances of these have been deprecated since Perl +5.24, and were made fatal in 5.28, but it turns out that in cases where +the wide characters did not affect the end result, no deprecation +notice was raised, and so remain legal. Now, all occurrences either are +fatal or raise a deprecation warning, so that the remaining legal +occurrences will be fatal in 5.32. + +An example of this is + + "" & "\x{100}" + +The wide character is not used in the C<&> operation because the left +operand is shorter. This now warns anyway. + +=head3 hostname() doesn't accept any arguments + +The function C<hostname()> in the L<Sys::Hostname> module has always +been documented to be called with no arguments. Historically it has not +enforced this, and has actually accepted and ignored any arguments. As a +result, some users have got the mistaken impression that an argument does +something useful. To avoid these bugs, the function is being made strict. +Passing arguments was deprecated in Perl 5.28, and will become fatal in +Perl 5.32. + +=head3 Unescaped left braces in regular expressions + +The simple rule to remember, if you want to match a literal C<{> +character (U+007B C<LEFT CURLY BRACKET>) in a regular expression +pattern, is to escape each literal instance of it in some way. +Generally easiest is to precede it with a backslash, like C<\{> +or enclose it in square brackets (C<[{]>). If the pattern +delimiters are also braces, any matching right brace (C<}>) should +also be escaped to avoid confusing the parser, for example, + + qr{abc\{def\}ghi} + +Forcing literal C<{> characters to be escaped will enable the Perl +language to be extended in various ways in future releases. To avoid +needlessly breaking existing code, the restriction is is not enforced in +contexts where there are unlikely to ever be extensions that could +conflict with the use there of C<{> as a literal. + +Literal uses of C<{> were deprecated in Perl 5.20, and some uses of it +started to give deprecation warnings since. These cases were made fatal +in Perl 5.26. Due to an oversight, not all cases of a use of a literal +C<{> got a deprecation warning. Some cases started warning in Perl 5.26, +and they will be fatal by Perl 5.30. Other case started in Perl 5.28, +and will be made fatal in 5.32. + +=head2 Perl 5.30 + +=head3 C<< $* >> is no longer supported + +Before Perl 5.10, setting C<< $* >> to a true value globally enabled +multi-line matching within a string. This relique from the past lost +its special meaning in 5.10. Use of this variable will be a fatal error +in Perl 5.30, freeing the variable up for a future special meaning. + +To enable multiline matching one should use the C<< /m >> regexp +modifier (possibly in combination with C<< /s >>). This can be set +on a per match bases, or can be enabled per lexical scope (including +a whole file) with C<< use re '/m' >>. + +=head3 C<< $# >> is no longer supported + +This variable used to have a special meaning -- it could be used +to control how numbers were formatted when printed. This seldom +used functionality was removed in Perl 5.10. In order to free up +the variable for a future special meaning, its use will be a fatal +error in Perl 5.30. + +To specify how numbers are formatted when printed, one is advised +to use C<< printf >> or C<< sprintf >> instead. + +=head3 Assigning non-zero to C<< $[ >> will be fatal + +This variable (and the corresponding C<array_base> feature and +L<arybase> module) allows changing the base for array and string +indexing operations. + +Setting this to a non-zero value has been deprecated since Perl 5.12 and +will become fatal in Perl 5.30. + +=head3 C<< File::Glob::glob() >> will disappear + +C<< File::Glob >> has a function called C<< glob >>, which just calls +C<< bsd_glob >>. However, its prototype is different from the prototype +of C<< CORE::glob >>, and hence, C<< File::Glob::glob >> should not +be used. + +C<< File::Glob::glob() >> was deprecated in Perl 5.8. A deprecation +message was issued from Perl 5.26 onwards, and the function will +disappear in Perl 5.30. + +Code using C<< File::Glob::glob() >> should call +C<< File::Glob::bsd_glob() >> instead. + +=head3 Unescaped left braces in regular expressions (for 5.30) + +See L</Unescaped left braces in regular expressions> above. + +=head3 Unqualified C<dump()> + +Use of C<dump()> instead of C<CORE::dump()> was deprecated in Perl 5.8, +and an unqualified C<dump()> will no longer be available in Perl 5.30. + +See L<perlfunc/dump>. + + +=head3 Using my() in false conditional. + +There has been a long-standing bug in Perl that causes a lexical variable +not to be cleared at scope exit when its declaration includes a false +conditional. Some people have exploited this bug to achieve a kind of +static variable. Since we intend to fix this bug, we don't want people +relying on this behavior. + +Instead, it's recommended one uses C<state> variables to achieve the +same effect: + + use 5.10.0; + sub count {state $counter; return ++ $counter} + say count (); # Prints 1 + say count (); # Prints 2 + +C<state> variables were introduced in Perl 5.10. + +Alternatively, you can achieve a similar static effect by +declaring the variable in a separate block outside the function, eg + + sub f { my $x if 0; return $x++ } + +becomes + + { my $x; sub f { return $x++ } } + +The use of C<my()> in a false conditional has been deprecated in +Perl 5.10, and it will become a fatal error in Perl 5.30. + + +=head3 Reading/writing bytes from/to :utf8 handles. + +The sysread(), recv(), syswrite() and send() operators are +deprecated on handles that have the C<:utf8> layer, either explicitly, or +implicitly, eg., with the C<:encoding(UTF-16LE)> layer. + +Both sysread() and recv() currently use only the C<:utf8> flag for the stream, +ignoring the actual layers. Since sysread() and recv() do no UTF-8 +validation they can end up creating invalidly encoded scalars. + +Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise ignoring +any layers. If the flag is set, both write the value UTF-8 encoded, even if +the layer is some different encoding, such as the example above. + +Ideally, all of these operators would completely ignore the C<:utf8> state, +working only with bytes, but this would result in silently breaking existing +code. To avoid this a future version of perl will throw an exception when +any of sysread(), recv(), syswrite() or send() are called on handle with the +C<:utf8> layer. + +In Perl 5.30, it will no longer be possible to use sysread(), recv(), +syswrite() or send() to read or send bytes from/to :utf8 handles. + + +=head3 Use of unassigned code point or non-standalone grapheme for a delimiter. + +A grapheme is what appears to a native-speaker of a language to be a +character. In Unicode (and hence Perl) a grapheme may actually be +several adjacent characters that together form a complete grapheme. For +example, there can be a base character, like "R" and an accent, like a +circumflex "^", that appear when displayed to be a single character with +the circumflex hovering over the "R". Perl currently allows things like +that circumflex to be delimiters of strings, patterns, I<etc>. When +displayed, the circumflex would look like it belongs to the character +just to the left of it. In order to move the language to be able to +accept graphemes as delimiters, we have to deprecate the use of +delimiters which aren't graphemes by themselves. Also, a delimiter must +already be assigned (or known to be never going to be assigned) to try +to future-proof code, for otherwise code that works today would fail to +compile if the currently unassigned delimiter ends up being something +that isn't a stand-alone grapheme. Because Unicode is never going to +assign +L<non-character code points|perlunicode/Noncharacter code points>, nor +L<code points that are above the legal Unicode maximum| +perlunicode/Beyond Unicode code points>, those can be delimiters, and +their use won't raise this warning. + +In Perl 5.30, delimiters which are unassigned code points, or which +are non-standalone graphemes will be fatal. + +=head3 In XS code, use of various macros dealing with UTF-8. + +These macros will require an extra parameter in Perl 5.30: +C<isALPHANUMERIC_utf8>, +C<isASCII_utf8>, +C<isBLANK_utf8>, +C<isCNTRL_utf8>, +C<isDIGIT_utf8>, +C<isIDFIRST_utf8>, +C<isPSXSPC_utf8>, +C<isSPACE_utf8>, +C<isVERTWS_utf8>, +C<isWORDCHAR_utf8>, +C<isXDIGIT_utf8>, +C<isALPHANUMERIC_LC_utf8>, +C<isALPHA_LC_utf8>, +C<isASCII_LC_utf8>, +C<isBLANK_LC_utf8>, +C<isCNTRL_LC_utf8>, +C<isDIGIT_LC_utf8>, +C<isGRAPH_LC_utf8>, +C<isIDCONT_LC_utf8>, +C<isIDFIRST_LC_utf8>, +C<isLOWER_LC_utf8>, +C<isPRINT_LC_utf8>, +C<isPSXSPC_LC_utf8>, +C<isPUNCT_LC_utf8>, +C<isSPACE_LC_utf8>, +C<isUPPER_LC_utf8>, +C<isWORDCHAR_LC_utf8>, +C<isXDIGIT_LC_utf8>, +C<toFOLD_utf8>, +C<toLOWER_utf8>, +C<toTITLE_utf8>, +and +C<toUPPER_utf8>. + +There is now a macro that corresponds to each one of these, simply by +appending C<_safe> to the name. It takes the extra parameter. +For example, C<isDIGIT_utf8_safe> corresponds to C<isDIGIT_utf8>, but +takes the extra parameter, and its use doesn't generate a deprecation +warning. All are documented in L<perlapi/Character case changing> and +L<perlapi/Character classification>. + +You can change to use these versions at any time, or, if you can live +with the deprecation messages, wait until 5.30 and add the parameter to +the existing calls, without changing the names. + +=head2 Perl 5.28 + +=head3 Attributes C<< :locked >> and C<< :unique >> + +The attributes C<< :locked >> (on code references) and C<< :unique >> +(on array, hash and scalar references) have had no effect since +Perl 5.005 and Perl 5.8.8 respectively. Their use has been deprecated +since. + +As of Perl 5.28, these attributes are syntax errors. Since the +attributes do not do anything, removing them from your code fixes +the syntax error; and removing them will not influence the behaviour +of your code. + + +=head3 Bare here-document terminators + +Perl has allowed you to use a bare here-document terminator to have the +here-document end at the first empty line. This practise was deprecated +in Perl 5.000; as of Perl 5.28, using a bare here-document terminator +throws a fatal error. + +You are encouraged to use the explicitly quoted form if you wish to +use an empty line as the terminator of the here-document: + + print <<""; + Print this line. + + # Previous blank line ends the here-document. + + +=head3 Setting $/ to a reference to a non-positive integer + +You assigned a reference to a scalar to C<$/> where the +referenced item is not a positive integer. In older perls this B<appeared> +to work the same as setting it to C<undef> but was in fact internally +different, less efficient and with very bad luck could have resulted in +your file being split by a stringified form of the reference. + +In Perl 5.20.0 this was changed so that it would be B<exactly> the same as +setting C<$/> to undef, with the exception that this warning would be +thrown. + +As of Perl 5.28, setting C<$/> to a reference of a non-positive +integer throws a fatal error. + +You are recommended to change your code to set C<$/> to C<undef> explicitly +if you wish to slurp the file. + + +=head3 Limit on the value of Unicode code points. + +Unicode only allows code points up to 0x10FFFF, but Perl allows +much larger ones. Up till Perl 5.28, it was allowed to use code +points exceeding the maximum value of an integer (C<IV_MAX>). +However, that did break the perl interpreter in some constructs, +including causing it to hang in a few cases. The known problem +areas were in C<tr///>, regular expression pattern matching using +quantifiers, as quote delimiters in C<qI<X>...I<X>> (where I<X> is +the C<chr()> of a large code point), and as the upper limits in +loops. + +The use of out of range code points was deprecated in Perl 5.24; as of +Perl 5.28 using a code point exceeding C<IV_MAX> throws a fatal error. + +If your code is to run on various platforms, keep in mind that the upper +limit depends on the platform. It is much larger on 64-bit word sizes +than 32-bit ones. For 32-bit integers, C<IV_MAX> equals C<0x7FFFFFFF>, +for 64-bit integers, C<IV_MAX> equals C<0x7FFFFFFFFFFFFFFF>. + + +=head3 Use of comma-less variable list in formats. + +It was allowed to use a list of variables in a format, without +separating them with commas. This usage has been deprecated +for a long time, and as of Perl 5.28, this throws a fatal error. + +=head3 Use of C<\N{}> + +Use of C<\N{}> with nothing between the braces was deprecated in +Perl 5.24, and throws a fatal error as of Perl 5.28. + +Since such a construct is equivalent to using an empty string, +you are recommended to remove such C<\N{}> constructs. + +=head3 Using the same symbol to open a filehandle and a dirhandle + +It used to be legal to use C<open()> to associate both a +filehandle and a dirhandle to the same symbol (glob or scalar). +This idiom is likely to be confusing, and it was deprecated in +Perl 5.10. + +Using the same symbol to C<open()> a filehandle and a dirhandle +throws a fatal error as of Perl 5.28. + +You should be using two different symbols instead. + +=head3 ${^ENCODING} is no longer supported. + +The special variable C<${^ENCODING}> was used to implement +the C<encoding> pragma. Setting this variable to anything other +than C<undef> was deprecated in Perl 5.22. Full deprecation +of the variable happened in Perl 5.25.3. + +Setting this variable to anything other than an undefined value +throws a fatal error as of Perl 5.28. + + +=head3 C<< B::OP::terse >> + +This method, which just calls C<< B::Concise::b_terse >>, has been +deprecated, and disappeared in Perl 5.28. Please use +C<< B::Concise >> instead. + + + +=head3 Use of inherited AUTOLOAD for non-method %s::%s() is no longer allowed + +As an (ahem) accidental feature, C<AUTOLOAD> subroutines were looked +up as methods (using the C<@ISA> hierarchy) even when the subroutines +to be autoloaded were called as plain functions (e.g. C<Foo::bar()>), +not as methods (e.g. C<< Foo->bar() >> or C<< $obj->bar() >>). + +This bug was deprecated in Perl 5.004, has been rectified in Perl 5.28 +by using method lookup only for methods' C<AUTOLOAD>s. + +The simple rule is: Inheritance will not work when autoloading +non-methods. The simple fix for old code is: In any module that used +to depend on inheriting C<AUTOLOAD> for non-methods from a base class +named C<BaseClass>, execute C<*AUTOLOAD = \&BaseClass::AUTOLOAD> during +startup. + +In code that currently says C<use AutoLoader; @ISA = qw(AutoLoader);> +you should remove AutoLoader from @ISA and change C<use AutoLoader;> to +C<use AutoLoader 'AUTOLOAD';>. + + +=head3 Use of code points over 0xFF in string bitwise operators + +The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat +their operands as strings of bytes. As such, values above 0xFF +are nonsensical. Using such code points with these operators +was deprecated in Perl 5.24, and is fatal as of Perl 5.28. + +=head3 In XS code, use of C<to_utf8_case()> + +This function has been removed as of Perl 5.28; instead convert to call +the appropriate one of: +L<C<toFOLD_utf8_safe>|perlapi/toFOLD_utf8_safe>. +L<C<toLOWER_utf8_safe>|perlapi/toLOWER_utf8_safe>, +L<C<toTITLE_utf8_safe>|perlapi/toTITLE_utf8_safe>, +or +L<C<toUPPER_utf8_safe>|perlapi/toUPPER_utf8_safe>. + +=head2 Perl 5.26 + +=head3 C<< --libpods >> in C<< Pod::Html >> + +Since Perl 5.18, the option C<< --libpods >> has been deprecated, and +using this option did not do anything other than producing a warning. + +The C<< --libpods >> option is no longer recognized as of Perl 5.26. + + +=head3 The utilities C<< c2ph >> and C<< pstruct >> + +These old, perl3-era utilities have been deprecated in favour of +C<< h2xs >> for a long time. As of Perl 5.26, they have been removed. + + +=head3 Trapping C<< $SIG {__DIE__} >> other than during program exit. + +The C<$SIG{__DIE__}> hook is called even inside an C<eval()>. It was +never intended to happen this way, but an implementation glitch made +this possible. This used to be deprecated, as it allowed strange action +at a distance like rewriting a pending exception in C<$@>. Plans to +rectify this have been scrapped, as users found that rewriting a +pending exception is actually a useful feature, and not a bug. + +Perl never issued a deprecation warning for this; the deprecation +was by documentation policy only. But this deprecation has been +lifted as of Perl 5.26. + + +=head3 Malformed UTF-8 string in "%s" + +This message indicates a bug either in the Perl core or in XS +code. Such code was trying to find out if a character, allegedly +stored internally encoded as UTF-8, was of a given type, such as +being punctuation or a digit. But the character was not encoded +in legal UTF-8. The C<%s> is replaced by a string that can be used +by knowledgeable people to determine what the type being checked +against was. + +Passing malformed strings was deprecated in Perl 5.18, and +became fatal in Perl 5.26. + + +=head2 Perl 5.24 + +=head3 Use of C<< *glob{FILEHANDLE} >> + +The use of C<< *glob{FILEHANDLE} >> was deprecated in Perl 5.8. +The intention was to use C<< *glob{IO} >> instead, for which +C<< *glob{FILEHANDLE} >> is an alias. + +However, this feature was undeprecated in Perl 5.24. + +=head3 Calling POSIX::%s() is deprecated + +The following functions in the C<POSIX> module are no longer available: +C<isalnum>, C<isalpha>, C<iscntrl>, C<isdigit>, C<isgraph>, C<islower>, +C<isprint>, C<ispunct>, C<isspace>, C<isupper>, and C<isxdigit>. The +functions are buggy and don't work on UTF-8 encoded strings. See their +entries in L<POSIX> for more information. + +The functions were deprecated in Perl 5.20, and removed in Perl 5.24. + + +=head2 Perl 5.16 + +=head3 Use of %s on a handle without * is deprecated + +It used to be possible to use C<tie>, C<tied> or C<untie> on a scalar +while the scalar holds a typeglob. This caused its filehandle to be +tied. It left no way to tie the scalar itself when it held a typeglob, +and no way to untie a scalar that had had a typeglob assigned to it. + +This was deprecated in Perl 5.14, and the bug was fixed in Perl 5.16. + +So now C<tie $scalar> will always tie the scalar, not the handle it holds. +To tie the handle, use C<tie *$scalar> (with an explicit asterisk). The same +applies to C<tied *$scalar> and C<untie *$scalar>. + + +=head1 SEE ALSO + +L<warnings>, L<diagnostics>. + +=cut diff --git a/gnu/usr.bin/perl/pod/perlhacktut.pod b/gnu/usr.bin/perl/pod/perlhacktut.pod index fc0833649be..72919fcd4a2 100644 --- a/gnu/usr.bin/perl/pod/perlhacktut.pod +++ b/gnu/usr.bin/perl/pod/perlhacktut.pod @@ -74,7 +74,7 @@ of C<pat>: items = SP - MARK; MARK++; - sv_setpvn(cat, "", 0); + SvPVCLEAR(cat); + patcopy = pat; while (pat < patend) { diff --git a/gnu/usr.bin/perl/pod/perlinterp.pod b/gnu/usr.bin/perl/pod/perlinterp.pod index bb559ba02b9..7ac6c9ee4cb 100644 --- a/gnu/usr.bin/perl/pod/perlinterp.pod +++ b/gnu/usr.bin/perl/pod/perlinterp.pod @@ -70,8 +70,7 @@ needs, the stacks, and so on. Now we pass Perl the command line options, and tell it to go: - exitstatus = perl_parse(my_perl, xs_init, argc, argv, (char **)NULL); - if (!exitstatus) + if (!perl_parse(my_perl, xs_init, argc, argv, (char **)NULL)) perl_run(my_perl); exitstatus = perl_destruct(my_perl); @@ -473,11 +472,11 @@ Originally, the tree would have looked like this: 11 SVOP (0x816dcf0) gv GV (0x80fa460) *a That is, fetch the C<a> entry from the main symbol table, and then look -at the scalar component of it: C<gvsv> (C<pp_gvsv> into F<pp_hot.c>) +at the scalar component of it: C<gvsv> (C<pp_gvsv> in F<pp_hot.c>) happens to do both these things. The right hand side, starting at line 5 is similar to what we've just -seen: we have the C<add> op (C<pp_add> also in F<pp_hot.c>) add +seen: we have the C<add> op (C<pp_add>, also in F<pp_hot.c>) add together two C<gvsv>s. Now, what's this about? @@ -531,8 +530,45 @@ statement. Get the values of C<$b> and C<$c>, and add them together. Find C<$a>, and assign one to the other. Then leave. The way Perl builds up these op trees in the parsing process can be -unravelled by examining F<perly.y>, the YACC grammar. Let's take the -piece we need to construct the tree for C<$a = $b + $c> +unravelled by examining F<toke.c>, the lexer, and F<perly.y>, the YACC +grammar. Let's look at the code that constructs the tree for C<$a = $b + +$c>. + +First, we'll look at the C<Perl_yylex> function in the lexer. We want to +look for C<case 'x'>, where x is the first character of the operator. +(Incidentally, when looking for the code that handles a keyword, you'll +want to search for C<KEY_foo> where "foo" is the keyword.) Here is the code +that handles assignment (there are quite a few operators beginning with +C<=>, so most of it is omitted for brevity): + + 1 case '=': + 2 s++; + ... code that handles == => etc. and pod ... + 3 pl_yylval.ival = 0; + 4 OPERATOR(ASSIGNOP); + +We can see on line 4 that our token type is C<ASSIGNOP> (C<OPERATOR> is a +macro, defined in F<toke.c>, that returns the token type, among other +things). And C<+>: + + 1 case '+': + 2 { + 3 const char tmp = *s++; + ... code for ++ ... + 4 if (PL_expect == XOPERATOR) { + ... + 5 Aop(OP_ADD); + 6 } + ... + 7 } + +Line 4 checks what type of token we are expecting. C<Aop> returns a token. +If you search for C<Aop> elsewhere in F<toke.c>, you will see that it +returns an C<ADDOP> token. + +Now that we know the two token types we want to look for in the parser, +let's take the piece of F<perly.y> we need to construct the tree for +C<$a = $b + $c> 1 term : term ASSIGNOP term 2 { $$ = newASSIGNOP(OPf_STACKED, $1, $2, $3); } @@ -541,9 +577,8 @@ piece we need to construct the tree for C<$a = $b + $c> If you're not used to reading BNF grammars, this is how it works: You're fed certain things by the tokeniser, which generally end up in -upper case. Here, C<ADDOP>, is provided when the tokeniser sees C<+> in -your code. C<ASSIGNOP> is provided when C<=> is used for assigning. -These are "terminal symbols", because you can't get any simpler than +upper case. C<ADDOP> and C<ASSIGNOP> are examples of "terminal symbols", +because you can't get any simpler than them. The grammar, lines one and three of the snippet above, tells you how to @@ -580,6 +615,49 @@ use C<$2>. The second parameter is the op's flags: 0 means "nothing special". Then the things to add: the left and right hand side of our expression, in scalar context. +The functions that create ops, which have names like C<newUNOP> and +C<newBINOP>, call a "check" function associated with each op type, before +returning the op. The check functions can mangle the op as they see fit, +and even replace it with an entirely new one. These functions are defined +in F<op.c>, and have a C<Perl_ck_> prefix. You can find out which +check function is used for a particular op type by looking in +F<regen/opcodes>. Take C<OP_ADD>, for example. (C<OP_ADD> is the token +value from the C<Aop(OP_ADD)> in F<toke.c> which the parser passes to +C<newBINOP> as its first argument.) Here is the relevant line: + + add addition (+) ck_null IfsT2 S S + +The check function in this case is C<Perl_ck_null>, which does nothing. +Let's look at a more interesting case: + + readline <HANDLE> ck_readline t% F? + +And here is the function from F<op.c>: + + 1 OP * + 2 Perl_ck_readline(pTHX_ OP *o) + 3 { + 4 PERL_ARGS_ASSERT_CK_READLINE; + 5 + 6 if (o->op_flags & OPf_KIDS) { + 7 OP *kid = cLISTOPo->op_first; + 8 if (kid->op_type == OP_RV2GV) + 9 kid->op_private |= OPpALLOW_FAKE; + 10 } + 11 else { + 12 OP * const newop + 13 = newUNOP(OP_READLINE, 0, newGVOP(OP_GV, 0, + 14 PL_argvgv)); + 15 op_free(o); + 16 return newop; + 17 } + 18 return o; + 19 } + +One particularly interesting aspect is that if the op has no kids (i.e., +C<readline()> or C<< <> >>) the op is freed and replaced with an entirely +new one that references C<*ARGV> (lines 12-16). + =head1 STACKS When perl executes something like C<addop>, how does it pass on its diff --git a/gnu/usr.bin/perl/pod/perlnumber.pod b/gnu/usr.bin/perl/pod/perlnumber.pod index ffe3ed5b432..d77fe68458c 100644 --- a/gnu/usr.bin/perl/pod/perlnumber.pod +++ b/gnu/usr.bin/perl/pod/perlnumber.pod @@ -59,7 +59,7 @@ numbers. (But realize that what we are discussing the rules for just the I<storage> of these numbers. The fact that you can store such "large" numbers does not mean that the I<operations> over these numbers will use all of the significant digits. -See L<"Numeric operators and numeric conversions"> for details.) +See L</"Numeric operators and numeric conversions"> for details.) In fact numbers stored in the native integer format may be stored either in the signed native form, or in the unsigned native form. Thus the limits diff --git a/gnu/usr.bin/perl/pod/perlreguts.pod b/gnu/usr.bin/perl/pod/perlreguts.pod index eac08f5d7a6..0eac156cdbf 100644 --- a/gnu/usr.bin/perl/pod/perlreguts.pod +++ b/gnu/usr.bin/perl/pod/perlreguts.pod @@ -693,7 +693,7 @@ simulated recursion. C<re_intuit_start()> is responsible for handling start points and no-match optimisations as determined by the results of the analysis done by -C<study_chunk()> (and described in L<Peep-hole Optimisation and Analysis>). +C<study_chunk()> (and described in L</Peep-hole Optimisation and Analysis>). The basic structure of this routine is to try to find the start- and/or end-points of where the pattern could match, and to ensure that the string diff --git a/gnu/usr.bin/perl/pod/splitman b/gnu/usr.bin/perl/pod/splitman index 9fe404a0610..325e1d96eee 100644 --- a/gnu/usr.bin/perl/pod/splitman +++ b/gnu/usr.bin/perl/pod/splitman @@ -14,7 +14,7 @@ while (<>) { if (name($desc) ne $myname) { $myname = name($desc); print $myname, "\n"; - open(MAN, "> $myname.3pl"); + open(MAN, '>', "$myname.3pl"); print MAN <<EOALL; $header .TH $myname 3PL "\\*(RP" |