diff options
| author | Ricardo Signes <rjbs@cpan.org> | 2013-05-06 21:54:24 -0400 |
|---|---|---|
| committer | Ricardo Signes <rjbs@cpan.org> | 2013-05-07 17:49:53 -0400 |
| commit | 5ed58cbd0b844b8a87c7a2f74bf48144fa94cc29 (patch) | |
| tree | 6e891afdcdc5d25937325fbd9944c932426b1238 /Porting | |
| parent | 44abfe822fdc028f992f13755dad520922c6d20a (diff) | |
| download | perl-5ed58cbd0b844b8a87c7a2f74bf48144fa94cc29.tar.gz | |
put the perldelta we had been working on in place
Diffstat (limited to 'Porting')
| -rw-r--r-- | Porting/perl5180delta.pod | 2940 |
1 files changed, 0 insertions, 2940 deletions
diff --git a/Porting/perl5180delta.pod b/Porting/perl5180delta.pod deleted file mode 100644 index e40c165be4..0000000000 --- a/Porting/perl5180delta.pod +++ /dev/null @@ -1,2940 +0,0 @@ -=encoding utf8 - -=head1 NAME - -perl5180delta - what is new for perl v5.18.0 - -=head1 DESCRIPTION - -This document describes differences between the 5.16.0 release and the 5.18.0 -release. - -If you are upgrading from an earlier release such as 5.16.0, first read -L<perl5160delta>, which describes differences between 5.14.0 and 5.16.0. - -=head1 Core Enhancements - -=head2 New mechanism for experimental features - -Newly-added experimental features will now require this incantation: - - no warnings "experimental::feature_name"; - use feature "feature_name"; # would warn without the prev line - -There is a new warnings category, called "experimental", containing -warnings that the L<feature> pragma emits when enabling experimental -features. - -Newly-added experimental features will also be given special warning IDs, -which consist of "experimental::" followed by the name of the feature. (The -plan is to extend this mechanism eventually to all warnings, to allow them -to be enabled or disabled individually, and not just by category.) - -By saying - - no warnings "experimental::feature_name"; - -you are taking responsibility for any breakage that future changes to, or -removal of, the feature may cause. - -Existing experimental features may begin emitting these warnings, too. Please -consult L<perlexperiment> for information on which features are considered -experimental. - -=head2 Hash overhaul - -Changes to the implementation of hashes in perl 5.18.0 will be one of the most -visible changes to the behavior of existing code. For the most part, these -changes will be visible as two distinct hash variables now providing their -contents in a different order where it was previously identical. When -encountering these changes, the key to cleaning up from them is to accept that -B<hashes are unordered collections> and to act accordingly. - -=head3 Hash randomization - -The seed used by Perl's hash function is now random. This means that the -order which keys/values will be returned from functions like C<keys()>, -C<values()>, and C<each()> will differ from run to run. - -This change was introduced to make Perl's hashes more robust to algorithmic -complexity attacks, and also because we discovered that it exposes hash -ordering dependency bugs and makes them easier to track down. - -Toolchain maintainers might want to invest in additional infrastructure to -test for things like this. Running tests several times in a row and then -comparing results will make it easier to spot hash order dependencies in -code. Authors are strongly encouraged not to expose the key order of -Perl's hashes to insecure audiences. - -Further, every hash has its own iteration order, which should make it much -more difficult to determine what the current hash seed is. - -=head3 New hash function: Murmurhash-32 - -We have switched Perl's hash function to use Murmurhash-32, and added build -support for several other hash functions. This new function is expected to -perform equivalently to the old one for shorter strings and is faster for -hashing longer strings. - -=head3 PERL_HASH_SEED enviornment variable now takes a hex value - -PERL_HASH_SEED no longer accepts an integer as a parameter, instead the -value is expected to be a binary string encoded in hex. This is to make -the infrastructure support hash seeds of arbitrary lengths which might -exceed that of an integer. (SipHash uses a 16 byte seed). - -=head3 Hash::Util::hash_seed() now returns a string - -Hash::Util::hash_seed() now returns a string instead of an integer. This -is to make the infrastructure support hash seeds of arbitrary lengths -which might exceed that of an integer. (SipHash uses a 16 byte seed). - -=head3 Output of PERL_HASH_SEED_DEBUG has been changed - -The environment variable PERL_HASH_SEED_DEBUG now makes perl show both the -hash function perl was built with AND the seed, in hex, in use for that -process. Code parsing this output, should it exist, must change to accommodate -the new format. Example of the new format: - - $ PERL_HASH_SEED_DEBUG=1 ./perl -e1 - HASH_FUNCTION = MURMUR3 HASH_SEED = 0x1476bb9f - -=head2 Upgrade to Unicode 6.2 - -Perl now supports the final version of Unicode 6.2. Earlier releases in -the 5.17 series supported Unicode 6.2 beta versions. There were no -substantive changes in the final Unicode 6.2 version from the most -recent beta, included in Perl 5.17.4. A list of changes from Unicode -6.1 is at L<http://www.unicode.org/versions/Unicode6.2.0>. - -=head2 Character name aliases may now include non-Latin1-range characters - -It is possible to define your own names for characters for use in -C<\N{...}>, C<charnames::vianame()>, etc. These names can now be -comprised of characters from the whole Unicode range. This allows for -names to be in your native language, and not just English. Certain -restrictions apply to the characters that may be used (you can't define -a name that has punctuation in it, for example). See L<charnames/CUSTOM -ALIASES>. - -=head2 New DTrace probes - -The following new DTrace probes have been added: - -=over 4 - -=item * - -C<op-entry> - -=item * - -C<loading-file> - -=item * - -C<loaded-file> - -=back - -=head2 C<${^LAST_FH}> - -This new variable provides access to the filehandle that was last read. -This is the handle used by C<$.> and by C<tell> and C<eof> without -arguments. - -=head2 Regular Expression Set Operations - -This is an B<experimental> feature to allow matching against the union, -intersection, etc., of sets of code points, similar to -L<Unicode::Regex::Set>. It can also be used to extend C</x> processing -to [bracketed] character classes, and as a replacement of user-defined -properties, allowing more complex expressions than they do. See -L<perlrecharclass/Extended Bracketed Character Classes>. - -=head2 Lexical subroutines - -This new feature is still considered B<experimental>. To enable it: - - use 5.018; - no warnings "experimental::lexical_subs"; - use feature "lexical_subs"; - -You can now declare subroutines with C<state sub foo>, C<my sub foo>, and -C<our sub foo>. (C<state sub> requires that the "state" feature be -enabled, unless you write it as C<CORE::state sub foo>.) - -C<state sub> creates a subroutine visible within the lexical scope in which -it is declared. The subroutine is shared between calls to the outer sub. - -C<my sub> declares a lexical subroutine that is created each time the -enclosing block is entered. C<state sub> is generally slightly faster than -C<my sub>. - -C<our sub> declares a lexical alias to the package subroutine of the same -name. - -For more information, see L<perlsub/Lexical Subroutines>. - -=head2 Computed Labels - -The loop controls C<next>, C<last> and C<redo>, and the special C<dump> -operator, now allow arbitrary expressions to be used to compute labels at run -time. Previously, any argument that was not a constant was treated as the -empty string. - -=head2 More CORE:: subs - -Several more built-in functions have been added as subroutines to the -CORE:: namespace - namely, those non-overridable keywords that can be -implemented without custom parsers: C<defined>, C<delete>, C<exists>, -C<glob>, C<pos>, C<protoytpe>, C<scalar>, C<split>, C<study>, and C<undef>. - -As some of these have prototypes, C<prototype('CORE::...')> has been -changed to not make a distinction between overridable and non-overridable -keywords. This is to make C<prototype('CORE::pos')> consistent with -C<prototype(&CORE::pos)>. - -=head2 C<kill> with negative signal names - -C<kill> has always allowed a negative signal number, which kills the -process group instead of a single process. It has also allowed signal -names. But it did not behave consistently, because negative signal names -were treated as 0. Now negative signals names like C<-INT> are supported -and treated the same way as -2 [perl #112990]. - -=head1 Security - -=head2 C<Storable> security warning in documentation - -The documentation for C<Storable> now includes a section which warns readers -of the danger of accepting Storable documents from untrusted sources. The -short version is that deserializing certain types of data can lead to loading -modules and other code execution. This is documented behavior and wanted -behavior, but this opens an attack vector for malicious entities. - -=head2 C<Locale::Maketext> allowed code injection via a malicious template - -If users could provide a translation string to Locale::Maketext, this could be -used to invoke arbitrary Perl subroutines available in the current process. - -This has been fixed, but it is still possible to invoke any method provided by -C<Locale::Maketext> itself or a subclass that you are using. One of these -methods in turn will invoke the Perl core's C<sprintf> subroutine. - -In summary, allowing users to provide translation strings without auditing -them is a bad idea. - -This vulnerability is documented in CVE-2012-6329. - -=head2 Avoid calling memset with a negative count - -Poorly written perl code that allows an attacker to specify the count to perl's -C<x> string repeat operator can already cause a memory exhaustion -denial-of-service attack. A flaw in versions of perl before 5.15.5 can escalate -that into a heap buffer overrun; coupled with versions of glibc before 2.16, it -possibly allows the execution of arbitrary code. - -The flaw addressed to this commit has been assigned identifier CVE-2012-5195 -and was researched by Tim Brown. - -=head1 Incompatible Changes - -=head2 See also: hash overhaul - -Some of the changes in the L<hash overhaul|/"Hash overhaul"> are not fully -compatible with previous versions of perl. Please read that section. - -=head2 An unknown character name in C<\N{...}> is now a syntax error - -Previously, it warned, and the Unicode REPLACEMENT CHARACTER was -substituted. Unicode now recommends that this situation be a syntax -error. Also, the previous behavior led to some confusing warnings and -behaviors, and since the REPLACEMENT CHARACTER has no use other than as -a stand-in for some unknown character, any code that has this problem is -buggy. - -=head2 Formerly deprecated characters in C<\N{}> character name aliases are now errors. - -Since v5.12.0, it has been deprecated to use certain characters in -user-defined C<\N{...}> character names. These now cause a syntax -error. For example, it is now an error to begin a name with a digit, -such as in - - my $undraftable = "\N{4F}"; # Syntax error! - -or to have commas anywhere in the name. See L<charnames/CUSTOM ALIASES> - -=head2 C<\N{BELL}> now refers to U+1F514 instead of U+0007 - -Unicode 6.0 reused the name "BELL" for a different code point than it -traditionally had meant. Since Perl v5.14, use of this name still -referred to U+0007, but would raise a deprecation warning. Now, "BELL" -refers to U+1F514, and the name for U+0007 is "ALERT". All the -functions in L<charnames> have been correspondingly updated. - -=head2 New Restrictions in Multi-Character Case-Insensitive Matching in Regular Expression Bracketed Character Classes - -Unicode has now withdrawn their previous recommendation for regular -expressions to automatically handle cases where a single character can -match multiple characters case-insensitively, for example the letter -LATIN SMALL LETTER SHARP S and the sequence C<ss>. This is because -it turns out to be impracticable to do this correctly in all -circumstances. Because Perl has tried to do this as best it can, it -will continue to do so. (We are considering an option to turn it off.) -However, a new restriction is being added on such matches when they -occur in [bracketed] character classes. People were specifying -things such as C</[\0-\xff]/i>, and being surprised that it matches the -two character sequence C<ss> (since LATIN SMALL LETTER SHARP S occurs in -this range). This behavior is also inconsistent with using a -property instead of a range: C<\p{Block=Latin1}> also includes LATIN -SMALL LETTER SHARP S, but C</[\p{Block=Latin1}]/i> does not match C<ss>. -The new rule is that for there to be a multi-character case-insensitive -match within a bracketed character class, the character must be -explicitly listed, and not as an end point of a range. This more -closely obeys the Principle of Least Astonishment. See -L<perlrecharclass/Bracketed Character Classes>. Note that a bug [perl -#89774], now fixed as part of this change, prevented the previous -behavior from working fully. - -=head2 Explicit rules for variable names and identifiers - -Due to an oversight, length-one variable names in 5.16 were completely -unrestricted, and opened the door to several kinds of insanity. As of -5.18, these now follow the rules of other identifiers, in addition -to accepting characters that match the C<\p{POSIX_Punct}> property. - -There are no longer any differences in the parsing of identifiers -specified as C<$...> or C<${...}>; previously, they were dealt with in -different parts of the core, and so had slightly different behavior. For -instance, C<${foo:bar}> was a legal variable name. Since they are now -both parsed by the same code, that is no longer the case. - -=head2 C<\s> in regular expressions now matches a Vertical Tab - -No one could recall why C<\s> didn't match C<\cK>, the vertical tab. -Now it does. Given the extreme rarity of that character, very little -breakage is expected. - -=head2 C</(?{})/> and C</(??{})/> have been heavily reworked - -The implementation of this feature has been almost completely rewritten. -Although its main intent is to fix bugs, some behaviors, especially -related to the scope of lexical variables, will have changed. This is -described more fully in the L</Selected Bug Fixes> section. - -=head2 Stricter parsing of substitution replacement - -It is no longer possible to abuse the way the parser parses C<s///e> like -this: - - %_=(_,"Just another "); - $_="Perl hacker,\n"; - s//_}->{_/e;print - -=head2 C<given> now aliases the global C<$_> - -Instead of assigning to an implicit lexical C<$_>, C<given> now makes the -global C<$_> an alias for its argument, just like C<foreach>. However, it -still uses lexical C<$_> if there is lexical C<$_> in scope (again, just like -C<foreach>) [perl #114020]. - -=head2 Lexical C<$_> is now experimental - -Since it was introduced in Perl 5.10, it has caused much confusion with no -obvious solution: - -=over - -=item * - -Various modules (e.g., List::Util) expect callback routines to use the -global C<$_>. C<use List::Util 'first'; my $_; first { $_ == 1 } @list> -does not work as one would expect. - -=item * - -A C<my $_> declaration earlier in the same file can cause confusing closure -warnings. - -=item * - -The "_" subroutine prototype character allows called subroutines to access -your lexical C<$_>, so it is not really private after all. - -=item * - -Nevertheless, subroutines with a "(@)" prototype and methods cannot access -the caller's lexical C<$_>, unless they are written in XS. - -=item * - -But even XS routines cannot access a lexical C<$_> declared, not in the -calling subroutine, but in an outer scope, iff that subroutine happened not -to mention C<$_> or use any operators that default to C<$_>. - -=back - -It is our hope that lexical C<$_> can be rehabilitated, but this may -cause changes in its behavior. Please use it with caution until it -becomes stable. - -=head2 readline() with C<$/ = \N> now reads N characters, not N bytes - -Previously, when reading from a stream with I/O layers such as -C<encoding>, the readline() function, otherwise known as the C<< <> >> -operator, would read I<N> bytes from the top-most layer. [perl #79960] - -Now, I<N> characters are read instead. - -There is no change in behaviour when reading from streams with no -extra layers, since bytes map exactly to characters. - -=head2 Overridden C<glob> is now passed one argument - -C<glob> overrides used to be passed a magical undocumented second argument -that identified the caller. Nothing on CPAN was using this, and it got in -the way of a bug fix, so it was removed. If you really need to identify -the caller, see L<Devel::Callsite> on CPAN. - -=head2 Here-doc parsing - -The body of a here-document inside a quote-like operator now always begins -on the line after the "<<foo" marker. Previously, it was documented to -begin on the line following the containing quote-like operator, but that -was only sometimes the case [perl #114040]. - -=head2 Alphanumeric operators must now be separated from the closing -delimiter of regular expressions - -You may no longer write something like: - - m/a/and 1 - -Instead you must write - - m/a/ and 1 - -with whitespace separating the operator from the closing delimiter of -the regular expression. Not having whitespace has resulted in a -deprecation warning since Perl v5.14.0. - -=head2 qw(...) can no longer be used as parentheses - -C<qw> lists used to fool the parser into thinking they were always -surrounded by parentheses. This permitted some surprising constructions -such as C<foreach $x qw(a b c) {...}>, which should really be written -C<foreach $x (qw(a b c)) {...}>. These would sometimes get the lexer into -the wrong state, so they didn't fully work, and the similar C<foreach qw(a -b c) {...}> that one might expect to be permitted never worked at all. - -This side effect of C<qw> has now been abolished. It has been deprecated -since Perl 5.13.11. It is now necessary to use real parentheses -everywhere that the grammar calls for them. - -=head2 Interaction of lexical and default warnings - -Turning on any lexical warnings used first to disable all default warnings -if lexical warnings were not already enabled: - - $*; # deprecation warning - use warnings "void"; - $#; # void warning; no deprecation warning - -Now, the debugging, deprecated, glob, inplace and malloc warnings -categories are left on when turning on lexical warnings (unless they are -turned off by C<no warnings>, of course). - -This may cause deprecation warnings to occur in code that used to be free -of warnings. - -Those are the only categories consisting only of default warnings. Default -warnings in other categories are still disabled by C<use warnings -"category">, as we do not yet have the infrastructure for controlling -individual warnings. - -=head2 C<state sub> and C<our sub> - -Due to an accident of history, C<state sub> and C<our sub> were equivalent -to a plain C<sub>, so one could even create an anonymous sub with -C<our sub { ... }>. These are now disallowed outside of the "lexical_subs" -feature. Under the "lexical_subs" feature they have new meanings described -in L<perlsub/Lexical Subroutines>. - -=head2 Defined values stored in environment are forced to byte strings - -A value stored in an environment variable has always been stringified. In this -release, it is 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 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>). - -=head2 C<require> dies for unreadable files - -When C<require> encounters an unreadable file, it now dies. It used to -ignore the file and continue searching the directories in C<@INC> -[perl #113422]. - -=head2 C<gv_fetchmeth_*> and SUPER - -The various C<gv_fetchmeth_*> XS functions used to treat a package whose -named ended with ::SUPER specially. A method lookup on the Foo::SUPER -package would be treated as a SUPER method lookup on the Foo package. This -is no longer the case. To do a SUPER lookup, pass the Foo stash and the -GV_SUPER flag. - -=item C<split>'s first argument is more consistently interpreted - -After some changes earlier in 5.17, C<split>'s behavior has been -simplified: if the PATTERN argument evaluates to a literal string -containing one space, it is treated the way that a I<literal> string -containing one space once was. - -=head1 Deprecations - -=head2 Deprecated modules - -The following modules will be removed from the core distribution in a -future release, and should be installed from CPAN instead. Distributions -on CPAN which require these should add them to their prerequisites. -The core versions of these modules will issue "deprecated"-category -warnings. - -You can silence these deprecation warnings by installing the modules -in question from CPAN. - -=over - -=item L<Archive::Extract> - -=item L<B::Lint> - -=item L<B::Lint::Debug> - -=item L<CPANPLUS> and all included C<CPANPLUS::*> modules - -=item L<Devel::InnerPackage> - -=item L<encoding> - -=item L<Log::Message> - -=item L<Log::Message::Config> - -=item L<Log::Message::Handlers> - -=item L<Log::Message::Item> - -=item L<Log::Message::Simple> - -=item L<Module::Pluggable> - -=item L<Module::Pluggable::Object> - -=item L<Object::Accessor> - -=item L<Pod::LaTeX> - -=item L<Term::UI> - -=item L<Term::UI::History> - -=back - -=head2 Deprecated Utilities - -The following utilities will be removed from the core distribution in a -future release as their associated modules have been deprecated. They -will remain available with the applicable CPAN distribution. - -=over - -=item L<cpanp> - -=item C<cpanp-run-perl> - -=item L<cpan2dist> - -These items are part of the C<CPANPLUS> distribution. - -=item L<pod2latex> - -This item is part of the C<Pod::LaTeX> distribution. - -=back - -=head2 PL_sv_objcount - -This interpreter-global variable used to track the total number of -Perl objects in the interpreter. It is no longer maintained and will -be removed altogether in Perl 5.20. - -=head2 Five additional characters should be escaped in patterns with C</x> - -When a regular expression pattern is compiled with C</x>, Perl treats 6 -characters as white space to ignore, such as SPACE and TAB. However, -Unicode recommends 11 characters be treated thusly. We will conform -with this in a future Perl version. In the meantime, use of any of the -missing characters will raise a deprecation warning, unless turned off. -The five characters are: -U+0085 NEXT LINE, -U+200E LEFT-TO-RIGHT MARK, -U+200F RIGHT-TO-LEFT MARK, -U+2028 LINE SEPARATOR, -and -U+2029 PARAGRAPH SEPARATOR. - -=head2 User-defined charnames with surprising whitespace - -A user-defined character name with trailing or multiple spaces in a row is -likely a typo. This now generates a warning when defined, on the assumption -that uses of it will be unlikely to include the excess whitespace. - -=head2 Various XS-callable functions are now deprecated - -All the functions used to classify characters will be removed from a -future version of Perl, and should not be used. With participating C -compilers (e.g., gcc), compiling any file that uses any of these will -generate a warning. These were not intended for public use; there are -equivalent, faster, macros for most of them. -See L<perlapi/Character classes>. The complete list (including some -that were deprecated in 5.17.7) is: -C<is_uni_alnum>, C<is_uni_alnumc>, C<is_uni_alnumc_lc>, -C<is_uni_alnum_lc>, C<is_uni_alpha>, C<is_uni_alpha_lc>, -C<is_uni_ascii>, C<is_uni_ascii_lc>, C<is_uni_blank>, -C<is_uni_blank_lc>, C<is_uni_cntrl>, C<is_uni_cntrl_lc>, -C<is_uni_digit>, C<is_uni_digit_lc>, C<is_uni_graph>, -C<is_uni_graph_lc>, C<is_uni_idfirst>, C<is_uni_idfirst_lc>, -C<is_uni_lower>, C<is_uni_lower_lc>, C<is_uni_print>, -C<is_uni_print_lc>, C<is_uni_punct>, C<is_uni_punct_lc>, -C<is_uni_space>, C<is_uni_space_lc>, C<is_uni_upper>, -C<is_uni_upper_lc>, C<is_uni_xdigit>, C<is_uni_xdigit_lc>, -C<is_utf8_alnum>, C<is_utf8_alnumc>, C<is_utf8_alpha>, -C<is_utf8_ascii>, C<is_utf8_blank>, C<is_utf8_char>, -C<is_utf8_cntrl>, C<is_utf8_digit>, C<is_utf8_graph>, -C<is_utf8_idcont>, C<is_utf8_idfirst>, C<is_utf8_lower>, -C<is_utf8_mark>, C<is_utf8_perl_space>, C<is_utf8_perl_word>, -C<is_utf8_posix_digit>, C<is_utf8_print>, C<is_utf8_punct>, -C<is_utf8_space>, C<is_utf8_upper>, C<is_utf8_xdigit>, -C<is_utf8_xidcont>, C<is_utf8_xidfirst>. - -In addition these three functions that have never worked properly are -deprecated: -C<to_uni_lower_lc>, C<to_uni_title_lc>, and C<to_uni_upper_lc>. - -=head2 Certain rare uses of backslashes within regexes are now deprectated - -There are three pairs of characters that Perl recognizes as -metacharacters in regular expression patterns: C<{}>, C<[]>, and C<()>. -These can be used as well to delimit patterns, as in: - - m{foo} - s(foo)(bar) - -Since they are metacharacters, they have special meaning to regular -expression patterns, and it turns out that you can't turn off that -special meaning by the normal means of preceding them with a backslash, -if you use them, paired, within a pattern delimitted by them. For -example, in - - m{foo\{1,3\}} - -the backslashes do not change the behavior, and this matches -S<C<"f o">> followed by one to three more occurrences of C<"o">. - -Usages like this, where they are interpreted as metacharacters, are -exceedingly rare; we think there are none, for example, in all of CPAN. -Hence, this deprecation should affect very little code. It does give -notice, however, that any such code needs to change, which will in turn -allow us to change the behavior in future Perl versions so that the -backslashes do have an effect, and without fear that we are silently -breaking any existing code. - -=head1 Future Deprecations - -=over - -=item * - -Platforms with out support infrastructure - -Both Windows CE and z/OS have been historically under-maintained, and are -currently neither successfully building nor regularly being smoke tested. -Efforts are underway to change this situation, but it should not be taken for -granted that the platforms are safe and supported. If they do not become -buildable and regularly smoked, support for them may be actively removed in -future releases. If you have an interest in these platforms and you can lend -your time, expertise, or hardware to help support these platforms, please let -the perl development effort know by emailing C<perl5-porters@perl.org>. - -Some platforms that appear otherwise entirely dead are also on the short list -for removal between now and 5.20.0: - -=over - -=item DG/UX - -=item NeXT - -=back - -=item * - -Swapping of $< and $> - -For more information about this future deprecation, see L<the relevant RT -ticket|https://rt.perl.org/rt3/Ticket/Display.html?id=96212>. - -=item * - -sfio, stdio - -Perl supports being built without PerlIO proper, using a stdio or sfio -wrapper instead. A perl build like this will not support IO layers and -thus Unicode IO, making it rather handicapped. - -PerlIO supports a C<stdio> layer if stdio use is desired, and similarly a -sfio layer could be produced. - -=item * - -C<microperl>, long broken and of unclear present purpose, will be removed. - -=item * - -Revamping C<< "\Q" >> semantics in double-quotish strings when combined with -other escapes. - -There are several bugs and inconsistencies involving combinations -of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair. -These need to be fixed, and doing so will necessarily change current -behavior. The changes have not yet been settled. - -=back - -=head1 Performance Enhancements - -=over 4 - -=item * - -Lists of lexical variable declarations (C<my($x, $y)>) are now optimised -down to a single op and are hence faster than before. - -=item * - -A new C preprocessor define C<NO_TAINT_SUPPORT> was added that, if set, -disables Perl's taint support altogether. Using the -T or -t command -line flags will cause a fatal error. Beware that both core tests as -well as many a CPAN distribution's tests will fail with this change. On -the upside, it provides a small performance benefit due to reduced -branching. - -B<Do not enable this unless you know exactly what you are getting yourself -into.> - -=item * - -C<pack> with constant arguments is now constant folded in most cases -[perl #113470]. - -=item * - -Speed up in regular expression matching against Unicode properties. The -largest gain is for C<\X>, the Unicode "extended grapheme cluster." The -gain for it is about 35% - 40%. Bracketed character classes, e.g., -C<[0-9\x{100}]> containing code points above 255 are also now faster. - -=item * - -On platforms supporting it, several former macros are now implemented as static -inline functions. This should speed things up slightly on non-GCC platforms. - -=item * - -Apply the optimisation of hashes in boolean context, such as in C<if> or -C<and>, to constructs in non-void context. - -=item * - -Extend the optimisation of hashes in boolean context to C<scalar(%hash)>, -C<%hash ? ... : ...>, and C<sub { %hash || ... }>. - -=item * - -Filetest ops manage the stack in a fractionally more efficient manner. - -=item * - -Globs used in a numeric context are now numified directly in most cases, -rather than being numerified via stringification. - -=item * - -The C<x> repetition operator is now folded to a single constant at compile -time if called in scalar context with constant operands and no parentheses -around the left operand. - -=back - -=head1 Modules and Pragmata - -=head2 New Modules and Pragmata - -=over 4 - -=item * - -L<Config::Perl::V> version 0.16 has been added as a dual-lifed module. -It provides structured data retrieval of C<perl -V> output including -information only known to the C<perl> binary and not available via L<Config>. - -=back - -=head2 Updated Modules and Pragmata - -This is only an overview of selected module updates. For a complete -list of updates, run: - - $ corelist --diff 5.14.0 5.16.0 - -You can substitute your favorite version in place of 5.14.0, too. - -=over 4 - -=item * - -L<XXX> has been upgraded from version A.xx to B.yy. - -=back - -=head2 Removed Modules and Pragmata - -=over - -=item * - -L<Version::Requirements> has been removed from the core distribution. It is -available under a different name: L<CPAN::Meta::Requirements>. - -=back - -=head1 Documentation - -=head2 Changes to Existing Documentation - -=head3 L<perlcheat> - -=over 4 - -=item * - -L<perlcheat> has been reorganized, and a few new sections were added. - -=back - -=head3 L<perldata> - -=over 4 - -=item * - -Now explicitly documents the behaviour of hash initializer lists that -contain duplicate keys. - -=back - -=head3 L<perldiag> - -=over 4 - -=item * - -The explanation of symbolic references being prevented by "strict refs" -now doesn't assume that the reader knows what symbolic references are. - -=back - -=head3 L<perlfaq> - -=over 4 - -=item * - -L<perlfaq> has been synchronized with version 5.0150040 from CPAN. - -=back - -=head3 L<perlfunc> - -=over 4 - -=item * - -The return value of C<pipe> is now documented. - -=item * - -Clarified documentation of C<our>. - -=back - -=head3 L<perlop> - -=over 4 - -=item * - -Loop control verbs (C<dump>, C<goto>, C<next>, C<last> and C<redo>) have always -had the same precedence as assignment operators, but this was not documented -until now. - -=back - -=head3 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>. - -XXX New or changed warnings emitted by the core's C<C> code go here. Also -include any changes in L<perldiag> that reconcile it to the C<C> code. - -=head2 New Diagnostics - -XXX Newly added diagnostic messages go under here, separated into New Errors -and New Warnings - -=head3 New Errors - -=over 4 - -=item * - -L<Unterminated delimiter for here document|perldiag/"Unterminated delimiter for here document"> - -This message now occurs when a here document label has an initial quotation -mark but the final quotation mark is missing. - -This replaces a bogus and misleading error message about not finding the label -itself [perl #114104]. - -=item * - -L<panic: child pseudo-process was never scheduled|perldiag/"panic: child pseudo-process was never scheduled"> - -This error is thrown when a child pseudo-process in the ithreads implementation -on Windows was not scheduled within the time period allowed and therefore was -not able to initialize properly [perl #88840]. - -=item * - -L<Group name must start with a non-digit word character in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Group name must start with a non-digit word character in regex; marked by <-- HERE in m/%s/"> - -This error has been added for C<(?&0)>, which is invalid. It used to -produce an incomprehensible error message [perl #101666]. - -=item * - -L<Can't use an undefined value as a subroutine reference|perldiag/"Can't use an undefined value as %s reference"> - -Calling an undefined value as a subroutine now produces this error message. -It used to, but was accidentally disabled, first in Perl 5.004 for -non-magical variables, and then in Perl 5.14 for magical (e.g., tied) -variables. It has now been restored. In the mean time, undef was treated -as an empty string [perl #113576]. - -=item * - -L<Experimental "%s" subs not enabled|perldiag/"Experimental "%s" subs not enabled"> - -To use lexical subs, you must first enable them: - - no warnings 'experimental::lexical_subs'; - use feature 'lexical_subs'; - my sub foo { ... } - -=back - -=head3 New Warnings - -=over 4 - -=item * - -L<%c* is deprecated, and will become a syntax error|perldiag/"%c* is deprecated, and will become a syntax error"> - -Use of C<@*>, C<&*>, C<**> or C<%*> is now deprecated, and will generate a -compile time warning, enabled by default. In future such code will fail to -compile with a syntax error. Removing these variables, along with C<$*>, -will permit future syntax additions. - -=item * - -XXX: This needs more detail. - -Strings with code points over 0xFF may not be mapped into in-memory file -handles - -=item * - -L<'%s' resolved to '\o{%s}%d'|perldiag/"'%s' resolved to '\o{%s}%d'"> - -=item * - -L<'Trailing white-space in a charnames alias definition is deprecated'|perldiag/"Trailing white-space in a charnames alias definition is deprecated"> - -=item * - -L<'A sequence of multiple spaces in a charnames alias definition is deprecated'|perldiag/"A sequence of multiple spaces in a charnames alias definition is deprecated"> - -=item * - -L<'Passing malformed UTF-8 to "%s" is deprecated'|perldiag/"Passing malformed UTF-8 to "%s" is deprecated"> - -=item * - -L<Subroutine "&%s" is not available|perldiag/"Subroutine "&%s" is not available"> - -(W closure) During compilation, an inner named subroutine or eval is -attempting to capture an outer lexical subroutine that is not currently -available. This can happen for one of two reasons. First, the lexical -subroutine may be declared in an outer anonymous subroutine that has not -yet been created. (Remember that named subs are created at compile time, -while anonymous subs are created at run-time.) For example, - - sub { my sub a {...} sub f { \&a } } - -At the time that f is created, it can't capture the current the "a" sub, -since the anonymous subroutine hasn't been created yet. Conversely, the -following won't give a warning since the anonymous subroutine has by now -been created and is live: - - sub { my sub a {...} eval 'sub f { \&a }' }->(); - -The second situation is caused by an eval accessing a variable that has -gone out of scope, for example, - - sub f { - my sub a {...} - sub { eval '\&a' } - } - f()->(); - -Here, when the '\&a' in the eval is being compiled, f() is not currently -being executed, so its &a is not available for capture. - -=item * - -L<"%s" subroutine &%s masks earlier declaration in same %s|perldiag/"%s" subroutine &%s masks earlier declaration in same %s> - -(W misc) A "my" or "state" subroutine has been redeclared in the -current scope or statement, effectively eliminating all access to -the previous instance. This is almost always a typographical error. -Note that the earlier subroutine will still exist until the end of -the scope or until all closure references to it are destroyed. - -=item * - -L<The %s feature is experimental|perldiag/"The %s feature is experimental"> - -(S experimental) This warning is emitted if you enable an experimental -feature via C<use feature>. 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::lexical_subs"; - use feature "lexical_subs"; - -=item * - -L<sleep(%u) too large|perldiag/"sleep(%u) too large"> - -(W overflow) You called C<sleep> with a number that was larger than it can -reliably handle and C<sleep> probably slept for less time than requested. - -=item * - -L<Wide character in setenv|perldiag/"Wide character in %s"> - -Attempts to put wide characters into environment variables via C<%ENV> now -provoke this warning. - -=item * - -"L<Invalid negative number (%s) in chr|perldiag/"Invalid negative number (%s) in chr">" - -C<chr()> now warns when passed a negative value [perl #83048]. - -=item * - -"L<Integer overflow in srand|perldiag/"Integer overflow in srand">" - -C<srand()> now warns when passed a value that doesn't fit in a C<UV> (since the -value will be truncated rather than overflowing) [perl #40605]. - -=item * - -"L<-i used with no filenames on the command line, reading from STDIN|perldiag/"-i used with no filenames on the command line, reading from STDIN">" - -Running perl with the C<-i> flag now warns if no input files are provided on -the command line [perl #113410]. - -=back - -=head2 Changes to Existing Diagnostics - -=over 4 - -=item * - -L<$* is no longer supported, and will become a syntax error|perldiag/"$* is no longer supported, and will become a syntax error"> - -The warning that use of C<$*> and C<$#> is no longer supported is now -generated for every location that references them. Previously it would fail -to be generated if another variable using the same typeglob was seen first -(e.g. C<@*> before C<$*>), and would not be generated for the second and -subsequent uses. (It's hard to fix the failure to generate warnings at all -without also generating them every time, and warning every time is -consistent with the warnings that C<$[> used to generate.) - -=item * - -The warnings for C<\b{> and C<\B{> were added. They are a deprecation -warning which should be turned off by that category. One should not -have to turn off regular regexp warnings as well to get rid of these. - -=item * - -L<Constant(%s): Call to &{$^H{%s}} did not return a defined value|perldiag/Constant(%s): Call to &{$^H{%s}} did not return a defined value> - -Constant overloading that returns C<undef> results in this error message. -For numeric constants, it used to say "Constant(undef)". "undef" has been -replaced with the number itself. - -=item * - -The error produced when a module cannot be loaded now includes a hint that -the module may need to be installed: "Can't locate hopping.pm in @INC (you -may need to install the hopping module) (@INC contains: ...)" - -=item * - -L<vector argument not supported with alpha versions|perldiag/vector argument not supported with alpha versions> - -This warning was not suppressable, even with C<no warnings>. Now it is -suppressible, and has been moved from the "internal" category to the -"printf" category. - -=item * - -C<< Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ >> - -This fatal error has been turned into a warning that reads: - -L<< Quantifier {n,m} with n > m can't match in regex | perldiag/Quantifier {n,m} with n > m can't match in regex >> - -(W regexp) Minima should be less than or equal to maxima. If you really want -your regexp to match something 0 times, just put {0}. - -=item * - -The "Runaway prototype" warning that occurs in bizarre cases has been -removed as being unhelpful and inconsistent. - -=item * - -The "Not a format reference" error has been removed, as the only case in -which it could be triggered was a bug. - -=item * - -The "Unable to create sub named %s" error has been removed for the same -reason. - -=item * - -The 'Can't use "my %s" in sort comparison' error has been downgraded to a -warning, '"my %s" used in sort comparison' (with 'state' instead of 'my' -for state variables). In addition, the heuristics for guessing whether -lexical $a or $b has been misused have been improved to generate fewer -false positives. Lexical $a and $b are no longer disallowed if they are -outside the sort block. Also, a named unary or list operator inside the -sort block no longer causes the $a or $b to be ignored [perl #86136]. - -=back - -=head1 Utility Changes - -=head3 L<h2xs> - -=over 4 - -=item * - -F<h2xs> no longer produces invalid code for empty defines. [perl #20636] - -=back - -=head1 Configuration and Compilation - -=over 4 - -=item * - -Added C<useversionedarchname> option to Configure - -When set, it includes 'api_versionstring' in 'archname'. E.g. -x86_64-linux-5.13.6-thread-multi. It is unset by default. - -This feature was requested by Tim Bunce, who observed that -INSTALL_BASE creates a library structure that does not -differentiate by perl version. Instead, it places architecture -specific files in "$install_base/lib/perl5/$archname". This makes -it difficult to use a common INSTALL_BASE library path with -multiple versions of perl. - -By setting -Duseversionedarchname, the $archname will be -distinct for architecture *and* API version, allowing mixed use of -INSTALL_BASE. - -=item * - -Configure will honour the external C<MAILDOMAIN> environment variable, if set. - -=item * - -C<installman> no longer ignores the silent option - -=item * - -Both C<META.yml> and C<META.json> files are now included in the distribution. - -=item * - -F<Configure> will now correctly detect C<isblank()> when compiling with a C++ -compiler. - -=item * - -The pager detection in F<Configure> has been improved to allow responses which -specify options after the program name, e.g. B</usr/bin/less -R>, if the user -accepts the default value. This helps B<perldoc> when handling ANSI escapes -[perl #72156]. - -=back - -=head1 Testing - -=over 4 - -=item * - -The test suite now has a section for tests that require very large amounts -of memory. These tests won't run by default; they can be enabled by -setting the C<PERL_TEST_MEMORY> environment variable to the number of -gibibytes of memory that may be safely used. - -=back - -=head1 Platform Support - -=head2 Discontinued Platforms - -=over 4 - -=item BeOS - -BeOS was an operating system for personal computers developed by Be Inc, -initially for their BeBox hardware. The OS Haiku was written as an open -source replacement for/continuation of BeOS, and its perl port is current and -actively maintained. - -=item UTS Global - -Support code relating to UTS global has been removed. UTS was a mainframe -version of System V created by Amdahl, subsequently sold to UTS Global. The -port has not been touched since before Perl 5.8.0, and UTS Global is now -defunct. - -=item VM/ESA - -Support for VM/ESA has been removed. The port was tested on 2.3.0, which -IBM ended service on in March 2002. 2.4.0 ended service in June 2003, and -was superseded by Z/VM. The current version of Z/VM is V6.2.0, and scheduled -for end of service on 2015/04/30. - -=item MPE/IX - -Support for MPE/IX has been removed. - -=item EPOC - -Support code relating to EPOC has been removed. EPOC was a family of -operating systems developed by Psion for mobile devices. It was the -predecessor of Symbian. The port was last updated in April 2002. - -=item Rhapsody - -Support for Rhapsody has been removed. - -=back - -=head2 Platform-Specific Notes - -=head3 AIX - -Configure now always adds C<-qlanglvl=extc99> to the CC flags on AIX when -using xlC. This will make it easier to compile a number of XS-based modules -that assume C99 [perl #113778]. - -=head3 clang++ - -There is now a workaround for a compiler bug that prevented compiling -with clang++ since Perl 5.15.7 [perl #112786]. - -=head3 C++ - -When compiling the Perl core as C++ (which is only semi-supported), the -mathom functions are now compiled as C<extern "C">, to ensure proper -binary compatibility. (However, binary compatibility isn't generally -guaranteed anyway in the situations where this would matter.) - -=head3 Darwin - -Stop hardcoding an alignment on 8 byte boundaries to fix builds using --Dusemorebits. - -=head3 Haiku - -Perl should now work out of the box on Haiku R1 Alpha 4. - -=head3 MidnightBSD - -C<libc_r> was removed from recent versions of MidnightBSD and older versions -work better with C<pthread>. Threading is now enabled using C<pthread> which -corrects build errors with threading enabled on 0.4-CURRENT. - -=head3 Solaris - -In Configure, avoid running sed commands with flags not supported on Solaris. - -=head3 VMS - -=over - -=item * - -Where possible, the case of filenames and command-line arguments is now -preserved by enabling the CRTL features C<DECC$EFS_CASE_PRESERVE> and -C<DECC$ARGV_PARSE_STYLE> at start-up time. The latter only takes effect -when extended parse is enabled in the process from which Perl is run. - -=item * - -The character set for Extended Filename Syntax (EFS) is now enabled by default -on VMS. Among other things, this provides better handling of dots in directory -names, multiple dots in filenames,and spaces in filenames. To obtain the old -behavior, set the logical name C<DECC$EFS_CHARSET> to C<DISABLE>. - -=item * - -Fix linking on builds configured with -Dusemymalloc=y. - -=item * - -It should now be possible to compile Perl as C++ on VMS. - -=item * - -All C header files from the top-level directory of the distribution are now -installed on VMS, providing consistency with a long-standing practice on other -platforms. Previously only a subset were installed, which broke non-core -extension builds for extensions that depended on the missing include files. - -=item * - -Quotes are now removed from the command verb (but not the parameters) for -commands spawned via C<system>, backticks, or a piped C<open>. Previously, -quotes on the verb were passed through to DCL, which would fail to recognize -the command. Also, if the verb is actually a path to an image or command -procedure on an ODS-5 volume, quoting it now allows the path to contain spaces. - -=item * - -The B<a2p> build has been fixed for the HP C++ compiler on OpenVMS. - -=back - -=head3 Win32 - -=over - -=item * - -Perl can now be built using Microsoft's Visual C++ 2012 compiler by specifying -CCTYPE=MSVC110 (or MSVC110FREE if you are using the free Express edition for -Windows Desktop) in F<win32/Makefile>. - -=item * - -The option to build without USE_SOCKETS_AS_HANDLES has been removed. - -=item * - -Fixed a problem where perl could crash while cleaning up threads (including the -main thread) in threaded debugging builds on Win32 and possibly other platforms -[perl #114496]. - -=item * - -A rare race condition that would lead to L<sleep|perlfunc/sleep> taking more -time than requested, and possibly even hanging, has been fixed [perl #33096]. - -=item * - -C<link> on Win32 now attempts to set C<$!> to more appropriate values -based on the Win32 API error code. [perl #112272] - -Perl no longer mangles the environment block, e.g. when launching a new -sub-process, when the environment contains non-ASCII characters. Known -problems still remain, however, when the environment contains characters -outside of the current ANSI codepage (e.g. see the item about Unicode in -C<%ENV> in L<http://perl5.git.perl.org/perl.git/blob/HEAD:/Porting/todo.pod>). -[perl #113536] - -=item * - -Building perl with some Windows compilers used to fail due to a problem -with miniperl's C<glob> operator (which uses the C<perlglob> program) -deleting the PATH environment variable [perl #113798]. - -=item * - -A new makefile option, USE_64_BIT_INT, has been added to the Windows -makefiles. Set this to "define" when building a 32-bit perl if you want -it to use 64-bit integers. - -Machine code size reductions, already made to the DLLs of XS modules in -Perl 5.17.2, have now been extended to the perl DLL itself. - -Building with VC++ 6.0 was inadvertently broken in Perl 5.17.2 but has -now been fixed again. - -=back - -=head3 WinCE - -Building on WinCE is now possible once again, although more work is required -to fully restore a clean build. - -=head1 Internal Changes - -=over - -=item * - -Synonyms for the misleadingly named C<av_len()> has been created: -C<av_top_index()> and C<av_tindex>. All three of these return the -number of the highest index in the array, not the number of elements it -contains. - -=item * - -SvUPGRADE() is no longer an expression. Originally this macro (and its -underlying function, sv_upgrade()) were documented as boolean, although -in reality they always croaked on error and never returned false. In 2005 -the documentation was updated to specify a void return value, but -SvUPGRADE() was left always returning 1 for backwards compatibility. This -has now been removed, and SvUPGRADE() is now a statement with no return -value. - -So this is now a syntax error: - - if (!SvUPGRADE(sv)) { croak(...); } - -If you have code like that, simply replace it with - - SvUPGRADE(sv); - -or to to avoid compiler warnings with older perls, possibly - - (void)SvUPGRADE(sv); - -=item * - -Perl has a new copy-on-write mechanism that allows any SvPOK scalar to be -upgraded to a copy-on-write scalar. A reference count on the string buffer -is stored in the string buffer itself. - -This breaks a few XS modules by allowing copy-on-write scalars to go -through code paths that never encountered them before. - -This behaviour can still be disabled by running F<Configure> with -B<-Accflags=-DPERL_NO_COW>. This option will probably be removed in Perl -5.20. - -=item * - -Copy-on-write no longer uses the SvFAKE and SvREADONLY flags. Hence, -SvREADONLY indicates a true read-only SV. - -Use the SvIsCOW macro (as before) to identify a copy-on-write scalar. - -=item * - -PL_glob_index is gone. - -=item * - -The private Perl_croak_no_modify has had its context parameter removed. It is -now has a void prototype. Users of the public API croak_no_modify remain -unaffected. - -=item * - -Copy-on-write (shared hash key) scalars are no longer marked read-only. -C<SvREADONLY> returns false on such an SV, but C<SvIsCOW> still returns -true. - -=item * - -A new op type, C<OP_PADRANGE> has been introduced. The perl peephole -optimiser will, where possible, substitute a single padrange op for a -pushmark followed by one or more pad ops, and possibly also skipping list -and nextstate ops. In addition, the op can carry out the tasks associated -with the RHS of a my(...) = @_ assignment, so those ops may be optimised -away too. - -=item * - -Case-insensitive matching inside a [bracketed] character class with a -multi-character fold no longer excludes one of the possibilities in the -circumstances that it used to. [perl #89774]. - -=item * - -C<PL_formfeed> has been removed. - -=item * - -The regular expression engine no longer reads one byte past the end of the -target string. While for all internally well-formed scalars this should -never have been a problem, this change facilitates clever tricks with -string buffers in CPAN modules. [perl #73542] - -=item * - -Inside a BEGIN block, C<PL_compcv> now points to the currently-compiling -subroutine, rather than the BEGIN block itself. - -=item * - -C<mg_length> has been deprecated. - -=item * - -C<sv_len> now always returns a byte count and C<sv_len_utf8> a character -count. Previously, C<sv_len> and C<sv_len_utf8> were both buggy and would -sometimes returns bytes and sometimes characters. C<sv_len_utf8> no longer -assumes that its argument is in UTF8. Neither of these creates UTF8 caches -for tied or overloaded values or for non-PVs any more. - -=item * - -C<sv_mortalcopy> now copies string buffers of shared hash key scalars when -called from XS modules [perl #79824]. - -=item * - -C<RXf_SPLIT> and C<RXf_SKIPWHITE> are no longer used. They are now -#defined as 0. - -=item * - -The new C<RXf_MODIFIES_VARS> flag can be set by custom regular expression -engines to indicate that the execution of the regular expression may cause -variables to be modified. This lets C<s///> know to skip certain -optimisations. Perl's own regular expression engine sets this flag for the -special backtracking verbs that set $REGMARK and $REGERROR. - -=item * - -The APIs for accessing lexical pads have changed considerably. - -C<PADLIST>s are now longer C<AV>s, but their own type instead. -C<PADLIST>s now contain a C<PAD> and a C<PADNAMELIST> of C<PADNAME>s, -rather than C<AV>s for the pad and the list of pad names. C<PAD>s, -C<PADNAMELIST>s, and C<PADNAME>s are to be accessed as such through the -newly added pad API instead of the plain C<AV> and C<SV> APIs. See -L<perlapi> for details. - -=item * - -In the regex API, the numbered capture callbacks are passed an index -indicating what match variable is being accessed. There are special -index values for the C<$`, $&, $&> variables. Previously the same three -values were used to retrieve C<${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}> -too, but these have now been assigned three separate values. See -L<perlreapi/Numbered capture callbacks>. - -=item * - -C<PL_sawampersand> was previously a boolean indicating that any of -C<$`, $&, $&> had been seen; it now contains three one-bit flags -indicating the presence of each of the variables individually. - -=item * - -The C<CV *> typemap entry now supports C<&{}> overloading and typeglobs, -just like C<&{...}> [perl #96872]. - -=item * - -The C<SVf_AMAGIC> flag to indicate overloading is now on the stash, not the -object. It is now set automatically whenever a method or @ISA changes, so -its meaning has changed, too. It now means "potentially overloaded". When -the overload table is calculated, the flag is automatically turned off if -there is no overloading, so there should be no noticeable slowdown. - -The staleness of the overload tables is now checked when overload methods -are invoked, rather than during C<bless>. - -"A" magic is gone. The changes to the handling of the C<SVf_AMAGIC> flag -eliminate the need for it. - -C<PL_amagic_generation> has been removed as no longer necessary. For XS -modules, it is now a macro alias to C<PL_na>. - -The fallback overload setting is now stored in a stash entry separate from -overloadedness itself. - -=item * - -The character-processing code has been cleaned up in places. The changes -should be operationally invisible. - -=item * - -The C<study> function was made a no-op in 5.16. It was simply disabled via -a C<return> statement; the code was left in place. Now the code supporting -what C<study> used to do has been removed. - -=item * - -Under threaded perls, there is no longer a separate PV allocated for every -COP to store its package name (C<< cop->stashpv >>). Instead, there is an -offset (C<< cop->stashoff >>) into the new C<PL_stashpad> array, which -holds stash pointers. - -=item * - -In the pluggable regex API, the C<regexp_engine> struct has acquired a new -field C<op_comp>, which is currently just for perl's internal use, and -should be initialised to NULL by other regex plugin modules. - -=item * - -A new function C<alloccoptash> has been added to the API, but is considered -experimental. See L<perlapi>. - -=item * - -Perl used to implement get magic in a way that would sometimes hide bugs in -code could call mg_get() too many times on magical values. This hiding of -errors no longer occurs, so long-standing bugs may become visible now. If -you see magic-related errors in XS code, check to make sure it, together -with the Perl API functions it uses, calls mg_get() only once on SvGMAGICAL() -values. - -=item * - -OP allocation for CVs now uses a slab allocator. This simplifies -memory management for OPs allocated to a CV, so cleaning up after a -compilation error is simpler and safer [perl #111462][perl #112312]. - -=item * - -PERL_DEBUG_READONLY_OPS has been rewritten to work with the new slab -allocator, allowing it to catch more violations than before. - -=item * - -The old slab allocator for ops, which was only enabled for PERL_IMPLICIT_SYS -and PERL_DEBUG_READONLY_OPS, has been retired. - -=back - -=head1 Selected Bug Fixes - -=over 4 - -=item * - -Here-doc terminators no longer require a terminating newline character when -they occur at the end of a file. This was already the case at the end of a -string eval [perl #65838]. - -=item * - --DPERL_GLOBAL_STRUCT builds now free the global struct B<after> -they've finished using it. - -=item * - -A trailing '/' on a path in @INC will no longer have an additional '/' -appended. - -=item * - -The C<:crlf> layer now works when unread data doesn't fit into its own -buffer. [perl #112244]. - -=item * - -C<ungetc()> now handles UTF-8 encoded data. [perl #116322]. - -=item * - -A bug in the core typemap caused any C types that map to the T_BOOL core -typemap entry to not be set, updated, or modified when the T_BOOL variable was -used in an OUTPUT: section with an exception for RETVAL. T_BOOL in an INPUT: -section was not affected. Using a T_BOOL return type for an XSUB (RETVAL) -was not affected. A side effect of fixing this bug is, if a T_BOOL is specified -in the OUTPUT: section (which previous did nothing to the SV), and a read only -SV (literal) is passed to the XSUB, croaks like "Modification of a read-only -value attempted" will happen. [perl #115796] - -=item * - -On many platforms, providing a directory name as the script name caused perl -to do nothing and report success. It should now universally report an error -and exit nonzero. [perl #61362] - -=item * - -C<sort {undef} ...> under fatal warnings no longer crashes. It had -begun crashing in Perl 5.16. - -=item * - -Stashes blessed into each other -(C<bless \%Foo::, 'Bar'; bless \%Bar::, 'Foo'>) no longer result in double -frees. This bug started happening in Perl 5.16. - -=item * - -Numerous memory leaks have been fixed, mostly involving fatal warnings and -syntax errors. - -=item * - -Some failed regular expression matches such as C<'f' =~ /../g> were not -resetting C<pos>. Also, "match-once" patterns (C<m?...?g>) failed to reset -it, too, when invoked a second time [perl #23180]. - -=item * - -Accessing C<$&> after a pattern match now works if it had not been seen -before the match. I.e., this applies to C<${'&'}> (under C<no strict>) and -C<eval '$&'>. The same applies to C<$'> and C<$`> [perl #4289]. - -=item * - -Several bugs involving C<local *ISA> and C<local *Foo::> causing stale -MRO caches have been fixed. - -=item * - -Defining a subroutine when its typeglob has been aliased no longer results -in stale method caches. This bug was introduced in Perl 5.10. - -=item * - -Localising a typeglob containing a subroutine when the typeglob's package -has been deleted from its parent stash no longer produces an error. This -bug was introduced in Perl 5.14. - -=item * - -Under some circumstances, C<local *method=...> would fail to reset method -caches upon scope exit. - -=item * - -C</[.foo.]/> is no longer an error, but produces a warning (as before) and -is treated as C</[.fo]/> [perl #115818]. - -=item * - -C<goto $tied_var> now calls FETCH before deciding what type of goto -(subroutine or label) this is. - -=item * - -Renaming packages through glob assignment -(C<*Foo:: = *Bar::; *Bar:: = *Baz::>) in combination with C<m?...?> and -C<reset> no longer makes threaded builds crash. - -=item * - -A number of bugs related to assigning a list to hash have been fixed. Many of -these involve lists with repeated keys like C<(1, 1, 1, 1)>. - -=over 4 - -=item * - -The expression C<scalar(%h = (1, 1, 1, 1))> now returns C<4>, not C<2>. - -=item * - -The return value of C<%h = (1, 1, 1)> in list context was wrong. Previously -this would return C<(1, undef, 1)>, now it returns C<(1, undef)>. - -=item * - -Perl now issues the same warning on C<($s, %h) = (1, {})> as it does for -C<(%h) = ({})>, "Reference found where even-sized list expected". - -=item * - -A number of additional edge cases in list assignment to hashes were -corrected. For more details see commit 23b7025ebc. - -=back - -=item * - -Attributes applied to lexical variables no longer leak memory. -[perl #114764] - -=item * - -C<dump>, C<goto>, C<last>, C<next>, C<redo> or C<require> followed by a -bareword (or version) and then an infix operator is no longer a syntax -error. It used to be for those infix operators (like C<+>) that have a -different meaning where a term is expected. [perl #105924] - -=item * - -C<require a::b . 1> and C<require a::b + 1> no longer produce erroneous -ambiguity warnings. [perl #107002] - -=item * - -Class method calls are now allowed on any string, and not just strings -beginning with an alphanumeric character. [perl #105922] - -=item * - -An empty pattern created with C<qr//> used in C<m///> no longer triggers -the "empty pattern reuses last pattern" behaviour. [perl #96230] - -=item * - -Tying a hash during iteration no longer results in a memory leak. - -=item * - -Freeing a tied hash during iteration no longer results in a memory leak. - -=item * - -List assignment to a tied array or hash that dies on STORE no longer -results in a memory leak. - -=item * - -If the hint hash (C<%^H>) is tied, compile-time scope entry (which copies -the hint hash) no longer leaks memory if FETCH dies. [perl #107000] - -=item * - -Constant folding no longer inappropriately triggers the special -C<split " "> behaviour. [perl #94490] - -=item * - -C<defined scalar(@array)>, C<defined do { &foo }>, and similar constructs -now treat the argument to C<defined> as a simple scalar. [perl #97466] - -=item * - -Running a custom debugging that defines no C<*DB::DB> glob or provides a -subroutine stub for C<&DB::DB> no longer results in a crash, but an error -instead. [perl #114990] - -=item * - -C<reset ""> now matches its documentation. C<reset> only resets C<m?...?> -patterns when called with no argument. An empty string for an argument now -does nothing. (It used to be treated as no argument.) [perl #97958] - -=item * - -C<printf> with an argument returning an empty list no longer reads past the -end of the stack, resulting in erratic behaviour. [perl #77094] - -=item * - -C<--subname> no longer produces erroneous ambiguity warnings. -[perl #77240] - -=item * - -C<v10> is now allowed as a label or package name. This was inadvertently -broken when v-strings were added in Perl 5.6. [perl #56880] - -=item * - -C<length>, C<pos>, C<substr> and C<sprintf> could be confused by ties, -overloading, references and typeglobs if the stringification of such -changed the internal representation to or from UTF8. [perl #114410] - -=item * - -utf8::encode now calls FETCH and STORE on tied variables. utf8::decode now -calls STORE (it was already calling FETCH). - -=item * - -C<$tied =~ s/$non_utf8/$utf8/> no longer loops infinitely if the tied -variable returns a Latin-1 string, shared hash key scalar, or reference or -typeglob that stringifies as ASCII or Latin-1. This is a regression from -5.12.x. - -=item * - -C<s///> without /e is now better at detecting when it needs to forego -certain optimisations, fixing some buggy cases: - -=over - -=item * - -Match variables in certain constructs (C<&&>, C<||>, C<..> and others) in -the replacement part; e.g., C<s/(.)/$l{$a||$1}/g>. [perl #26986] - -=item * - -Aliases to match variables in the replacement. - -=item * - -C<$REGERROR> or C<$REGMARK> in the replacement. [perl #49190] - -=item * - -An empty pattern (C<s//$foo/>) that causes the last-successful pattern to -be used, when that pattern contains code blocks that modify the variables -in the replacement. - -=back - -=item * - -The taintedness of the replacement string no longer affects the taintedness -of the return value of C<s///e>. - -=item * - -The C<$|> autoflush variable is created on-the-fly when needed. If this -happened (e.g., if it was mentioned in a module or eval) when the -currently-selected filehandle was a typeglob with an empty IO slot, it used -to crash. [perl #115206] - -=item * - -Line numbers at the end of a string eval are no longer off by one. -[perl #114658] - -=item * - -@INC filters (subroutines returned by subroutines in @INC) that set $_ to a -copy-on-write scalar no longer cause the parser to modify that string -buffer in place. - -=item * - -C<length($object)> no longer returns the undefined value if the object has -string overloading that returns undef. [perl #115260] - -=item * - -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 -carried on working without it. - -=item * - -The error "Can't localize through a reference" had disappeared in 5.16.0 -when C<local %$ref> appeared on the last line of an lvalue subroutine. -This error disappeared for C<\local %$ref> in perl 5.8.1. It has now -been restored. - -=item * - -The parsing of here-docs has been improved significantly, fixing several -parsing bugs and crashes and one memory leak, and correcting wrong -subsequent line numbers under certain conditions. - -=item * - -Inside an eval, the error message for an unterminated here-doc no longer -has a newline in the middle of it [perl #70836]. - -=item * - -A substitution inside a substitution pattern (C<s/${s|||}//>) no longer -confuses the parser. - -=item * - -It may be an odd place to allow comments, but C<s//"" # hello/e> has -always worked, I<unless> there happens to be a null character before the -first #. Now it works even in the presence of nulls. - -=item * - -An invalid range in C<tr///> or C<y///> no longer results in a memory leak. - -=item * - -String eval no longer treats a semicolon-delimited quote-like operator at -the very end (C<eval 'q;;'>) as a syntax error. - -=item * - -C<< warn {$_ => 1} + 1 >> is no longer a syntax error. The parser used to -get confused with certain list operators followed by an anonymous hash and -then an infix operator that shares its form with a unary operator. - -=item * - -C<(caller $n)[6]> (which gives the text of the eval) used to return the -actual parser buffer. Modifying it could result in crashes. Now it always -returns a copy. The string returned no longer has "\n;" tacked on to the -end. The returned text also includes here-doc bodies, which used to be -omitted. - -=item * - -Reset the utf8 position cache when accessing magical variables to avoid the -string buffer and the utf8 position cache getting out of sync -[perl #114410]. - -=item * - -Various cases of get magic being called twice for magical utf8 strings have been -fixed. - -=item * - -This code (when not in the presence of C<$&> etc) - - $_ = 'x' x 1_000_000; - 1 while /(.)/; - -used to skip the buffer copy for performance reasons, but suffered from C<$1> -etc changing if the original string changed. That's now been fixed. - -=item * - -Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO -might attempt to allocate more memory. - -=item * - -In a regular expression, if something is quantified with C<{n,m}> where -C<S<n E<gt> m>>, it can't possibly match. Previously this was a fatal -error, but now is merely a warning (and that something won't match). -[perl #82954]. - -=item * - -It used to be possible for formats defined in subroutines that have -subsequently been undefined and redefined to close over variables in the -wrong pad (the newly-defined enclosing sub), resulting in crashes or -"Bizarre copy" errors. - -=item * - -Redefinition of XSUBs at run time could produce warnings with the wrong -line number. - -=item * - -The %vd sprintf format does not support version objects for alpha versions. -It used to output the format itself (%vd) when passed an alpha version, and -also emit an "Invalid conversion in printf" warning. It no longer does, -but produces the empty string in the output. It also no longer leaks -memory in this case. - -=item * - -C<< $obj->SUPER::method >> calls in the main package could fail if the -SUPER package had already been accessed by other means. - -=item * - -Stash aliasing (C<*foo:: = *bar::>) no longer causes SUPER calls to ignore -changes to methods or @ISA or use the wrong package. - -=item * - -Method calls on packages whose names end in ::SUPER are no longer treated -as SUPER method calls, resulting in failure to find the method. -Furthermore, defining subroutines in such packages no longer causes them to -be found by SUPER method calls on the containing package [perl #114924]. - -=item * - -C<\w> now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D -(ZERO WIDTH JOINER). C<\W> no longer matches these. This change is because -Unicode corrected their definition of what C<\w> should match. - -=item * - -C<dump LABEL> no longer leaks its label. - -=item * - -Constant folding no longer changes the behaviour of functions like C<stat()> -and C<truncate()> that can take either filenames or handles. -C<stat 1 ? foo : bar> nows treats its argument as a file name (since it is an -arbitrary expression), rather than the handle "foo". - -=item * - -C<truncate FOO, $len> no longer falls back to treating "FOO" as a file name if -the filehandle has been deleted. This was broken in Perl 5.16.0. - -=item * - -Subroutine redefinitions after sub-to-glob and glob-to-glob assignments no -longer cause double frees or panic messages. - -=item * - -C<s///> now turns vstrings into plain strings when performing a substitution, -even if the resulting string is the same (C<s/a/a/>). - -=item * - -Prototype mismatch warnings no longer erroneously treat constant subs as having -no prototype when they actually have "". - -=item * - -Constant subroutines and forward declarations no longer prevent prototype -mismatch warnings from omitting the sub name. - -=item * - -C<undef> on a subroutine now clears call checkers. - -=item * - -The C<ref> operator started leaking memory on blessed objects in Perl 5.16.0. -This has been fixed [perl #114340]. - -=item * - -C<use> no longer tries to parse its arguments as a statement, making -C<use constant { () };> a syntax error [perl #114222]. - -=item * - -On debugging builds, "uninitialized" warnings inside formats no longer cause -assertion failures. - -=item * - -On debugging builds, subroutines nested inside formats no longer cause -assertion failures [perl #78550]. - -=item * - -Formats and C<use> statements are now permitted inside formats. - -=item * - -C<print $x> and C<sub { print $x }-E<gt>()> now always produce the same output. -It was possible for the latter to refuse to close over $x if the variable was -not active; e.g., if it was defined outside a currently-running named -subroutine. - -=item * - -Similarly, C<print $x> and C<print eval '$x'> now produce the same output. -This also allows "my $x if 0" variables to be seen in the debugger [perl -#114018]. - -=item * - -Formats called recursively no longer stomp on their own lexical variables, but -each recursive call has its own set of lexicals. - -=item * - -Attempting to free an active format or the handle associated with it no longer -results in a crash. - -=item * - -Format parsing no longer gets confused by braces, semicolons and low-precedence -operators. It used to be possible to use braces as format delimiters (instead -of C<=> and C<.>), but only sometimes. Semicolons and low-precedence operators -in format argument lines no longer confuse the parser into ignoring the line's -return value. In format argument lines, braces can now be used for anonymous -hashes, instead of being treated always as C<do> blocks. - -=item * - -Formats can now be nested inside code blocks in regular expressions and other -quoted constructs (C</(?{...})/> and C<qq/${...}/>) [perl #114040]. - -=item * - -Formats are no longer created after compilation errors. - -=item * - -Under debugging builds, the B<-DA> command line option started crashing in Perl -5.16.0. It has been fixed [perl #114368]. - -=item * - -A potential deadlock scenario involving the premature termination of a pseudo- -forked child in a Windows build with ithreads enabled has been fixed. This -resolves the common problem of the F<t/op/fork.t> test hanging on Windows [perl -#88840]. - -=item * - -The microperl build, broken since Perl 5.15.7, has now been restored. - -=item * - -The code which generates errors from C<require()> could potentially read one or -two bytes before the start of the filename for filenames less than three bytes -long and ending C</\.p?\z/>. This has now been fixed. Note that it could -never have happened with module names given to C<use()> or C<require()> anyway. - -=item * - -The handling of pathnames of modules given to C<require()> has been made -thread-safe on VMS. - -=item * - -A bug in the compilation of a C</(?{})/> expression which affected the TryCatch -test suite has been fixed [perl #114242]. - -=item * - -Pod can now be nested in code inside a quoted construct outside of a string -eval. This used to work only within string evals [perl #114040]. - -=item * - -C<goto ''> now looks for an empty label, producing the "goto must have -label" error message, instead of exiting the program [perl #111794]. - -=item * - -C<goto "\0"> now dies with "Can't find label" instead of "goto must have -label". - -=item * - -The C function C<hv_store> used to result in crashes when used on C<%^H> -[perl #111000]. - -=item * - -A call checker attached to a closure prototype via C<cv_set_call_checker> -is now copied to closures cloned from it. So C<cv_set_call_checker> now -works inside an attribute handler for a closure. - -=item * - -Writing to C<$^N> used to have no effect. Now it croaks with "Modification -of a read-only value" by default, but that can be overridden by a custom -regular expression engine, as with C<$1> [perl #112184]. - -=item * - -C<undef> on a control character glob (C<undef *^H>) no longer emits an -erroneous warning about ambiguity [perl #112456]. - -=item * - -For efficiency's sake, many operators and built-in functions return the -same scalar each time. Lvalue subroutines and subroutines in the CORE:: -namespace were allowing this implementation detail to leak through. -C<print &CORE::uc("a"), &CORE::uc("b")> used to print "BB". The same thing -would happen with an lvalue subroutine returning the return value of C<uc>. -Now the value is copied in such cases. - -=item * - -C<method {}> syntax with an empty block or a block returning an empty list -used to crash or use some random value left on the stack as its invocant. -Now it produces an error. - -=item * - -C<vec> now works with extremely large offsets (E<gt>2 GB) [perl #111730]. - -=item * - -Changes to overload settings now take effect immediately, as do changes to -inheritance that affect overloading. They used to take effect only after -C<bless>. - -Objects that were created before a class had any overloading used to remain -non-overloaded even if the class gained overloading through C<use overload> -or @ISA changes, and even after C<bless>. This has been fixed -[perl #112708]. - -=item * - -Classes with overloading can now inherit fallback values. - -=item * - -Overloading was not respecting a fallback value of 0 if there were -overloaded objects on both sides of an assignment operator like C<+=> -[perl #111856]. - -=item * - -C<pos> now croaks with hash and array arguments, instead of producing -erroneous warnings. - -=item * - -C<while(each %h)> now implies C<while(defined($_ = each %h))>, like -C<readline> and C<readdir>. - -=item * - -Subs in the CORE:: namespace no longer crash after C<undef *_> when called -with no argument list (C<&CORE::time> with no parentheses). - -=item * - -C<unpack> no longer produces the "'/' must follow a numeric type in unpack" -error when it is the data that are at fault [perl #60204]. - -=item * - -C<join> and C<"@array"> now call FETCH only once on a tied C<$"> -[perl #8931]. - -=item * - -Some subroutine calls generated by compiling core ops affected by a -C<CORE::GLOBAL> override had op checking performed twice. The checking -is always idempotent for pure Perl code, but the double checking can -matter when custom call checkers are involved. - -=item * - -A race condition used to exist around fork that could cause a signal sent to -the parent to be handled by both parent and child. Signals are now blocked -briefly around fork to prevent this from happening [perl #82580]. - -=item * - -The implementation of code blocks in regular expressions, such as C<(?{})> -and C<(??{})>, has been heavily reworked to eliminate a whole slew of bugs. -The main user-visible changes are: - -=over 4 - -=item * - -Code blocks within patterns are now parsed in the same pass as the -surrounding code; in particular it is no longer necessary to have balanced -braces: this now works: - - /(?{ $x='{' })/ - -This means that this error message is no longer generated: - - Sequence (?{...}) not terminated or not {}-balanced in regex - -but a new error may be seen: - - Sequence (?{...}) not terminated with ')' - -In addition, literal code blocks within run-time patterns are only -compiled once, at perl compile-time: - - for my $p (...) { - # this 'FOO' block of code is compiled once, - # at the same time as the surrounding 'for' loop - /$p{(?{FOO;})/; - } - -=item * - -Lexical variables are now sane as regards scope, recursion and closure -behavior. In particular, C</A(?{B})C/> behaves (from a closure viewpoint) -exactly like C</A/ && do { B } && /C/>, while C<qr/A(?{B})C/> is like -C<sub {/A/ && do { B } && /C/}>. So this code now works how you might -expect, creating three regexes that match 0, 1, and 2: - - for my $i (0..2) { - push @r, qr/^(??{$i})$/; - } - "1" =~ $r[1]; # matches - -=item * - -The C<use re 'eval'> pragma is now only required for code blocks defined -at runtime; in particular in the following, the text of the C<$r> pattern is -still interpolated into the new pattern and recompiled, but the individual -compiled code-blocks within C<$r> are reused rather than being recompiled, -and C<use re 'eval'> isn't needed any more: - - my $r = qr/abc(?{....})def/; - /xyz$r/; - -=item * - -Flow control operators no longer crash. Each code block runs in a new -dynamic scope, so C<next> etc. will not see -any enclosing loops. C<return> returns a value -from the code block, not from any enclosing subroutine. - -=item * - -Perl normally caches the compilation of run-time patterns, and doesn't -recompile if the pattern hasn't changed, but this is now disabled if -required for the correct behavior of closures. For example: - - my $code = '(??{$x})'; - for my $x (1..3) { - # recompile to see fresh value of $x each time - $x =~ /$code/; - } - -=item * - -The C</msix> and C<(?msix)> etc. flags are now propagated into the return -value from C<(??{})>; this now works: - - "AB" =~ /a(??{'b'})/i; - -=item * - -Warnings and errors will appear to come from the surrounding code (or for -run-time code blocks, from an eval) rather than from an C<re_eval>: - - use re 'eval'; $c = '(?{ warn "foo" })'; /$c/; - /(?{ warn "foo" })/; - -formerly gave: - - foo at (re_eval 1) line 1. - foo at (re_eval 2) line 1. - -and now gives: - - foo at (eval 1) line 1. - foo at /some/prog line 2. - -=back - -=item * - -Perl now works as well as can be expected on all releases of Unicode so -far. In v5.16, it worked on Unicodes 6.0 and 6.1, but there were -various bugs for earlier releases; the older the release the more -problems. - -=item * - -C<vec> no longer produces "uninitialized" warnings in lvalue context -[perl #9423]. - -=item * - -An optimization involving fixed strings in regular expressions could cause -a severe performance penalty in edge cases. This has been fixed -[perl #76546]. - -=item * - -In certain cases, including empty subpatterns within a regular expression (such -as C<(?:)> or C<(?:|)>) could disable some optimizations. This has been fixed. - -=item * - -The "Can't find an opnumber" message that C<prototype> produces when passed -a string like "CORE::nonexistent_keyword" now passes UTF-8 and embedded -NULs through unchanged [perl #97478]. - -=item * - -C<prototype> now treats magical variables like C<$1> the same way as -non-magical variables when checking for the CORE:: prefix, instead of -treating them as subroutine names. - -=item * - -Under threaded perls, a runtime code block in a regular expression could -corrupt the package name stored in the op tree, resulting in bad reads -in C<caller>, and possibly crashes [perl #113060]. - -=item * - -Referencing a closure prototype (C<\&{$_[1]}> in an attribute handler for a -closure) no longer results in a copy of the subroutine (or assertion -failures on debugging builds). - -=item * - -C<eval '__PACKAGE__'> now returns the right answer on threaded builds if -the current package has been assigned over (as in -C<*ThisPackage:: = *ThatPackage::>) [perl #78742]. - -=item * - -If a package is deleted by code that it calls, it is possible for C<caller> -to see a stack frame belonging to that deleted package. C<caller> could -crash if the stash's memory address was reused for a scalar and a -substitution was performed on the same scalar [perl #113486]. - -=item * - -C<UNIVERSAL::can> no longer treats its first argument differently -depending on whether it is a string or number internally. - -=item * - -C<open> with C<< <& >> for the mode checks to see whether the third argument is -a number, in determining whether to treat it as a file descriptor or a handle -name. Magical variables like C<$1> were always failing the numeric check and -being treated as handle names. - -=item * - -C<warn>'s handling of magical variables (C<$1>, ties) has undergone several -fixes. C<FETCH> is only called once now on a tied argument or a tied C<$@> -[perl #97480]. Tied variables returning objects that stringify as "" are -no longer ignored. A tied C<$@> that happened to return a reference the -I<previous> time it was used is no longer ignored. - -=item * - -C<warn ""> now treats C<$@> with a number in it the same way, regardless of -whether it happened via C<$@=3> or C<$@="3">. It used to ignore the -former. Now it appends "\t...caught", as it has always done with -C<$@="3">. - -=item * - -Numeric operators on magical variables (e.g., S<C<$1 + 1>>) used to use -floating point operations even where integer operations were more appropriate, -resulting in loss of accuracy on 64-bit platforms [perl #109542]. - -=item * - -Unary negation no longer treats a string as a number if the string happened -to be used as a number at some point. So, if C<$x> contains the string "dogs", -C<-$x> returns "-dogs" even if C<$y=0+$x> has happened at some point. - -=item * - -In Perl 5.14, C<-'-10'> was fixed to return "10", not "+10". But magical -variables (C<$1>, ties) were not fixed till now [perl #57706]. - -=item * - -Unary negation now treats strings consistently, regardless of the internal -C<UTF8> flag. - -=item * - -A regression introduced in Perl v5.16.0 involving -C<tr/I<SEARCHLIST>/I<REPLACEMENTLIST>/> has been fixed. Only the first -instance is supposed to be meaningful if a character appears more than -once in C<I<SEARCHLIST>>. Under some circumstances, the final instance -was overriding all earlier ones. [perl #113584] - -=item * - -Regular expressions like C<qr/\87/> previously silently inserted a NUL -character, thus matching as if it had been written C<qr/\00087/>. Now it -matches as if it had been written as C<qr/87/>, with a message that the -sequence C<"\8"> is unrecognized. - -=item * - -C<__SUB__> now works in special blocks (C<BEGIN>, C<END>, etc.). - -=item * - -Thread creation on Windows could theoretically result in a crash if done -inside a C<BEGIN> block. It still does not work properly, but it no longer -crashes [perl #111610]. - -=item * - -C<\&{''}> (with the empty string) now autovivifies a stub like any other -sub name, and no longer produces the "Unable to create sub" error -[perl #94476]. - -=item * - -A regression introduced in v5.14.0 has been fixed, in which some calls -to the C<re> module would clobber C<$_> [perl #113750]. - -=item * - -C<do FILE> now always either sets or clears C<$@>, even when the file can't be -read. This ensures that testing C<$@> first (as recommended by the -documentation) always returns the correct result. - -=item * - -The array iterator used for the C<each @array> construct is now correctly -reset when C<@array> is cleared (RT #75596). This happens for example when the -array is globally assigned to, as in C<@array = (...)>, but not when its -B<values> are assigned to. In terms of the XS API, it means that C<av_clear()> -will now reset the iterator. - -This mirrors the behaviour of the hash iterator when the hash is cleared. - -=item * - -C<< $class->can >>, C<< $class->isa >>, and C<< $class->DOES >> now return -correct results, regardless of whether that package referred to by C<$class> -exists [perl #47113]. - -=item * - -Arriving signals no longer clear C<$@> [perl #45173]. - -=item * - -Allow C<my ()> declarations with an empty variable list [perl #113554]. - -=item * - -During parsing, subs declared after errors no longer leave stubs -[perl #113712]. - -=item * - -Closures containing no string evals no longer hang on to their containing -subroutines, allowing variables closed over by outer subroutines to be -freed when the outer sub is freed, even if the inner sub still exists -[perl #89544]. - -=item * - -Duplication of in-memory filehandles by opening with a "<&=" or ">&=" mode -stopped working properly in 5.16.0. It was causing the new handle to -reference a different scalar variable. This has been fixed [perl #113764]. - -=item * - -C<qr//> expressions no longer crash with custom regular expression engines -that do not set C<offs> at regular expression compilation time -[perl #112962]. - -=item * - -C<delete local> no longer crashes with certain magical arrays and hashes -[perl #112966]. - -=item * - -C<local> on elements of certain magical arrays and hashes used not to -arrange to have the element deleted on scope exit, even if the element did -not exist before C<local>. - -=item * - -C<scalar(write)> no longer returns multiple items [perl #73690]. - -=item * - -String to floating point conversions no longer misparse certain strings under -C<use locale> [perl #109318]. - -=item * - -C<@INC> filters that die no longer leak memory [perl #92252]. - -=item * - -The implementations of overloaded operations are now called in the correct -context. This allows, among other things, being able to properly override -C<< <> >> [perl #47119]. - -=item * - -Specifying only the C<fallback> key when calling C<use overload> now behaves -properly [perl #113010]. - -=item * - -C<< sub foo { my $a = 0; while ($a) { ... } } >> and -C<< sub foo { while (0) { ... } } >> now return the same thing [perl #73618]. - -=item * - -String negation now behaves the same under C<use integer;> as it does -without [perl #113012]. - -=item * - -C<chr> now returns the Unicode replacement character (U+FFFD) for -1, -regardless of the internal representation. -1 used to wrap if the argument -was tied or a string internally. - -=item * - -Using a C<format> after its enclosing sub was freed could crash as of -perl 5.12.0, if the format referenced lexical variables from the outer sub. - -=item * - -Using a C<format> after its enclosing sub was undefined could crash as of -perl 5.10.0, if the format referenced lexical variables from the outer sub. - -=item * - -Using a C<format> defined inside a closure, which format references -lexical variables from outside, never really worked unless the C<write> -call was directly inside the closure. In 5.10.0 it even started crashing. -Now the copy of that closure nearest the top of the call stack is used to -find those variables. - -=item * - -Formats that close over variables in special blocks no longer crash if a -stub exists with the same name as the special block before the special -block is compiled. - -=item * - -The parser no longer gets confused, treating C<eval foo ()> as a syntax -error if preceded by C<print;> [perl #16249]. - -=item * - -The return value of C<syscall> is no longer truncated on 64-bit platforms -[perl #113980]. - -=item * - -Constant folding no longer causes C<print 1 ? FOO : BAR> to print to the -FOO handle [perl #78064]. - -=item * - -C<do subname> now calls the named subroutine and uses the file name it -returns, instead of opening a file named "subname". - -=item * - -Subroutines looked up by rv2cv check hooks (registered by XS modules) are -now taken into consideration when determining whether C<foo bar> should be -the sub call C<foo(bar)> or the method call C<< "bar"->foo >>. - -=item * - -C<CORE::foo::bar> is no longer treated specially, allowing global overrides -to be called directly via C<CORE::GLOBAL::uc(...)> [perl #113016]. - -=item * - -Calling an undefined sub whose typeglob has been undefined now produces the -customary "Undefined subroutine called" error, instead of "Not a CODE -reference". - -=item * - -Two bugs involving @ISA have been fixed. C<*ISA = *glob_without_array> and -C<undef *ISA; @{*ISA}> would prevent future modifications to @ISA from -updating the internal caches used to look up methods. The -*glob_without_array case was a regression from Perl 5.12. - -=item * - -Regular expression optimisations sometimes caused C<$> with C</m> to -produce failed or incorrect matches [perl #114068]. - -=item * - -C<__SUB__> now works in a C<sort> block when the enclosing subroutine is -predeclared with C<sub foo;> syntax [perl #113710]. - -=item * - -Unicode properties only apply to Unicode code points, which leads to -some subtleties when regular expressions are matched against -above-Unicode code points. There is a warning generated to draw your -attention to this. However, this warning was being generated -inappropriately in some cases, such as when a program was being parsed. -Non-Unicode matches such as C<\w> and C<[:word;]> should not generate the -warning, as their definitions don't limit them to apply to only Unicode -code points. Now the message is only generated when matching against -C<\p{}> and C<\P{}>. There remains a bug, [perl #114148], for the very -few properties in Unicode that match just a single code point. The -warning is not generated if they are matched against an above-Unicode -code point. - -=item * - -Uninitialized warnings mentioning hash elements would only mention the -element name if it was not in the first bucket of the hash, due to an -off-by-one error. - -=item * - -A regular expression optimizer bug could cause multiline "^" to behave -incorrectly in the presence of line breaks, such that -C<"/\n\n" =~ m#\A(?:^/$)#im> would not match [perl #115242]. - -=item * - -Failed C<fork> in list context no longer corrupts the stack. -C<@a = (1, 2, fork, 3)> used to gobble up the 2 and assign C<(1, undef, 3)> -if the C<fork> call failed. - -=item * - -Numerous memory leaks have been fixed, mostly involving tied variables that -die, regular expression character classes and code blocks, and syntax -errors. - -=item * - -Assigning a regular expression (C<${qr//}>) to a variable that happens to -hold a floating point number no longer causes assertion failures on -debugging builds. - -=item * - -Assigning a regular expression to a scalar containing a number no longer -causes subsequent nummification to produce random numbers. - -=item * - -Assigning a regular expression to a magic variable no longer wipes away the -magic. This is a regression from 5.10. - -=item * - -Assigning a regular expression to a blessed scalar no longer results in -crashes. This is also a regression from 5.10. - -=item * - -Regular expression can now be assigned to tied hash and array elements with -flattening into strings. - -=item * - -Nummifying a regular expression no longer results in an uninitialized -warning. - -=item * - -Negative array indices no longer cause EXISTS methods of tied variables to -be ignored. This is a regression from 5.12. - -=item * - -Negative array indices no longer result in crashes on arrays tied to -non-objects. - -=item * - -C<$byte_overload .= $utf8> no longer results in doubly-encoded UTF8 if the -left-hand scalar happened to have produced a UTF8 string the last time -overloading was invoked. - -=item * - -C<goto &sub> now uses the current value of @_, instead of using the array -the subroutine was originally called with. This means -C<local @_ = (...); goto &sub> now works [perl #43077]. - -=item * - -If a debugger is invoked recursively, it no longer stomps on its own -lexical variables. Formerly under recursion all calls would share the same -set of lexical variables [perl #115742]. - -=item * - -C<*_{ARRAY}> returned from a subroutine no longer spontaneously -becomes empty. - -=back - -=head1 Known Problems - -=over 4 - -=item * - -XXX: the imperfect behavior of the ** deprecation - -=back - -=head1 Acknowledgements - -XXX Generate this with: - - perl Porting/acknowledgements.pl v5.18.0..HEAD - -=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 -http://rt.perl.org/perlbug/ . There may also be information at -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 please send it -to perl5-security-report@perl.org. This points to a closed subscription -unarchived mailing list, which includes all the core committers, who will be -able to help assess the impact of issues, figure out a resolution, and help -co-ordinate the release of patches to mitigate or fix the problem across all -platforms on which Perl is supported. Please only use this address for -security issues in the Perl core, not for modules independently distributed on -CPAN. - -=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 |