diff options
author | Ricardo Signes <rjbs@cpan.org> | 2015-05-06 07:42:32 -0400 |
---|---|---|
committer | Ricardo Signes <rjbs@cpan.org> | 2015-05-08 20:19:41 -0400 |
commit | eabfc7bc1932ffcb9e80fc4bdd4853e7f5b85c28 (patch) | |
tree | cb34ed0e525522262c2a1ba268e3bb64c08c3002 /pod | |
parent | bff00388f2dd2eb97cc67045e63380a6c56e22d1 (diff) | |
download | perl-eabfc7bc1932ffcb9e80fc4bdd4853e7f5b85c28.tar.gz |
perldelta is now the perl5220delta
Diffstat (limited to 'pod')
-rw-r--r-- | pod/.gitignore | 2 | ||||
-rw-r--r-- | pod/perldelta.pod | 3090 |
2 files changed, 2950 insertions, 142 deletions
diff --git a/pod/.gitignore b/pod/.gitignore index 1ef84951d0..e6a3ab34df 100644 --- a/pod/.gitignore +++ b/pod/.gitignore @@ -53,7 +53,7 @@ /roffitall # generated -/perl52112delta.pod +/perl5220delta.pod /perlapi.pod /perlintern.pod *.html diff --git a/pod/perldelta.pod b/pod/perldelta.pod index d1a5fc93ad..46b6b342ff 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -2,94 +2,662 @@ =head1 NAME -[ this is a template for a new perldelta file. Any text flagged as XXX needs -to be processed before release. ] - -perldelta - what is new for perl v5.21.12 +perldelta - what is new for perl v5.22.0 =head1 DESCRIPTION -This document describes differences between the 5.21.11 release and the 5.21.12 +This document describes differences between the 5.22.0 release and the 5.20.0 release. -If you are upgrading from an earlier release such as 5.21.10, first read -L<perl52111delta>, which describes differences between 5.21.10 and 5.21.11. +If you are upgrading from an earlier release such as 5.18.0, first read +L<perl5200delta>, which describes differences between 5.18.0 and 5.20.0. -=head1 Notice +=head1 Core Enhancements -XXX Any important notices here +=head2 New bitwise operators -=head1 Core Enhancements +A new experimental facility has been added that makes the four standard +bitwise operators (C<& | ^ ~>) treat their operands consistently as +numbers, and introduces four new dotted operators (C<&. |. ^. ~.>) that +treat their operands consistently as strings. The same applies to the +assignment variants (C<&= |= ^= &.= |.= ^.=>). + +To use this, enable the "bitwise" feature and disable the +"experimental::bitwise" warnings category. See L<perlop/Bitwise String +Operators> for details. [rt.perl.org #123466] + +=head2 New double-diamond operator + +C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open +each file in @ARGV. So each element of @ARGV is an actual file name, and +"|foo" won't be treated as a pipe open. + +=head2 New \b boundaries in regular expressions + +=head3 qr/\b{gcb}/ + +C<gcb> stands for Grapheme Cluster Boundary. It is a Unicode property +that finds the boundary between sequences of characters that look like a +single character to a native speaker of a language. Perl has long had +the ability to deal with these through the C<\X> regular escape +sequence. Now, there is an alternative way of handling these. See +L<perlrebackslash/\b{}, \b, \B{}, \B> for details. + +=head3 qr/\b{wb}/ + +C<wb> stands for Word Boundary. It is a Unicode property +that finds the boundary between words. This is similar to the plain +C<\b> (without braces) but is more suitable for natural language +processing. It knows, for example that apostrophes can occur in the +middle of words. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. + +=head3 qr/\b{sb}/ + +C<sb> stands for Sentence Boundary. It is a Unicode property +to aid in parsing natural language sentences. +See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. + +=head2 C<no re> covers more and is lexical + +Previously running C<no re> would only turn off a few things. Now it +turns off all the enabled things. For example, previously, you +couldn't turn off debugging, once enabled, inside the same block. + +=head2 Non-Capturing Regular Expression Flag + +Regular expressions now support a C</n> flag that disables capturing +and filling in C<$1>, C<$2>, etc... inside of groups: + + "hello" =~ /(hi|hello)/n; # $1 is not set + +This is equivalent to putting C<?:> at the beginning of every capturing group. + +See L<perlre/"n"> for more information. + +=head2 C<use re 'strict'> + +This applies stricter syntax rules to regular expression patterns +compiled within its scope, which hopefully will alert you to typos and +other unintentional behavior that backwards-compatibility issues prevent +us from doing in normal regular expression compilations. Because the +behavior of this is subject to change in future Perl releases as we gain +experience, using this pragma will raise a category +C<experimental::re_strict> warning. +See L<'strict' in re|re/'strict' mode>. + +=head2 C<qr/foo/x> now ignores any Unicode pattern white space + +The C</x> regular expression modifier allows the pattern to contain +white space and comments, both of which are ignored, for improved +readability. Until now, not all the white space characters that Unicode +designates for this purpose were handled. The additional ones now +recognized 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 Unicode 7.0 is now supported + +For details on what is in this release, see +L<http://www.unicode.org/versions/Unicode7.0.0/>. + +=head2 S<C<use locale>> can restrict which locale categories are affected + +It is now possible to pass a parameter to S<C<use locale>> to specify +a subset of locale categories to be locale-aware, with the remaining +ones unaffected. See L<perllocale/The "use locale" pragma> for details. + +=head2 Perl now supports POSIX 2008 locale currency additions. + +On platforms that are able to handle POSIX.1-2008, the +hash returned by +L<C<POSIX::localeconv()>|perllocale/The localeconv function> +includes the international currency fields added by that version of the +POSIX standard. These are +C<int_n_cs_precedes>, +C<int_n_sep_by_space>, +C<int_n_sign_posn>, +C<int_p_cs_precedes>, +C<int_p_sep_by_space>, +and +C<int_p_sign_posn>. + +=head2 Better heuristics on older platforms for determining locale UTF8ness + +On platforms that implement neither the C99 standard nor the POSIX 2001 +standard, determining if the current locale is UTF8 or not depends on +heuristics. These are improved in this release. + +=head2 Aliasing via reference + +Variables and subroutines can now be aliased by assigning to a reference: + + \$c = \$d; + \&x = \&y; + +Or by using a backslash before a C<foreach> iterator variable, which is +perhaps the most useful idiom this feature provides: + + foreach \%hash (@array_of_hash_refs) { ... } + +This feature is experimental and must be enabled via C<use feature +'refaliasing'>. It will warn unless the C<experimental::refaliasing> +warnings category is disabled. + +See L<perlref/Assigning to References> + +=head2 C<prototype> with no arguments + +C<prototype()> with no arguments now infers C<$_>. [perl #123514] + +=head2 New "const" subroutine attribute + +The "const" attribute can be applied to an anonymous subroutine. It causes +it to be executed immediately when it is cloned. Its value is captured and +used to create a new constant subroutine that is returned. This feature is +experimental. See L<perlsub/Constant Functions>. + +=head2 C<fileno> now works on directory handles -XXX New core language features go here. Summarize user-visible core language -enhancements. Particularly prominent performance optimisations could go -here, but most should go in the L</Performance Enhancements> section. +When the relevant support is available in the operating system, the +C<fileno> builtin now works on directory handles, yielding the +underlying file descriptor in the same way as for filehandles. On +operating systems without such support, C<fileno> on a directory handle +continues to return the undefined value, as before, but also sets C<$!> to +indicate that the operation is not supported. -[ List each enhancement as a =head2 entry ] +Currently, this uses either a C<dd_fd> member in the OS C<DIR> +structure, or a dirfd(3) function as specified by POSIX.1-2008. + +=head2 List form of pipe open implemented for Win32 + +The list form of pipe: + + open my $fh, "-|", "program", @arguments; + +is now implemented on Win32. It has the same limitations as C<system +LIST> on Win32, since the Win32 API doesn't accept program arguments +as a list. + +=head2 C<close> now sets C<$!> + +When an I/O error occurs, the fact that there has been an error is recorded +in the handle. C<close> returns false for such a handle. Previously, the +value of C<$!> would be untouched by C<close>, so the common convention of +writing C<close $fh or die $!> did not work reliably. Now the handle +records the value of C<$!>, too, and C<close> restores it. + +=head2 Assignment to list repetition + +C<(...) x ...> can now be used within a list that is assigned to, as long +as the left-hand side is a valid lvalue. This allows C<(undef,undef,$foo) += that_function()> to be written as C<((undef)x2, $foo) = that_function()>. + +=head2 Infinity and NaN (not-a-number) handling improved + +Floating point values are able to hold the special values infinity (also +-infinity), and NaN (not-a-number). Now we more robustly recognize and +propagate the value in computations, and on output normalize them to C<Inf> and +C<NaN>. + +See also the L<POSIX> enhancements. + +=head2 Floating point parsing has been improved + +Parsing and printing of floating point values has been improved. + +As a completely new feature, hexadecimal floating point literals +(like 0x1.23p-4) are now supported, and they can be output with +C<printf %a>. + +=head2 Packing infinity or not-a-number into a character is now fatal + +Before, when trying to pack infinity or not-a-number into a +(signed) character, Perl would warn, and assumed you tried to +pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>, +C<< U+FFFD >> was returned. + +But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>) +result in a fatal error. + +=head2 Experimental C Backtrace API + +Starting from Perl 5.21.1, on some platforms Perl supports retrieving +the C level backtrace (similar to what symbolic debuggers like gdb do). + +The backtrace returns the stack trace of the C call frames, +with the symbol names (function names), the object names (like "perl"), +and if it can, also the source code locations (file:line). + +The supported platforms are Linux and OS X (some *BSD might work at +least partly, but they have not yet been tested). + +The feature needs to be enabled with C<Configure -Dusecbacktrace>. + +Also included is a C API to retrieve backtraces. + +See L<perlhacktips/"C backtrace"> for more information. =head1 Security -XXX Any security-related notices go here. In particular, any security -vulnerabilities closed should be noted here rather than in the -L</Selected Bug Fixes> section. +=head2 Perl is now compiled with -fstack-protector-strong if available + +Perl has been compiled with the anti-stack-smashing option +C<-fstack-protector> since 5.10.1. Now Perl uses the newer variant +called C<-fstack-protector-strong>, if available. + +=head2 The L<Safe> module could allow outside packages to be replaced + +Critical bugfix: outside packages could be replaced. L<Safe> has +been patched to 2.38 to address this. + +=head2 Perl is now always compiled with -D_FORTIFY_SOURCE=2 if available -[ List each security issue as a =head2 entry ] +The 'code hardening' option called C<_FORTIFY_SOURCE>, available in +gcc 4.*, is now always used for compiling Perl, if available. + +Note that this isn't necessarily a huge step since in many platforms +the step had already been taken several years ago: many Linux +distributions (like Fedora) have been using this option for Perl, +and OS X has enforced the same for many years. =head1 Incompatible Changes -XXX For a release on a stable branch, this section aspires to be: +=head2 Subroutine signatures moved before attributes + +The experimental sub signatures feature, as introduced in 5.20, parsed +signatures after attributes. In this release, the positioning has been +moved such that signatures occur after the subroutine name (if any) and +before the attribute list (if any). + +=head2 C<&> and C<\&> prototypes accepts only subs + +The C<&> prototype character now accepts only anonymous subs (C<sub {...}>) +and things beginning with C<\&>. Formerly it erroneously also allowed +C<undef> and references to array, hashes, and lists. [perl #4539] +[perl #123062] + +The C<\&> prototype was allowing subroutine calls, whereas now it only +allows subroutines. C<&foo> is permitted. C<&foo()> and C<foo()> are not. +[perl #77860] + +=head2 C<use encoding> is now lexical + +The L<encoding> pragma's effect is now limited to lexical scope. This +pragma is deprecated, but in the meantime, it could adversely affect +unrelated modules that are included in the same program. + +=head2 List slices returning empty lists + +List slices return an empty list now only if the original list was empty +(or if there are no indices). Formerly, a list slice would return an empty +list if all indices fell outside the original list. [perl #114498] + +=head2 C<\N{}> with a sequence of multiple spaces is now a fatal error. + +This has been deprecated since v5.18. + +=head2 S<C<use UNIVERSAL '...'>> is now a fatal error + +Importing functions from C<UNIVERSAL> has been deprecated since v5.12, and +is now a fatal error. S<C<"use UNIVERSAL">> without any arguments is still +allowed. + +=head2 In double-quotish C<\cI<X>>, I<X> must now be a printable ASCII character + +In prior releases, failure to do this raised a deprecation warning. - There are no changes intentionally incompatible with 5.XXX.XXX - If any exist, they are bugs, and we request that you submit a - report. See L</Reporting Bugs> below. +=head2 Splitting the tokens C<(?> and C<(*> in regular expressions is +now a fatal compilation error. -[ List each incompatible change as a =head2 entry ] +These had been deprecated since v5.18. + +=head2 5 additional characters are treated as white space under C</x> in +regex patterns (unless escaped) + +The use of these characters with C</x> outside bracketed character +classes and when not preceded by a backslash has raised a deprecation +warning since v5.18. Now they will be ignored. See L</"qr/foo/x"> +for the list of the five characters. + +=head2 Comment lines within S<C<(?[ ])>> now are ended only by a C<\n> + +S<C<(?[ ])>> is an experimental feature, introduced in v5.18. It operates +as if C</x> is always enabled. But there was a difference, comment +lines (following a C<#> character) were terminated by anything matching +C<\R> which includes all vertical whitespace, such as form feeds. For +consistency, this is now changed to match what terminates comment lines +outside S<C<(?[ ])>>, namely a C<\n> (even if escaped), which is the +same as what terminates a heredoc string and formats. + +=head2 C<(?[...])> operators now follow standard Perl precedence + +This experimental feature allows set operations in regular expression patterns. +Prior to this, the intersection operator had the same precedence as the other +binary operators. Now it has higher precedence. This could lead to different +outcomes than existing code expects (though the documentation has always noted +that this change might happen, recommending fully parenthesizing the +expressions). See L<perlrecharclass/Extended Bracketed Character Classes>. + +=head2 Omitting % and @ on hash and array names is no longer permitted + +Really old Perl let you omit the @ on array names and the % on hash +names in some spots. This has issued a deprecation warning since Perl +5.0, and is no longer permitted. + +=head2 C<"$!"> text is now in English outside C<"use locale"> scope + +Previously, the text, unlike almost everything else, always came out +based on the current underlying locale of the program. (Also affected +on some systems is C<"$^E>".) For programs that are unprepared to +handle locale, this can cause garbage text to be displayed. It's better +to display text that is translatable via some tool than garbage text +which is much harder to figure out. + +=head2 C<"$!"> text will be returned in UTF-8 when appropriate + +The stringification of C<$!> and C<$^E> will have the UTF-8 flag set +when the text is actually non-ASCII UTF-8. This will enable programs +that are set up to be locale-aware to properly output messages in the +user's native language. Code that needs to continue the 5.20 and +earlier behavior can do the stringification within the scopes of both +'use bytes' and 'use locale ":messages". No other Perl operations will +be affected by locale; only C<$!> and C<$^E> stringification. The +'bytes' pragma causes the UTF-8 flag to not be set, just as in previous +Perl releases. This resolves [perl #112208]. + +=head2 Support for C<?PATTERN?> without explicit operator has been removed + +Starting regular expressions matching only once directly with the +question mark delimiter is now a syntax error, so that the question mark +can be available for use in new operators. Write C<m?PATTERN?> instead, +explicitly using the C<m> operator: the question mark delimiter still +invokes match-once behaviour. + +=head2 C<defined(@array)> and C<defined(%hash)> are now fatal errors + +These have been deprecated since v5.6.1 and have raised deprecation +warnings since v5.16. + +=head2 Using a hash or an array as a reference are now fatal errors. + +For example, C<%foo-E<gt>{"bar"}> now causes a fatal compilation +error. These have been deprecated since before v5.8, and have raised +deprecation warnings since then. + +=head2 Changes to the C<*> prototype + +The C<*> character in a subroutine's prototype used to allow barewords to take +precedence over most, but not all subroutines. It was never consistent and +exhibited buggy behaviour. + +Now it has been changed, so subroutines always take precedence over barewords, +which brings it into conformity with similarly prototyped built-in functions: + + sub splat(*) { ... } + sub foo { ... } + splat(foo); # now always splat(foo()) + splat(bar); # still splat('bar') as before + close(foo); # close(foo()) + close(bar); # close('bar') =head1 Deprecations -XXX Any deprecated features, syntax, modules etc. should be listed here. +=head2 Setting C<${^ENCODING}> to anything but C<undef> -=head2 Module removals +This variable allows Perl scripts to be written in a non-ASCII, +non-UTF-8 encoding. However, it affects all modules globally, leading +to wrong answers and segmentation faults. New scripts should be written +in UTF-8; old scripts should be converted to UTF-8, which is easily done +with the L<encoding> pragma. -XXX Remove this section if inapplicable. +=head2 C<< /\C/ >> character class -The following modules will be removed from the core distribution in a -future release, and will at that time need to be installed from CPAN. -Distributions on CPAN which require these modules will need to list them as -prerequisites. +This character class, which matches a single byte, even if it appears +in a multi-byte character has been deprecated. Matching single bytes +in a multi-byte character breaks encapsulation, and can corrupt utf8 +strings. -The core versions of these modules will now issue C<"deprecated">-category -warnings to alert you to this fact. To silence these deprecation warnings, -install the modules in question from CPAN. +=head2 Use of non-graphic characters in single-character variable names -Note that these are (with rare exceptions) fine modules that you are encouraged -to continue to use. Their disinclusion from core primarily hinges on their -necessity to bootstrapping a fully functional, CPAN-capable Perl installation, -not usually on concerns over their design. +The syntax for single-character variable names is more lenient than +for longer variable names, allowing the one-character name to be a +punctuation character or even invisible (a non-graphic). Perl v5.20 +deprecated the ASCII-range controls as such a name. Now, all +non-graphic characters that formerly were allowed are deprecated. +The practical effect of this occurs only when not under C<S<"use +utf8">>, and affects just the C1 controls (code points 0x80 through +0xFF), NO-BREAK SPACE, and SOFT HYPHEN. -=over +=head2 Inlining of C<sub () { $var }> with observable side-effects -=item XXX +In many cases Perl makes sub () { $var } into an inlinable constant +subroutine, capturing the value of $var at the time the C<sub> expression +is evaluated. This can break the closure behaviour in those cases where +$var is subsequently modified. The subroutine won't return the new value. -XXX Note that deprecated modules should be listed here even if they are listed -as an updated module in the L</Modules and Pragmata> section. +This usage is now deprecated in those cases where the variable could be +modified elsewhere. Perl detects those cases and emits a deprecation +warning. Such code will likely change in the future and stop producing a +constant. -=back +If your variable is only modified in the place where it is declared, then +Perl will continue to make the sub inlinable with no warnings. -[ List each other deprecation as a =head2 entry ] + sub make_constant { + my $var = shift; + return sub () { $var }; # fine + } -=head1 Performance Enhancements + sub make_constant_deprecated { + my $var; + $var = shift; + return sub () { $var }; # deprecated + } + + sub make_constant_deprecated2 { + my $var = shift; + log_that_value($var); # could modify $var + return sub () { $var }; # deprecated + } + +In the second example above, detecting that $var is assigned to only once +is too hard to detect. That it happens in a spot other than the C<my> +declaration is enough for Perl to find it suspicious. + +This deprecation warning happens only for a simple variable for the body of +the sub. (A C<BEGIN> block or C<use> statement inside the sub is ignored, +because it does not become part of the sub's body.) For more complex +cases, such as C<sub () { do_something() if 0; $var }> the behaviour has +changed such that inlining does not happen if the variable is modifiable +elsewhere. Such cases should be rare. + +=head2 Use of multiple /x regexp modifiers + +It is now deprecated to say something like any of the following: + + qr/foo/xx; + /(?xax:foo)/; + use re qw(/amxx); + +That is, now C<x> should only occur once in any string of contiguous +regular expression pattern modifiers. We do not believe there are any +occurrences of this in all of CPAN. This is in preparation for a future +Perl release having C</xx> mean to allow white-space for readability in +bracketed character classes (those enclosed in square brackets: +C<[...]>). + +=head2 Using a NO-BREAK space in a character alias for C<\N{...}> is now +deprecated -XXX Changes which enhance performance without changing behaviour go here. -There may well be none in a stable release. +This non-graphic character is essentially indistinguishable from a +regular space, and so should not be allowed. See +L<charnames/CUSTOM ALIASES>. -[ List each enhancement as a =item entry ] +=head2 A literal C<"{"> should now be escaped in a pattern + +If you want a literal left curly bracket (also called a left brace) in a +regular expression pattern, you should now escape it by either +preceding it with a backslash (C<"\{">) or enclosing it within square +brackets C<"[{]">, or by using C<\Q>; otherwise a deprecation warning +will be raised. This was first announced as forthcoming in the v5.16 +release; it will allow future extensions to the language to happen. + +=head2 Making all warnings fatal is discouraged + +The documentation for L<fatal warnings|warnings/Fatal Warnings> notes that +C<< use warnings FATAL => 'all' >> is discouraged and provides stronger +language about the risks of fatal warnings in general. + +=head1 Performance Enhancements =over 4 =item * -XXX +If method and class names are known at compile time, hashes are precomputed +to speed up run-time method lookup. Also, compound method names like +C<SUPER::new> are parsed at compile time, to save having to parse them at +run time. + +=item * + +Array and hash lookups (especially nested ones) that use only constants +or simple variables as keys, are now considerably faster. See +L</Internal Changes> for more details. + +=item * + +C<(...)x1>, C<("constant")x0> and C<($scalar)x0> are now optimised in list +context. If the right-hand argument is a constant 1, the repetition +operator disappears. If the right-hand argument is a constant 0, the whole +expressions is optimised to the empty list, so long as the left-hand +argument is a simple scalar or constant. C<(foo())x0> is not optimised. + +=item * + +C<substr> assignment is now optimised into 4-argument C<substr> at the end +of a subroutine (or as the argument to C<return>). Previously, this +optimisation only happened in void context. + +=item * + +Assignment to lexical variables is often optimised away. For instance, in +C<$lexical = chr $foo>, the C<chr> operator writes directly to the lexical +variable instead of returning a value that gets copied. This optimisation +has been extended to C<split>, C<x> and C<vec> on the right-hand side. It +has also been made to work with state variable initialization. + +=item * + +In "\L...", "\Q...", etc., the extra "stringify" op is now optimised away, +making these just as fast as C<lcfirst>, C<quotemeta>, etc. + +=item * + +Assignment to an empty list is now sometimes faster. In particular, it +never calls C<FETCH> on tied arguments on the right-hand side, whereas it +used to sometimes. + +=item * + +C<length> is up to 20% faster for non-magical/non-tied scalars containing a +string if it is a non-utf8 string or if C<use bytes;> is in scope. + +=item * + +Non-magical/non-tied scalars that contain only a floating point value and are +on most Perl builds with 64 bit integers now use 8-32 less bytes of memory +depending on OS. + +=item * + +In C<@array = split>, the assignment can be optimized away with C<split> +writing directly to the array. This optimisation was happening only for +package arrays other than @_ and only +sometimes. Now this optimisation happens +almost all the time. + +=item * + +C<join> is now subject to constant folding. Moreover, C<join> with a +scalar or constant for the separator and a single-item list to join is +simplified to a stringification. The separator doesn't even get evaluated. + +=item * + +C<qq(@array)> is implemented using two ops: a stringify op and a join op. +If the qq contains nothing but a single array, the stringification is +optimized away. + +=item * + +C<our $var> and C<our($s,@a,%h)> in void context are no longer evaluated at +run time. Even a whole sequence of C<our $foo;> statements will simply be +skipped over. The same applies to C<state> variables. + +=item * + +Many internal functions have been refactored to improve performance and reduce +their memory footprints. + +L<[perl #121436]|https://rt.perl.org/Ticket/Display.html?id=121436> +L<[perl #121906]|https://rt.perl.org/Ticket/Display.html?id=121906> +L<[perl #121969]|https://rt.perl.org/Ticket/Display.html?id=121969> + +=item * + +C<-T> and C<-B> filetests will return sooner when an empty file is detected. + +L<perl #121489|https://rt.perl.org/Ticket/Display.html?id=121489> + +=item * + +Refactoring of C<< pp_tied >> and CC<< pp_ref >> for small improvements. + +=item * + +Pathtools don't try to load XS on miniperl. + +=item * + +A typo fix reduces the size of the C<< OP >> structure. + +=item * + +Hash lookups where the key is a constant is faster. + +=item * + +Subroutines with an empty prototype and bodies containing just C<undef> are now +eligible for inlining. +L<[perl #122728]|https://rt.perl.org/Ticket/Display.html?id=122728> + +=item * + +Subroutines in packages no longer need to carry typeglobs around with them. +Declaring a subroutine will now put a simple sub reference in the stash if +possible, saving memory. The typeglobs still notionally exist, so accessing +them will cause the subroutine reference to be upgraded to a typeglob. This +optimization does not currently apply to XSUBs or exported subroutines, and +method calls will undo it, since they cache things in typeglobs. +L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> + +=item * + +The functions C<utf8::native_to_unicode()> and C<utf8::unicode_to_native()> +(see L<utf8>) are now optimized out on ASCII platforms. There is now not even +a minimal performance hit in writing code portable between ASCII and EBCDIC +platforms. + +=item * + +Win32 Perl uses 8 KB less of per-process memory than before for every perl +process of this version. This data is now memory mapped from disk and shared +between perl processes from the same perl binary. =back @@ -119,9 +687,7 @@ XXX =item * -L<Module::CoreList> has been upgraded from version 5.20150420 to 5.20150520. - -Updated to cover the latest releases of Perl. +L<XXX> has been upgraded from version A.xx to B.yy. =back @@ -137,30 +703,303 @@ XXX =head1 Documentation -XXX Changes to files in F<pod/> go here. Consider grouping entries by -file and be sure to link to the appropriate page, e.g. L<perlfunc>. - =head2 New Documentation -XXX Changes which create B<new> files in F<pod/> go here. - -=head3 L<XXX> +=head3 L<perlunicook> -XXX Description of the purpose of the new file here +This document, by Tom Christiansen, provides examples of handling Unicode in +Perl. =head2 Changes to Existing Documentation -XXX Changes which significantly change existing files in F<pod/> go here. -However, any changes to F<pod/perldiag.pod> should go in the L</Diagnostics> -section. +=head3 L<perlapi> + +=over 4 + +=item * + +Note that C<SvSetSV> doesn't do set magic. + +=item * + +C<sv_usepvn_flags> - Fix documentation to mention the use of C<NewX> instead of +C<malloc>. + +L<[perl #121869]|https://rt.perl.org/Ticket/Display.html?id=121869> + +=item * + +Clarify where C<NUL> may be embedded or is required to terminate a string. + +=item * + +Previously missing documentation due to formatting errors are now included. + +=item * + +Entries are now organized into groups rather than by file where they are found. + +=item * + +Alphabetical sorting of entries is now handled by the POD generator to make +entries easier to find when scanning. + +=back + +=head3 L<perldata> + +=over 4 + +=item * + +The syntax of single-character variable names has been brought +up-to-date and more fully explained. + +=back + +=head3 L<perlebcdic> + +=over 4 + +=item * + +This document has been significantly updated in the light of recent +improvements to EBCDIC support. + +=back + +=head3 L<perlfunc> + +=over 4 + +=item * + +Mention that C<study()> is currently a no-op. + +=item * + +Calling C<delete> or C<exists> on array values is now described as "strongly +discouraged" rather than "deprecated". + +=item * + +Improve documentation of C<< our >>. + +=item * + +C<-l> now notes that it will return false if symlinks aren't supported by the +file system. + +L<[perl #121523]|https://rt.perl.org/Ticket/Display.html?id=121523> + +=item * + +Note that C<exec LIST> and C<system LIST> may fall back to the shell on +Win32. Only C<exec PROGRAM LIST> and C<system PROGRAM LIST> indirect object +syntax will reliably avoid using the shell. + +This has also been noted in L<perlport>. + +L<[perl #122046]|https://rt.perl.org/Ticket/Display.html?id=122046> + +=back + +=head3 L<perlguts> + +=over 4 + +=item * + +The OOK example has been updated to account for COW changes and a change in the +storage of the offset. + +=item * + +Details on C level symbols and libperl.t added. + +=back + +=head3 L<perlhacktips> + +=over 4 + +=item * + +Documentation has been added illustrating the perils of assuming the contents +of static memory pointed to by the return values of Perl wrappers for C library +functions doesn't change. + +=item * + +Recommended replacements for tmpfile, atoi, strtol, and strtoul added. + +=item * + +Updated documentation for the C<test.valgrind> C<make> target. + +L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> + +=back + +=head3 L<perlmodstyle> + +=over 4 + +=item * + +Instead of pointing to the module list, we are now pointing to +L<PrePAN|http://prepan.org/>. + +=back + +=head3 L<perlpolicy> + +=over 4 + +=item * + +We now have a code of conduct for the I<< p5p >> mailing list, as documented +in L<< perlpolicy/STANDARDS OF CONDUCT >>. + +=item * -=head3 L<XXX> +The conditions for marking an experimental feature as non-experimental are now +set out. + +=back + +=head3 L<perlport> =over 4 =item * -XXX Description of the change here +Out-of-date VMS-specific information has been fixed/simplified. + +=back + +=head3 L<perlre> + +=over 4 + +=item * + +The C</x> modifier has been clarified to note that comments cannot be continued +onto the next line by escaping them. + +=back + +=head3 L<perlrebackslash> + +=over 4 + +=item * + +Added documentation of C<\b{sb}>, C<\b{wb}>, C<\b{gcb}>, and C<\b{g}>. + +=back + +=head3 L<perlrecharclass> + +=over 4 + +=item * + +Clarifications have been added to L<perlrecharclass/Character Ranges> +to the effect that Perl guarantees that C<[A-Z]>, C<[a-z]>, C<[0-9]> and +any subranges thereof in regular expression bracketed character classes +are guaranteed to match exactly what a naive English speaker would +expect them to match, even on platforms (such as EBCDIC) where special +handling is required to accomplish this. + +=item * + +The documentation of Bracketed Character Classes has been expanded to cover the +improvements in C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>). + +=back + +=head3 L<perlsec> + +=over 4 + +=item * + +Comments added on algorithmic complexity and tied hashes. + +=back + +=head3 L<perlsyn> + +=over 4 + +=item * + +An ambiguity in the documentation of the C<...> statement has been corrected. +L<[perl #122661]|https://rt.perl.org/Ticket/Display.html?id=122661> + +=item * + +The empty conditional in C<< for >> and C<< while >> is now documented +in L<< perlsyn >>. + +=back + +=head3 L<perlunicode> + +=over 4 + +=item * + +Update B<Default Word Boundaries> under +L<perlunicode/"Unicode Regular Expression Support Level">'s +B<Extended Unicode Support>. + +=back + +=head3 L<perluniintro> + +=over 4 + +=item * + +Advice for how to make sure your strings and regular expression patterns are +interpreted as Unicode has been revised to account for the new Perl 5.22 EBCDIC +handling. + +=back + +=head3 L<perlvar> + +=over 4 + +=item * + +Further clarify version number representations and usage. + +=back + +=head3 L<perlvms> + +=over 4 + +=item * + +Out-of-date and/or incorrect material has been removed. + +=item * + +Updated documentation on environment and shell interaction in VMS. + +=back + +=head3 L<perlxs> + +=over 4 + +=item * + +Added a discussion of locale issues in XS code. =back @@ -170,21 +1009,157 @@ 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 * -XXX L<message|perldiag/"message"> +L<Bad symbol for scalar|perldiag/"Bad symbol for scalar"> + +(P) An internal request asked to add a scalar entry to something that +wasn't a symbol table entry. + +=item * + +L<Can't use a hash as a reference|perldiag/"Can't use a hash as a reference"> + +(F) You tried to use a hash as a reference, as in +C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl E<lt>= 5.6.1 +used to allow this syntax, but shouldn't have. + +=item * + +L<Can't use an array as a reference|perldiag/"Can't use an array as a reference"> + +(F) You tried to use an array as a reference, as in +C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl E<lt>= 5.6.1 used to +allow this syntax, but shouldn't have. + +=item * + +L<Can't use 'defined(@array)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(@array)' (Maybe you should just omit the defined()?)"> + +(F) defined() is not useful on arrays because it +checks for an undefined I<scalar> value. If you want to see if the +array is empty, just use C<if (@array) { # not empty }> for example. + +=item * + +L<Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)"> + +(F) C<defined()> is not usually right on hashes. + +Although C<defined %hash> is false on a plain not-yet-used hash, it +becomes true in several non-obvious circumstances, including iterators, +weak references, stash names, even remaining true after C<undef %hash>. +These things make C<defined %hash> fairly useless in practice, so it now +generates a fatal error. + +If a check for non-empty is what you wanted then just put it in boolean +context (see L<perldata/Scalar values>): + + if (%hash) { + # not empty + } + +If you had C<defined %Foo::Bar::QUUX> to check whether such a package +variable exists then that's never really been reliable, and isn't +a good way to enquire about the features of a package, or whether +it's loaded, etc. + +=item * + +L<Cannot chr %f|perldiag/"Cannot chr %f"> + +=item * + +L<Cannot compress %f in pack|perldiag/"Cannot compress %f in pack"> + +=item * + +L<Cannot pack %f with '%c'|perldiag/"Cannot pack %f with '%c'"> + +=item * + +L<Cannot print %f with '%c'|perldiag/"Cannot printf %f with '%c'"> + +=item * + +L<charnames alias definitions may not contain a sequence of multiple spaces|perldiag/"charnames alias definitions may not contain a sequence of multiple spaces"> + +(F) You defined a character name which had multiple space +characters in a row. Change them to single spaces. Usually these +names are defined in the C<:alias> import argument to C<use charnames>, but +they could be defined by a translator installed into C<$^H{charnames}>. +See L<charnames/CUSTOM ALIASES>. + +=item * + +L<charnames alias definitions may not contain trailing white-space|perldiag/"charnames alias definitions may not contain trailing white-space"> + +(F) You defined a character name which ended in a space +character. Remove the trailing space(s). Usually these names are +defined in the C<:alias> import argument to C<use charnames>, but they +could be defined by a translator installed into C<$^H{charnames}>. +See L<charnames/CUSTOM ALIASES>. + +=item * + +L<:const is not permitted on named subroutines|perldiag/":const is not permitted on named subroutines"> + +(F) The "const" attribute causes an anonymous subroutine to be run and +its value captured at the time that it is cloned. Names subroutines are +not cloned like this, so the attribute does not make sense on them. + +=item * + +L<Hexadecimal float: internal error|perldiag/"Hexadecimal float: internal error"> + +(F) Something went horribly bad in hexadecimal float handling. + +=item * + +L<Hexadecimal float: unsupported long double format|perldiag/"Hexadecimal float: unsupported long double format"> + +(F) You have configured Perl to use long doubles but +the internals of the long double format are unknown, +therefore the hexadecimal float output is impossible. + +=item * + +L<Illegal suidscript|perldiag/"Illegal suidscript"> + +(F) The script run under suidperl was somehow illegal. + +=item * + +L<In '(?...)', the '(' and '?' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(?...)', the '(' and '?' must be adjacent in regex; marked by <-- HERE in m/%s/"> + +(F) The two-character sequence C<"(?"> in +this context in a regular expression pattern should be an +indivisible token, with nothing intervening between the C<"("> +and the C<"?">, but you separated them. + +=item * + +L<In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by <-- HERE in m/%s/"> + +(F) The two-character sequence C<"(*"> in +this context in a regular expression pattern should be an +indivisible token, with nothing intervening between the C<"("> +and the C<"*">, but you separated them. + +=item * + +L<Invalid quantifier in {,} in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/"> + +(F) The pattern looks like a {min,max} quantifier, but the min or max could not +be parsed as a valid number - either it has leading zeroes, or it represents +too big a number to cope with. The S<<-- HERE> shows where in the regular +expression the problem was discovered. See L<perlre>. =back @@ -194,193 +1169,2026 @@ XXX L<message|perldiag/"message"> =item * -XXX L<message|perldiag/"message"> +L<'%s' is an unknown bound type in regex|perldiag/"'%s' is an unknown bound type in regex; marked by <-- HERE in m/%s/"> + +You used C<\b{...}> or C<\B{...}> and the C<...> is not known to +Perl. The current valid ones are given in +L<perlrebackslash/\b{}, \b, \B{}, \B>. + +=item * + +L<"%s" is more clearly written simply as "%s" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"%s" is more clearly written simply as "%s" in regex; marked by <-- HERE in mE<sol>%sE<sol>> + +(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) + +You specified a character that has the given plainer way of writing it, +and which is also portable to platforms running with different character +sets. + +=item * + +L<Argument "%s" treated as 0 in increment (++)|perldiag/"Argument "%s" treated +as 0 in increment (++)"> + +(W numeric) The indicated string was fed as an argument to the C<++> operator +which expects either a number or a string matching C</^[a-zA-Z]*[0-9]*\z/>. +See L<perlop/Auto-increment and Auto-decrement> for details. + +=item * + +L<Both or neither range ends should be Unicode in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Both or neither range ends should be Unicode in regex; marked by <-- HERE in m/%s/"> + +(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) + +In a bracketed character class in a regular expression pattern, you +had a range which has exactly one end of it specified using C<\N{}>, and +the other end is specified using a non-portable mechanism. Perl treats +the range as a Unicode range, that is, all the characters in it are +considered to be the Unicode characters, and which may be different code +points on some platforms Perl runs on. For example, C<[\N{U+06}-\x08]> +is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it +matches the characters whose code points in Unicode are 6, 7, and 8. +But that C<\x08> might indicate that you meant something different, so +the warning gets raised. + +=item * + +L<Character in 'C' format overflow in pack|perldiag/"Character in 'C' format overflow in pack"> + +(W pack) You tried converting an infinity or not-a-number to an unsigned +character, which makes no sense. Perl behaved as if you tried to pack 0xFF. + +=item * + +L<Character in 'c' format overflow in pack|perldiag/"Character in 'c' format overflow in pack"> + +(W pack) You tried converting an infinity or not-a-number to a signed +character, which makes no sense. Perl behaved as if you tried to pack 0xFF. + +=item * + +L<:const is experimental|perldiag/":const is experimental"> + +(S experimental::const_attr) The "const" attribute is experimental. +If you want to use the feature, disable the warning with C<no warnings +'experimental::const_attr'>, but know that in doing so you are taking +the risk that your code may break in a future Perl version. + +=item * + +L<gmtime(%f) failed|perldiag/"gmtime(%f) failed"> + +(W overflow) You called C<gmtime> with a number that it could not handle: +too large, too small, or NaN. The returned value is C<undef>. + +=item * + +L<Hexadecimal float: exponent overflow|perldiag/"Hexadecimal float: exponent overflow"> + +(W overflow) The hexadecimal floating point has larger exponent +than the floating point supports. + +=item * + +L<Hexadecimal float: exponent underflow|perldiag/"Hexadecimal float: exponent underflow"> + +(W overflow) The hexadecimal floating point has smaller exponent +than the floating point supports. + +=item * + +L<Hexadecimal float: mantissa overflow|perldiag/"Hexadecimal float: mantissa overflow"> + +(W overflow) The hexadecimal floating point literal had more bits in +the mantissa (the part between the 0x and the exponent, also known as +the fraction or the significand) than the floating point supports. + +=item * + +L<Hexadecimal float: precision loss|perldiag/"Hexadecimal float: precision loss"> + +(W overflow) The hexadecimal floating point had internally more +digits than could be output. This can be caused by unsupported +long double formats, or by 64-bit integers not being available +(needed to retrieve the digits under some configurations). + +L<Invalid number (%f) in chr|perldiag/"Invalid number (%f) in chr"> + +(W utf8) You passed an invalid number (like an infinity or not-a-number) to +C<chr>. Those are not valid character numbers, so it returned the Unicode +replacement character (U+FFFD). + +=item * + +L<localtime(%f) failed|perldiag/"localtime(%f) failed"> + +(W overflow) You called C<localtime> with a number that it could not handle: +too large, too small, or NaN. The returned value is C<undef>. + +=item * + +L<Negative repeat count does nothing|perldiag/"Negative repeat count does nothing"> + +(W numeric) You tried to execute the +L<C<x>|perlop/Multiplicative Operators> repetition operator fewer than 0 +times, which doesn't make sense. + +=item * + +L<NO-BREAK SPACE in a charnames alias definition is deprecated|perldiag/"NO-BREAK SPACE in a charnames alias definition is deprecated"> + +(D deprecated) You defined a character name which contained a no-break +space character. Change it to a regular space. Usually these names are +defined in the C<:alias> import argument to C<use charnames>, but they +could be defined by a translator installed into C<$^H{charnames}>. See +L<charnames/CUSTOM ALIASES>. + +=item * + +L<Non-finite repeat count does nothing|perldiag/"Non-finite repeat count does nothing"> + +(W numeric) You tried to execute the +L<C<x>|perlop/Multiplicative Operators> repetition operator C<Inf> (or +C<-Inf>) or C<NaN> times, which doesn't make sense. + +=item * + +L<PerlIO layer ':win32' is experimental|perldiag/"PerlIO layer ':win32' is experimental"> + +(S experimental::win32_perlio) The C<:win32> PerlIO layer is +experimental. If you want to take the risk of using this layer, +simply disable this warning: + + no warnings "experimental::win32_perlio"; + +=item * + +L<Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by <-- HERE in mE<sol>%sE<sol>"> + +(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) + +Stricter rules help to find typos and other errors. Perhaps you didn't +even intend a range here, if the C<"-"> was meant to be some other +character, or should have been escaped (like C<"\-">). If you did +intend a range, the one that was used is not portable between ASCII and +EBCDIC platforms, and doesn't have an obvious meaning to a casual +reader. + + [3-7] # OK; Obvious and portable + [d-g] # OK; Obvious and portable + [A-Y] # OK; Obvious and portable + [A-z] # WRONG; Not portable; not clear what is meant + [a-Z] # WRONG; Not portable; not clear what is meant + [%-.] # WRONG; Not portable; not clear what is meant + [\x41-Z] # WRONG; Not portable; not obvious to non-geek + +(You can force portability by specifying a Unicode range, which means that +the endpoints are specified by +L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may +still not be obvious.) +The stricter rules require that ranges that start or stop with an ASCII +character that is not a control have all their endpoints be the literal +character, and not some escape sequence (like C<"\x41">), and the ranges +must be all digits, or all uppercase letters, or all lowercase letters. + +=item * + +L<Ranges of digits should be from the same group in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of digits should be from the same group in regex; marked by <-- HERE in m/%s/"> + +(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) + +Stricter rules help to find typos and other errors. You included a +range, and at least one of the end points is a decimal digit. Under the +stricter rules, when this happens, both end points should be digits in +the same group of 10 consecutive digits. + +=item * + +L<Redundant argument in %s|perldiag/Redundant argument in %s> + +(W redundant) You called a function with more arguments than other +arguments you supplied indicated would be needed. Currently only +emitted when a printf-type format required fewer arguments than were +supplied, but might be used in the future for e.g. L<perlfunc/pack>. + +The warnings category C<< redundant >> is new. See also [RT #121025] + +=item * + +L<Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale|perldiag/"Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale"> + +You are matching a regular expression using locale rules, +and a Unicode boundary is being matched, but the locale is not a Unicode +one. This doesn't make sense. Perl will continue, assuming a Unicode +(UTF-8) locale, but the results could well be wrong except if the locale +happens to be ISO-8859-1 (Latin1) where this message is spurious and can +be ignored. + +=item * + +L<< Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by <-- HERE in mE<sol>%sE<sol>" >> + +You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a +portion of a regular expression where the character set modifiers C</a> +or C</aa> are in effect. These two modifiers indicate an ASCII +interpretation, and this doesn't make sense for a Unicode definition. +The generated regular expression will compile so that the boundary uses +all of Unicode. No other portion of the regular expression is affected. + +=item * + +L<The bitwise feature is experimental|perldiag/"The bitwise feature is experimental"> + +This warning is emitted if you use bitwise +operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled. +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::bitwise"; + use feature "bitwise"; + $x |.= $y; + +=item * + +L<Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in m/%s/"> + +(D deprecated, regexp) You used a literal C<"{"> character in a regular +expression pattern. You should change to use C<"\{"> instead, because a future +version of Perl (tentatively v5.26) will consider this to be a syntax error. If +the pattern delimiters are also braces, any matching right brace +(C<"}">) should also be escaped to avoid confusing the parser, for +example, + + qr{abc\{def\}ghi} + +=item * + +L<Use of literal non-graphic characters in variable names is deprecated|perldiag/"Use of literal non-graphic characters in variable names is deprecated"> + +=item * + +L<Useless use of attribute "const"|perldiag/Useless use of attribute "const"> + +(W misc) The "const" attribute has no effect except +on anonymous closure prototypes. You applied it to +a subroutine via L<attributes.pm|attributes>. This is only useful +inside an attribute handler for an anonymous subroutine. + +=item * + +L<E<quot>use re 'strict'E<quot> is experimental|perldiag/"use re 'strict'" is experimental> + +(S experimental::re_strict) The things that are different when a regular +expression pattern is compiled under C<'strict'> are subject to change +in future Perl releases in incompatible ways. This means that a pattern +that compiles today may not in a future Perl release. This warning is +to alert you to that risk. + +=item * + +L<Warning: unable to close filehandle %s properly: %s|perldiag/"Warning: unable to close filehandle %s properly: %s"> + +=item * + +L<Wide character (U+%X) in %s|perldiag/"Wide character (U+%X) in %s"> + +(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8 +one), a multi-byte character was encountered. Perl considers this +character to be the specified Unicode code point. Combining non-UTF8 +locales and Unicode is dangerous. Almost certainly some characters +will have two different representations. For example, in the ISO 8859-7 +(Greek) locale, the code point 0xC3 represents a Capital Gamma. But so +also does 0x393. This will make string comparisons unreliable. + +You likely need to figure out how this multi-byte character got mixed up +with your single-byte locale (or perhaps you thought you had a UTF-8 +locale, but Perl disagrees). + +=item * + +The following two warnings for C<tr///> used to be skipped if the +transliteration contained wide characters, but now they occur regardless of +whether there are wide characters or not: + +L<Useless use of E<sol>d modifier in transliteration operator|perldiag/"Useless use of /d modifier in transliteration operator"> + +L<Replacement list is longer than search list|perldiag/Replacement list is longer than search list> + +=item * + +A new C<locale> warning category has been created, with the following warning +messages currently in it: + +=over 4 + +=item * + +L<Locale '%s' may not work well.%s|perldiag/Locale '%s' may not work well.%s> + +=item * + +L<Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".|perldiag/Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".> =back -=head2 Changes to Existing Diagnostics +=back -XXX Changes (i.e. rewording) of diagnostic messages go here +=head2 Changes to Existing Diagnostics =over 4 =item * -XXX Describe change here +<> should be quotes + +This warning has been changed to +L<< <> at require-statement should be quotes|perldiag/"<> at require-statement should be quotes" >> +to make the issue more identifiable. + +=item * + +L<Argument "%s" isn't numeric%s|perldiag/"Argument "%s" isn't numeric%s"> +now adds the following note: + + Note that for the C<Inf> and C<NaN> (infinity and not-a-number) the + definition of "numeric" is somewhat unusual: the strings themselves + (like "Inf") are considered numeric, and anything following them is + considered non-numeric. + +=item * + +L<Global symbol "%s" requires explicit package name|perldiag/"Global symbol "%s" requires explicit package name (did you forget to declare "my %s"?)"> + +This message has had '(did you forget to declare "my %s"?)' appended to it, to +make it more helpful to new Perl programmers. +L<[perl #121638]|https://rt.perl.org/Ticket/Display.html?id=121638> + +=item * + +'"my" variable &foo::bar can't be in a package' has been reworded to say +'subroutine' instead of 'variable'. + +=item * + +L<\N{} in character class restricted to one character in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"\N{} in inverted character class or as a range end-point is restricted to one character in regex; marked by S<<-- HERE> in m/%s/"> + +This message has had 'character class' changed to 'inverted character class or +as a range end-point is' to reflect improvements in C<qr/[\N{named sequence}]/> +(see under L</Selected Bug Fixes>). + +=item * + +L<panic: frexp|perldiag/"panic: frexp: %f"> + +This message has had ': %f' appended to it, to show what the offending floating +point number is. + +=item * + +B<Possible precedence problem on bitwise %c operator> reworded as +L<Possible precedence problem on bitwise %s operator|perldiag/"Possible precedence problem on bitwise %s operator">. + +=item * + +C<require> with no argument or undef used to warn about a Null filename; now +it dies with C<Missing or undefined argument to require>. + +=item * + +L<Unsuccessful %s on filename containing newline|perldiag/"Unsuccessful %s on filename containing newline"> + +This warning is now only produced when the newline is at the end of +the filename. + +=item * + +"Variable %s will not stay shared" has been changed to say "Subroutine" +when it is actually a lexical sub that will not stay shared. + +=item * + +L<Variable length lookbehind not implemented in regex mE<sol>%sE<sol>|perldiag/"Variable length lookbehind not implemented in regex m/%s/"> + +Information about Unicode behaviour has been added. + +=back + +=head2 Diagnostic Removals + +=over + +=item * + +"Ambiguous use of -foo resolved as -&foo()" + +There is actually no ambiguity here, and this impedes the use of negated +constants; e.g., C<-Inf>. + +=item * + +"Constant is not a FOO reference" + +Compile-time checking of constant dereferencing (e.g., C<< my_constant->() >>) +has been removed, since it was not taking overloading into account. +L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> +L<[perl #122607]|https://rt.perl.org/Ticket/Display.html?id=122607> =back =head1 Utility Changes -XXX Changes to installed programs such as F<perlbug> and F<xsubpp> go here. -Most of these are built within the directory F<utils>. +=head2 F<x2p/> -[ List utility changes as a =head2 entry for each utility and =item -entries for each change -Use L<XXX> with program names to get proper documentation linking. ] +=over 4 + +=item * -=head2 L<XXX> +The F<x2p/> directory has been removed from the Perl core. + +This removes find2perl, s2p and a2p. They have all been released to CPAN as +separate distributions (App::find2perl, App::s2p, App::a2p). + +=back + +=head2 L<h2ph> =over 4 =item * -XXX +F<h2ph> now handles hexadecimal constants in the compiler's predefined +macro definitions, as visible in C<$Config{cppsymbols}>. [rt.perl.org +#123784] =back -=head1 Configuration and Compilation +=head2 L<encguess> + +=over 4 -XXX Changes to F<Configure>, F<installperl>, F<installman>, and analogous tools -go here. Any other changes to the Perl build process should be listed here. -However, any platform-specific changes should be listed in the -L</Platform Support> section, instead. +=item * + +No longer depends on non-core module anymore. + +=back -[ List changes as a =item entry ]. +=head1 Configuration and Compilation =over 4 =item * -XXX +F<Configure> now checks for F<lrintl>, F<lroundl>, F<llrintl>, and F<llroundl>. + +=item * + +F<Configure> with C<-Dmksymlinks> should now be faster. [perl #122002] + +=item * + +pthreads and lcl will be linked by default if present. This allows XS modules +that require threading to work on non-threaded perls. Note that you must still +pass C<-Dusethreads> if you want a threaded perl. + +=item * + +For long doubles (to get more precision and range for floating point numbers) +one can now use the GCC quadmath library which implements the quadruple +precision floating point numbers in x86 and ia64 platforms. See F<INSTALL> for +details. + +=item * + +MurmurHash64A and MurmurHash64B can now be configured as the internal hash +function. + +=item * + +C<make test.valgrind> now supports parallel testing. + +For example: + + TEST_JOBS=9 make test.valgrind + +See L<perlhacktips/valgrind> for more information. + +L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> + +=item * + +The MAD (Misc Attribute Decoration) build option has been removed + +This was an unmaintained attempt at preserving +the Perl parse tree more faithfully so that automatic conversion of +Perl 5 to Perl 6 would have been easier. + +This build-time configuration option had been unmaintained for years, +and had probably seriously diverged on both Perl 5 and Perl 6 sides. + +=item * + +A new compilation flag, C<< -DPERL_OP_PARENT >> is available. For details, +see the discussion below at L<< /Internal Changes >>. =back =head1 Testing -XXX Any significant changes to the testing of a freshly built perl should be -listed here. Changes which create B<new> files in F<t/> go here as do any -large changes to the testing harness (e.g. when parallel testing was added). -Changes to existing files in F<t/> aren't worth summarizing, although the bugs -that they represent may be covered elsewhere. +=over 4 -[ List each test improvement as a =item entry ] +=item * -=over 4 +F<t/porting/re_context.t> has been added to test that L<utf8> and its +dependencies only use the subset of the C<$1..$n> capture vars that +Perl_save_re_context() is hard-coded to localize, because that function has no +efficient way of determining at runtime what vars to localize. =item * -XXX +Tests for performance issues have been added in the file F<t/perf/taint.t>. + +=item * + +Some regular expression tests are written in such a way that they will +run very slowly if certain optimizations break. These tests have been +moved into new files, F<< t/re/speed.t >> and F<< t/re/speed_thr.t >>, +and are run with a C<< watchdog() >>. + +=item * + +C<< test.pl >> now allows C<< plan skip_all => $reason >>, to make it +more compatible with C<< Test::More >>. + +=item * + +A new test script, F<op/infnan.t>, has been added to test if Inf and NaN are +working correctly. See L</Infinity and NaN (not-a-number) handling improved>. =back =head1 Platform Support -XXX Any changes to platform support should be listed in the sections below. +=head2 Regained Platforms + +=over 4 + +=item IRIX and Tru64 platforms are working again. -[ Within the sections, list each platform as a =item entry with specific -changes as paragraphs below it. ] +(Some C<make test> failures remain.) -=head2 New Platforms +=item z/OS running EBCDIC Code Page 1047 -XXX List any platforms that this version of perl compiles on, that previous -versions did not. These will either be enabled by new files in the F<hints/> -directories, or new subdirectories and F<README> files at the top level of the -source tree. +Core perl now works on this EBCDIC platform. Earlier perls also worked, but, +even though support wasn't officially withdrawn, recent perls would not compile +and run well. Perl 5.20 would work, but had many bugs which have now been +fixed. Many CPAN modules that ship with Perl still fail tests, including +Pod::Simple. However the version of Pod::Simple currently on CPAN should work; +it was fixed too late to include in Perl 5.22. Work is under way to fix many +of the still-broken CPAN modules, which likely will be installed on CPAN when +completed, so that you may not have to wait until Perl 5.24 to get a working +version. + +=back + +=head2 Discontinued Platforms =over 4 -=item XXX-some-platform +=item NeXTSTEP/OPENSTEP -XXX +NeXTSTEP was proprietary OS bundled with NeXT's workstations in the early +to mid 90's; OPENSTEP was an API specification that provided a NeXTSTEP-like +environment on a non-NeXTSTEP system. Both are now long dead, so support +for building Perl on them has been removed. =back -=head2 Discontinued Platforms +=head2 Platform-Specific Notes + +=over 4 + +=item EBCDIC + +Special handling is required on EBCDIC platforms to get C<qr/[i-j]/> to +match only C<"i"> and C<"j">, since there are 7 characters between the +code points for C<"i"> and C<"j">. This special handling had only been +invoked when both ends of the range are literals. Now it is also +invoked if any of the C<\N{...}> forms for specifying a character by +name or Unicode code point is used instead of a literal. See +L<perlrecharclass/Character Ranges>. -XXX List any platforms that this version of perl no longer compiles on. +=item HP-UX + +The archname now distinguishes use64bitint from use64bitall. + +=item Android + +Build support has been improved for cross-compiling in general and for +Android in particular. + +=item VMS =over 4 -=item XXX-some-platform +=item * + +When spawning a subprocess without waiting, the return value is now +the correct PID. -XXX +=item * + +Fix a prototype so linking doesn't fail under the VMS C++ compiler. + +=item * + +C<finite>, C<finitel>, and C<isfinite> detection has been added to +C<configure.com>, environment handling has had some minor changes, and +a fix for legacy feature checking status. =back -=head2 Platform-Specific Notes +=item Win32 + +=over 4 + +=item * + +F<miniperl.exe> is now built with C<-fno-strict-aliasing>, allowing 64-bit +builds to complete on GCC 4.8. +L<[perl #123976]|https://rt.perl.org/Ticket/Display.html?id=123976> + +=item * + +C<test-prep> again depends on C<test-prep-gcc> for GCC builds. +L<[perl #124221]|https://rt.perl.org/Ticket/Display.html?id=124221> + +=item * + +Perl can now be built in C++ mode on Windows by setting the makefile macro +C<USE_CPLUSPLUS> to the value "define". + +=item * + +List form pipe open no longer falls back to the shell. + +=item * + +In release 5.21.8 compiling on VC with dmake was broken. Fixed. + +=item * + +New C<DebugSymbols> and C<DebugFull> configuration options added to +Windows makefiles. + +=item * + +L<B> now compiles again on Windows. + +=item * + +Previously, on Visual C++ for Win64 built Perls only, when compiling every Perl +XS module (including CPAN ones) and Perl aware .c file with a 64 bit Visual C++, +would unconditionally have around a dozen warnings from hv_func.h. These +warnings have been silenced. GCC all bitness and Visual C++ for Win32 were +not affected. + +=item * + +Support for building without PerlIO has been removed from the Windows +makefiles. Non-PerlIO builds were all but deprecated in Perl 5.18.0 and are +already not supported by F<Configure> on POSIX systems. + +=item * + +Between 2 and 6 ms and 7 I/O calls have been saved per attempt to open a perl +module for each path in C<@INC>. + +=item * + +Intel C builds are now always built with C99 mode on. + +=item * + +C<%I64d> is now being used instead of C<%lld> for MinGW. + +=item * + +In the experimental C<:win32> layer, a crash in C<open> was fixed. Also +opening C</dev/null>, which works the Win32 Perl's normal C<:unix> layer, was +implemented for C<:win32>. +L<[perl #122224]|https://rt.perl.org/Ticket/Display.html?id=122224> + +=item * + +A new makefile option, C<USE_LONG_DOUBLE>, has been added to the Windows +dmake makefile for gcc builds only. Set this to "define" if you want perl to +use long doubles to give more accuracy and range for floating point numbers. + +=back -XXX List any changes for specific platforms. This could include configuration -and compilation changes or changes in portability/compatibility. However, -changes within modules for platforms should generally be listed in the -L</Modules and Pragmata> section. +=item OpenBSD + +On OpenBSD, Perl will now default to using the system C<malloc> due to the +security features it provides. Perl's own malloc wrapper has been in use +since v5.14 due to performance reasons, but the OpenBSD project believes +the tradeoff is worth it and would prefer that users who need the speed +specifically ask for it. + +L<[perl #122000]|https://rt.perl.org/Ticket/Display.html?id=122000>. + +=item Solaris =over 4 -=item XXX-some-platform +=item * -XXX +We now look for the Sun Studio compiler in both F</opt/solstudio*> and +F</opt/solarisstudio*>. + +=item * + +Builds on Solaris 10 with C<-Dusedtrace> would fail early since make +didn't follow implied dependencies to build C<perldtrace.h>. Added an +explicit dependency to C<depend>. +L<[perl #120120]|https://rt.perl.org/Ticket/Display.html?id=120120> + +=item * + +C<c99> options have been cleaned up, hints look for C<solstudio> +as well as C<SUNWspro>, and support for native C<setenv> has been added. + +=back =back =head1 Internal Changes -XXX Changes which affect the interface available to C<XS> code go here. Other -significant internal changes for future core maintainers should be noted as -well. +=over 4 + +=item * -[ List each change as a =item entry ] +Perl 5.21.2 introduced a new build option, C<-DPERL_OP_PARENT>, which causes +the last C<op_sibling> pointer to refer back to the parent rather than being +C<NULL>, and where instead a new flag indicates the end of the chain. In this +release, the new implementation has been revised; in particular: =over 4 =item * -XXX +On C<PERL_OP_PARENT> builds, the C<op_sibling> field has been renamed +C<op_sibparent> to reflect its new dual purpose. Since the intention is that +this field should primarily be accessed via macros, this change should be +transparent for code written to work under C<PERL_OP_PARENT>. + +=item * + +The newly-introduced C<op_lastsib> flag bit has been renamed C<op_moresib> and +its logic inverted; i.e. it is initialised to zero in a new op, and is changed +to 1 when an op gains a sibling. + +=item * + +The function C<Perl_op_parent> is now only available on C<PERL_OP_PARENT> +builds. Using it on a plain build will be a compile-timer error. + +=item * + +Three new macros, C<OpMORESIB_set>, C<OpLASTSIB_set>, C<OpMAYBESIB_set> have +been added, which are intended to be a low-level portable way to set +C<op_sibling> / C<op_sibparent> while also updating C<op_moresib>. The first +sets the sibling pointer to a new sibling, the second makes the op the last +sibling, and the third conditionally does the first or second action. The +C<op_sibling_splice()> function is retained as a higher-level interface that +can also maintain consistency in the parent at the same time (e.g. by updating +C<op_first> and C<op_last> where appropriate). + +=item * + +The macro C<OpSIBLING_set>, added in Perl 5.21.2, has been removed. It didn't +manipulate C<op_moresib> and has been superseded by C<OpMORESIB_set> et al. + +=item * + +The C<op_sibling_splice> function now accepts a null C<parent> argument where +the splicing doesn't affect the first or last ops in the sibling chain, and +thus where the parent doesn't need to be updated accordingly. =back -=head1 Selected Bug Fixes +=item * + +Macros have been created to allow XS code to better manipulate the POSIX locale +category C<LC_NUMERIC>. See L<perlapi/Locale-related functions and macros>. + +=item * + +The previous C<atoi> et al replacement function, C<grok_atou>, has now been +superseded by C<grok_atoUV>. See L<perlclib> for details. + +=item * + +Added Perl_sv_get_backrefs() to determine if an SV is a weak-referent. + +Function either returns an SV * of type AV, which contains the set of +weakreferences which reference the passed in SV, or a simple RV * which +is the only weakref to this item. + +=item * + +C<screaminstr> has been removed. Although marked as public API, it is +undocumented and has no usage in modern perl versions on CPAN Grep. Calling it +has been fatal since 5.17.0. + +=item * + +C<newDEFSVOP>, C<block_start>, C<block_end> and C<intro_my> have been added +to the API. + +=item * + +The internal C<convert> function in F<op.c> has been renamed +C<op_convert_list> and added to the API. + +=item * + +C<sv_magic> no longer forbids "ext" magic on read-only values. After all, +perl can't know whether the custom magic will modify the SV or not. +[perl #123103] + +=item * + +Starting in 5.21.6, accessing L<perlapi/CvPADLIST> in an XSUB is forbidden. +CvPADLIST has be reused for a different internal purpose for XSUBs. Guard all +CvPADLIST expressions with C<CvISXSUB()> if your code doesn't already block +XSUB CV*s from going through optree CV* expecting code. + +=item * + +SVs of type SVt_NV are now bodyless when a build configure and platform allow +it, specifically C<sizeof(NV) <= sizeof(IV)>. The bodyless trick is the same one +as for IVs since 5.9.2, but for NVs, unlike IVs, is not guaranteed on all +platforms and build configurations. + +=item * + +The C<$DB::single>, C<$DB::signal> and C<$DB::trace> now have set and +get magic that stores their values as IVs and those IVs are used when +testing their values in C<pp_dbstate>. This prevents perl from +recursing infinity if an overloaded object is assigned to any of those +variables. [perl #122445] + +=item * + +C<Perl_tmps_grow> which is marked as public API but undocumented has been +removed from public API. If you use C<EXTEND_MORTAL> macro in your XS code to +preextend the mortal stack, you are unaffected by this change. + +=item * + +C<cv_name>, which was introduced in 5.21.4, has been changed incompatibly. +It now has a flags field that allows the caller to specify whether the name +should be fully qualified. See L<perlapi/cv_name>. + +=item * + +Internally Perl no longer uses the C<SVs_PADMY> flag. C<SvPADMY()> now +returns a true value for anything not marked PADTMP. C<SVs_PADMY> is now +defined as 0. + +=item * + +The macros SETsv and SETsvUN have been removed. They were no longer used +in the core since commit 6f1401dc2a, and have not been found present on +CPAN. + +=item * + +The C<< SvFAKE >> bit (unused on HVs) got informally reserved by +David Mitchell for future work on vtables. + +=item * + +The C<sv_catpvn_flags> function accepts C<SV_CATBYTES> and C<SV_CATUTF8> +flags, which specify whether the appended string is bytes or utf8, +respectively. + +=item * + +A new opcode class, C<< METHOP >> has been introduced, which holds +class/method related info needed at runtime to improve performance +of class/object method calls. + +C<< OP_METHOD >> and C<< OP_METHOD_NAMED >> are moved from being +C<< UNOP/SVOP >> to being C<< METHOP >>. + +=item * + +C<save_re_context> no longer does anything and has been moved to F<mathoms.c>. + +=item * + +C<cv_name> is a new API function that can be passed a CV or GV. It returns an +SV containing the name of the subroutine for use in diagnostics. +L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735> +L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> + +=item * + +C<cv_set_call_checker_flags> is a new API function that works like +C<cv_set_call_checker>, except that it allows the caller to specify whether the +call checker requires a full GV for reporting the subroutine's name, or whether +it could be passed a CV instead. Whatever value is passed will be acceptable +to C<cv_name>. C<cv_set_call_checker> guarantees there will be a GV, but it +may have to create one on the fly, which is inefficient. +L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735> + +=item * + +C<CvGV> (which is not part of the API) is now a more complex macro, which may +call a function and reify a GV. For those cases where is has been used as a +boolean, C<CvHASGV> has been added, which will return true for CVs that +notionally have GVs, but without reifying the GV. C<CvGV> also returns a GV +now for lexical subs. +L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> + +=item * + +Added L<perlapi/sync_locale>. Changing the program's locale should be avoided +by XS code. Nevertheless, certain non-Perl libraries called from XS, such as +C<Gtk> do so. When this happens, Perl needs to be told that the locale has +changed. Use this function to do so, before returning to Perl. + +=item * + +The defines and labels for the flags in the C<op_private> field of OPs are now +auto-generated from data in F<regen/op_private>. The noticeable effect of this +is that some of the flag output of C<Concise> might differ slightly, and the +flag output of C<perl -Dx> may differ considerably (they both use the same set +of labels now). Also in debugging builds, there is a new assert in +C<op_free()> that checks that the op doesn't have any unrecognized flags set in +C<op_private>. + +=item * + +Added L<perlapi/sync_locale>. +Changing the program's locale should be avoided by XS code. Nevertheless, +certain non-Perl libraries called from XS, such as C<Gtk> do so. When this +happens, Perl needs to be told that the locale has changed. Use this function +to do so, before returning to Perl. + +=item * -XXX Important bug fixes in the core language are summarized here. Bug fixes in -files in F<ext/> and F<lib/> are best summarized in L</Modules and Pragmata>. +The deprecated variable C<PL_sv_objcount> has been removed. -[ List each fix as a =item entry ] +=item * + +Perl now tries to keep the locale category C<LC_NUMERIC> set to "C" +except around operations that need it to be set to the program's +underlying locale. This protects the many XS modules that cannot cope +with the decimal radix character not being a dot. Prior to this +release, Perl initialized this category to "C", but a call to +C<POSIX::setlocale()> would change it. Now such a call will change the +underlying locale of the C<LC_NUMERIC> category for the program, but the +locale exposed to XS code will remain "C". There is an API under +development for those relatively few modules that need to use the +underlying locale. This API will be nailed down during the course of +developing v5.21. Send email to L<mailto:perl5-porters@perl.org> for +guidance. + +=item * + +A new macro L<C<isUTF8_CHAR>|perlapi/isUTF8_CHAR> has been written which +efficiently determines if the string given by its parameters begins +with a well-formed UTF-8 encoded character. + +=item * + +The following private API functions had their context parameter removed, +C<Perl_cast_ulong>, C<Perl_cast_i32>, C<Perl_cast_iv>, C<Perl_cast_uv>, +C<Perl_cv_const_sv>, C<Perl_mg_find>, C<Perl_mg_findext>, C<Perl_mg_magical>, +C<Perl_mini_mktime>, C<Perl_my_dirfd>, C<Perl_sv_backoff>, C<Perl_utf8_hop>. + +Users of the public API prefix-less calls remain unaffected. + +=item * + +Experimental support for ops in the optree to be able to locate their +parent, if any. A general-purpose function, C<< op_sibling_splice() >> +allows for general manipulating an C<< op_sibling >> chain. The last op +in such a chain is now marked with the field C<< op_lastsib >>. + +A new build define, C<< -DPERL_OP_PARENT >> has been added; if +given, it forces the core to use C<< op_lastsib >> to detect the +last sibling in a chain, freeing the last C<< op_sibling >> pointer, +which then points back to the parent (instead of being C<< NULL >>). + +A C-level C<< op_parent() >> function, and a C<< B >> C<< parent() >> method +have been added; under a default build, they return C<< NULL >>, but when +C<< -DPERL_OP_PARENT >> has been set, they return the parent of the current op. + +=item * + +The PADNAME and PADNAMELIST types are now separate types, and no longer +simply aliases for SV and AV. [perl #123223] + +=item * + +Pad names are now always UTF8. The C<PadnameUTF8> macro always returns +true. Previously, this was effectively the case already, but any support +for two different internal representations of pad names has now been +removed. + +=item * + +The C<OP_SIBLING> and C<OP_HAS_SIBLING> macros added in an earlier 5.21.x +release have been renamed C<OpSIBLING> and C<OpHAS_SIBLING>, following the +existing convention. + +=item * + +A new op class, C<UNOP_AUX>, has been added. This is a subclass of +C<UNOP> with an C<op_aux> field added, which points to an array of unions +of C<UV>, C<SV*> etc. It is intended for where an op needs to store more data +than a simple C<op_sv> or whatever. Currently the only op of this type is +C<OP_MULTIDEREF> (see below). + +=item * + +A new op has been added, C<OP_MULTIDEREF>, which performs one or more +nested array and hash lookups where the key is a constant or simple +variable. For example the expression C<$a[0]{$k}[$i]>, which previously +involved ten C<rv2Xv>, C<Xelem>, C<gvsv> and C<const> ops is now performed +by a single C<multideref> op. It can also handle C<local>, C<exists> and +C<delete>. A non-simple index expression, such as C<[$i+1]> is still done +using C<aelem/helem>, and single-level array lookup with a small constant +index is still done using C<aelemfast>. + +=back + +=head1 Selected Bug Fixes =over 4 =item * -XXX +C<pack("D", $x)> and C<pack("F", $x)> now zero the padding on x86 long double +builds. GCC 4.8 and later, under some build options, would either overwrite +the zero-initialized padding, or bypass the initialized buffer entirely. This +caused F<op/pack.t> to fail. +L<[perl #123971]|https://rt.perl.org/Ticket/Display.html?id=123971> + +=item * + +Extending an array cloned from a parent thread could result in "Modification of +a read-only value attempted" errors when attempting to modify the new elements. +L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127> + +=item * + +An assertion failure and subsequent crash with C<< *x=<y> >> has been fixed. +L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790> + +=item * + +An optimization for state variable initialization introduced in Perl 5.21.6 has +been reverted because it was found to exacerbate some other existing buggy +behaviour. +L<[perl #124160]|https://rt.perl.org/Ticket/Display.html?id=124160> + +=item * + +The extension of another optimization to cover more ops in Perl 5.21 has also +been reverted to its Perl 5.20 state as a temporary fix for regression issues +that it caused. +L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790> + +=item * + +New bitwise ops added in Perl 5.21.9 accidentally caused C<$^H |= 0x1c020000> +to enable all features. This has now been fixed. + +=item * + +A possible crashing/looping bug has been fixed. +L<[perl #124099]|https://rt.perl.org/Ticket/Display.html?id=124099> + +=item * + +UTF-8 variable names used in array indexes, unquoted UTF-8 HERE-document +terminators and UTF-8 function names all now work correctly. +L<[perl #124113]|https://rt.perl.org/Ticket/Display.html?id=124113> + +=item * + +Repeated global pattern matches in scalar context on large tainted strings were +exponentially slow depending on the current match position in the string. +L<[perl #123202]|https://rt.perl.org/Ticket/Display.html?id=123202> + +=item * + +Various crashes due to the parser getting confused by syntax errors have been +fixed. +L<[perl #123801]|https://rt.perl.org/Ticket/Display.html?id=123801> +L<[perl #123802]|https://rt.perl.org/Ticket/Display.html?id=123802> +L<[perl #123955]|https://rt.perl.org/Ticket/Display.html?id=123955> +L<[perl #123995]|https://rt.perl.org/Ticket/Display.html?id=123995> + +=item * + +C<split> in the scope of lexical $_ has been fixed not to fail assertions. +L<[perl #123763]|https://rt.perl.org/Ticket/Display.html?id=123763> + +=item * + +C<my $x : attr> syntax inside various list operators no longer fails +assertions. +L<[perl #123817]|https://rt.perl.org/Ticket/Display.html?id=123817> + +=item * + +An @ sign in quotes followed by a non-ASCII digit (which is not a valid +identifier) would cause the parser to crash, instead of simply trying the @ as +literal. This has been fixed. +L<[perl #123963]|https://rt.perl.org/Ticket/Display.html?id=123963> + +=item * + +C<*bar::=*foo::=*glob_with_hash> has been crashing since Perl 5.14, but no +longer does. +L<[perl #123847]|https://rt.perl.org/Ticket/Display.html?id=123847> + +=item * + +C<foreach> in scalar context was not pushing an item on to the stack, resulting +in bugs. (C<print 4, scalar do { foreach(@x){} } + 1> would print 5.) It has +been fixed to return C<undef>. +L<[perl #124004]|https://rt.perl.org/Ticket/Display.html?id=124004> + +=item * + +A memory leak introduced in Perl 5.21.6 has been fixed. +L<[perl #123922]|https://rt.perl.org/Ticket/Display.html?id=123922> + +=item * + +A regression in the behaviour of the C<readline> built-in function, caused by +the introduction of the C<< <<>> >> operator, has been fixed. +L<[perl #123990]|https://rt.perl.org/Ticket/Display.html?id=123990> + +=item * + +Several cases of data used to store environment variable contents in core C +code being potentially overwritten before being used have been fixed. +L<[perl #123748]|https://rt.perl.org/Ticket/Display.html?id=123748> + +=item * + +Patterns starting with C</.*/> are now fast again. [rt.perl.org #123743] + +=item * + +The original visible value of C<$/> is now preserved when it is set to +an invalid value. Previously if you set C<$/> to a reference to an +array, for example, perl would produce a runtime error and not set +C<PL_rs>, but perl code that checked C<$/> would see the array +reference. [rt.perl.org #123218] + +=item * + +In a regular expression pattern, a POSIX class, like C<[:ascii:]>, must +be inside a bracketed character class, like C</qr[[:ascii:]]>. A +warning is issued when something looking like a POSIX class is not +inside a bracketed class. That warning wasn't getting generated when +the POSIX class was negated: C<[:^ascii:]>. This is now fixed. + +=item * + +Fix a couple of other size calculation overflows. [rt.perl.org #123554] + +=item * + +A bug introduced in 5.21.6, C<dump LABEL> acted the same as C<goto +LABEL>. This has been fixed. [rt.perl.org #123836] + +=item * + +Perl 5.14.0 introduced a bug whereby C<eval { LABEL: }> would crash. This +has been fixed. [rt.perl.org #123652] + +=item * + +Various crashes due to the parser getting confused by syntax errors have +been fixed. [rt.perl.org #123617] [rt.perl.org #123737] +[rt.perl.org #123753] [rt.perl.org #123677] + +=item * + +Code like C</$a[/> used to read the next line of input and treat it as +though it came immediately after the opening bracket. Some invalid code +consequently would parse and run, but some code caused crashes, so this is +now disallowed. [rt.perl.org #123712] + +=item * + +Fix argument underflow for C<pack>. [rt.perl.org #123874] + +=item * + +Fix handling of non-strict C<\x{}>. Now C<\x{}> is equivalent to C<\x{0}> +instead of faulting. + +=item * + +C<stat -t> is now no longer treated as stackable, just like C<-t stat>. +[rt.perl.org #123816] + +=item * + +The following no longer causes a SEGV: C<qr{x+(y(?0))*}>. + +=item * + +Fixed infinite loop in parsing backrefs in regexp patterns. + +=item * + +Several minor bug fixes in behavior of Inf and NaN, including +warnings when stringifying Inf-like or NaN-like strings. For example, +"NaNcy" doesn't numify to NaN anymore. + +=item * + +Only stringy classnames are now shared. This fixes some failures in L<autobox>. [rt.cpan.org #100819] + +=item * + +A bug in regular expression patterns that could lead to segfaults and +other crashes has been fixed. This occurred only in patterns compiled +with C<"/i">, while taking into account the current POSIX locale (this usually +means they have to be compiled within the scope of C<S<"use locale">>), +and there must be a string of at least 128 consecutive bytes to match. +[perl #123539] + +=item * + +C<s///> now works on very long strings instead of dying with 'Substitution +loop'. [perl #103260] [perl #123071] + +=item * + +C<gmtime> no longer crashes with not-a-number values. [perl #123495] + +=item * + +C<\()> (reference to an empty list) and C<y///> with lexical $_ in scope +could do a bad write past the end of the stack. They have been fixed +to extend the stack first. + +=item * + +C<prototype()> with no arguments used to read the previous item on the +stack, so C<print "foo", prototype()> would print foo's prototype. It has +been fixed to infer $_ instead. [perl #123514] + +=item * + +Some cases of lexical state subs inside predeclared subs could crash but no +longer do. + +=item * + +Some cases of nested lexical state subs inside anonymous subs could cause +'Bizarre copy' errors or possibly even crash. + +=item * + +When trying to emit warnings, perl's default debugger (F<perl5db.pl>) was +sometimes giving 'Undefined subroutine &DB::db_warn called' instead. This +bug, which started to occur in Perl 5.18, has been fixed. [perl #123553] + +=item * + +Certain syntax errors in substitutions, such as C<< s/${E<lt>E<gt>{})// >>, would +crash, and had done so since Perl 5.10. (In some cases the crash did not +start happening till 5.16.) The crash has, of course, been fixed. +[perl #123542] + +=item * + +A repeat expression like C<33 x ~3> could cause a large buffer +overflow since the new output buffer size was not correctly handled by +SvGROW(). An expression like this now properly produces a memory wrap +panic. [perl 123554] + +=item * + +C<< formline("@...", "a"); >> would crash. The C<FF_CHECKNL> case in +pp_formline() didn't set the pointer used to mark the chop position, +which led to the C<FF_MORE> case crashing with a segmentation fault. +This has been fixed. [perl #123538] + +=item * + +A possible buffer overrun and crash when parsing a literal pattern during +regular expression compilation has been fixed. [perl #123604] + +=item * + +fchmod() and futimes() now set C<$!> when they fail due to being +passed a closed file handle. [perl #122703] + +=item * + +Perl now comes with a corrected Unicode 7.0 for the erratum issued on +October 21, 2014 (see L<http://www.unicode.org/errata/#current_errata>), +dealing with glyph shaping in Arabic. + +=item * + +op_free() no longer crashes due to a stack overflow when freeing a +deeply recursive op tree. [perl #108276] + +=item * + +scalarvoid() would crash due to a stack overflow when processing a +deeply recursive op tree. [perl #108276] + +=item * + +In Perl 5.20.0, C<$^N> accidentally had the internal UTF8 flag turned off +if accessed from a code block within a regular expression, effectively +UTF8-encoding the value. This has been fixed. [perl #123135] + +=item * + +A failed C<semctl> call no longer overwrites existing items on the stack, +causing C<(semctl(-1,0,0,0))[0]> to give an "uninitialized" warning. + +=item * + +C<else{foo()}> with no space before C<foo> is now better at assigning the +right line number to that statement. [perl #122695] + +=item * + +Sometimes the assignment in C<@array = split> gets optimised and C<split> +itself writes directly to the array. This caused a bug, preventing this +assignment from being used in lvalue context. So +C<(@a=split//,"foo")=bar()> was an error. (This bug probably goes back to +Perl 3, when the optimisation was added.) This optimisation, and the bug, +started to happen in more cases in 5.21.5. It has now been fixed. +[perl #123057] + +=item * + +When argument lists that fail the checks installed by subroutine +signatures, the resulting error messages now give the file and line number +of the caller, not of the called subroutine. [perl #121374] + +=item * + +Flip-flop operators (C<..> and C<...> in scalar context) used to maintain +a separate state for each recursion level (the number of times the +enclosing sub was called recursively), contrary to the documentation. Now +each closure has one internal state for each flip-flop. [perl #122829] + +=item * + +C<use>, C<no>, statement labels, special blocks (C<BEGIN>) and pod are now +permitted as the first thing in a C<map> or C<grep> block, the block after +C<print> or C<say> (or other functions) returning a handle, and within +C<${...}>, C<@{...}>, etc. [perl #122782] + +=item * + +The repetition operator C<x> now propagates lvalue context to its left-hand +argument when used in contexts like C<foreach>. That allows +C<for(($#that_array)x2) { ... }> to work as expected if the loop modifies +$_. + +=item * + +C<(...) x ...> in scalar context used to corrupt the stack if one operand +were an object with "x" overloading, causing erratic behaviour. +[perl #121827] + +=item * + +Assignment to a lexical scalar is often optimised away (as mentioned under +L</Performance Enhancements>). Various bugs related to this optimisation +have been fixed. Certain operators on the right-hand side would sometimes +fail to assign the value at all or assign the wrong value, or would call +STORE twice or not at all on tied variables. The operators affected were +C<$foo++>, C<$foo-->, and C<-$foo> under C<use integer>, C<chomp>, C<chr> +and C<setpgrp>. + +=item * + +List assignments were sometimes buggy if the same scalar ended up on both +sides of the assignment due to used of C<tied>, C<values> or C<each>. The +result would be the wrong value getting assigned. + +=item * + +C<setpgrp($nonzero)> (with one argument) was accidentally changed in 5.16 +to mean C<setpgrp(0)>. This has been fixed. + +=item * + +C<__SUB__> could return the wrong value or even corrupt memory under the +debugger (the B<-d> switch) and in subs containing C<eval $string>. + +=item * + +When C<sub () { $var }> becomes inlinable, it now returns a different +scalar each time, just as a non-inlinable sub would, though Perl still +optimises the copy away in cases where it would make no observable +difference. + +=item * + +C<my sub f () { $var }> and C<sub () : attr { $var }> are no longer +eligible for inlining. The former would crash; the latter would just +throw the attributes away. An exception is made for the little-known +":method" attribute, which does nothing much. + +=item * + +Inlining of subs with an empty prototype is now more consistent than +before. Previously, a sub with multiple statements, all but the last +optimised away, would be inlinable only if it were an anonymous sub +containing a string C<eval> or C<state> declaration or closing over an +outer lexical variable (or any anonymous sub under the debugger). Now any +sub that gets folded to a single constant after statements have been +optimised away is eligible for inlining. This applies to things like C<sub +() { jabber() if DEBUG; 42 }>. + +Some subroutines with an explicit C<return> were being made inlinable, +contrary to the documentation, Now C<return> always prevents inlining. + +=item * + +On some systems, such as VMS, C<crypt> can return a non-ASCII string. If a +scalar assigned to had contained a UTF8 string previously, then C<crypt> +would not turn off the UTF8 flag, thus corrupting the return value. This +would happen with C<$lexical = crypt ...>. + +=item * + +C<crypt> no longer calls C<FETCH> twice on a tied first argument. + +=item * + +An unterminated here-doc on the last line of a quote-like operator +(C<qq[${ <<END }]>, C</(?{ <<END })/>) no longer causes a double free. It +started doing so in 5.18. + +=item * + +Fixed two assertion failures introduced into C<-DPERL_OP_PARENT> +builds. [perl #108276] + +=item * + +index() and rindex() no longer crash when used on strings over 2GB in +size. +L<[perl #121562]|https://rt.perl.org/Ticket/Display.html?id=121562>. + +=item * + +A small previously intentional memory leak in PERL_SYS_INIT/PERL_SYS_INIT3 on +Win32 builds was fixed. This might affect embedders who repeatedly create and +destroy perl engines within the same process. + +=item * + +C<POSIX::localeconv()> now returns the data for the program's underlying +locale even when called from outside the scope of S<C<use locale>>. + +=item * + +C<POSIX::localeconv()> now works properly on platforms which don't have +C<LC_NUMERIC> and/or C<LC_MONETARY>, or for which Perl has been compiled +to disregard either or both of these locale categories. In such +circumstances, there are now no entries for the corresponding values in +the hash returned by C<localeconv()>. + +=item * + +C<POSIX::localeconv()> now marks appropriately the values it returns as +UTF-8 or not. Previously they were always returned as a bytes, even if +they were supposed to be encoded as UTF-8. + +=item * + +On Microsoft Windows, within the scope of C<S<use locale>>, the following +POSIX character classes gave results for many locales that did not +conform to the POSIX standard: +C<[[:alnum:]]>, +C<[[:alpha:]]>, +C<[[:blank:]]>, +C<[[:digit:]]>, +C<[[:graph:]]>, +C<[[:lower:]]>, +C<[[:print:]]>, +C<[[:punct:]]>, +C<[[:upper:]]>, +C<[[:word:]]>, +and +C<[[:xdigit:]]>. +These are because the underlying Microsoft implementation does not +follow the standard. Perl now takes special precautions to correct for +this. + +=item * + +Many issues have been detected by L<Coverity|http://www.coverity.com/> and +fixed. + +=item * + +system() and friends should now work properly on more Android builds. + +Due to an oversight, the value specified through -Dtargetsh to Configure +would end up being ignored by some of the build process. This caused perls +cross-compiled for Android to end up with defective versions of system(), +exec() and backticks: the commands would end up looking for C</bin/sh> +instead of C</system/bin/sh>, and so would fail for the vast majority +of devices, leaving C<$!> as C<ENOENT>. + +=item * + +C<qr(...\(...\)...)>, +C<qr[...\[...\]...]>, +and +C<qr{...\{...\}...}> +now work. Previously it was impossible to escape these three +left-characters with a backslash within a regular expression pattern +where otherwise they would be considered metacharacters, and the pattern +opening delimiter was the character, and the closing delimiter was its +mirror character. + +=item * + +C<< s///e >> on tainted utf8 strings got C<< pos() >> messed up. This bug, +introduced in 5.20, is now fixed. [RT #122148] + +=item * + +A non-word boundary in a regular expression (C<< \B >>) did not always +match the end of the string; in particular C<< q{} =~ /\B/ >> did not +match. This bug, introduced in perl 5.14, is now fixed. [RT #122090] + +=item * + +C<< " P" =~ /(?=.*P)P/ >> should match, but did not. This is now fixed. +[RT #122171]. + +=item * + +Failing to compile C<use Foo> in an eval could leave a spurious +C<BEGIN> subroutine definition, which would produce a "Subroutine +BEGIN redefined" warning on the next use of C<use>, or other C<BEGIN> +block. [perl #122107] + +=item * + +C<method { BLOCK } ARGS> syntax now correctly parses the arguments if they +begin with an opening brace. [perl #46947] + +=item * + +External libraries and Perl may have different ideas of what the locale is. +This is problematic when parsing version strings if the locale's numeric +separator has been changed. Version parsing has been patched to ensure +it handles the locales correctly. [perl #121930] + +=item * + +A bug has been fixed where zero-length assertions and code blocks inside of a +regex could cause C<pos> to see an incorrect value. [perl #122460] + +=item * + +Constant dereferencing now works correctly for typeglob constants. Previously +the glob was stringified and its name looked up. Now the glob itself is used. +L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> + +=item * + +When parsing a funny character ($ @ % &) followed by braces, the parser no +longer tries to guess whether it is a block or a hash constructor (causing a +syntax error when it guesses the latter), since it can only be a block. + +=item * + +C<undef $reference> now frees the referent immediately, instead of hanging on +to it until the next statement. +L<[perl #122556]|https://rt.perl.org/Ticket/Display.html?id=122556> + +=item * + +Various cases where the name of a sub is used (autoload, overloading, error +messages) used to crash for lexical subs, but have been fixed. + +=item * + +Bareword lookup now tries to avoid vivifying packages if it turns out the +bareword is not going to be a subroutine name. + +=item * + +Compilation of anonymous constants (e.g., C<sub () { 3 }>) no longer deletes +any subroutine named C<__ANON__> in the current package. Not only was +C<*__ANON__{CODE}> cleared, but there was a memory leak, too. This bug goes +back to Perl 5.8.0. + +=item * + +Stub declarations like C<sub f;> and C<sub f ();> no longer wipe out constants +of the same name declared by C<use constant>. This bug was introduced in Perl +5.10.0. + +=item * + +Under some conditions a warning raised in compilation of regular expression +patterns could be displayed multiple times. This is now fixed. + +=item * + +C<qr/[\N{named sequence}]/> now works properly in many instances. Some names +known to C<\N{...}> refer to a sequence of multiple characters, instead of the +usual single character. Bracketed character classes generally only match +single characters, but now special handling has been added so that they can +match named sequences, but not if the class is inverted or the sequence is +specified as the beginning or end of a range. In these cases, the only +behavior change from before is a slight rewording of the fatal error message +given when this class is part of a C<?[...])> construct. When the C<[...]> +stands alone, the same non-fatal warning as before is raised, and only the +first character in the sequence is used, again just as before. + +=item * + +Tainted constants evaluated at compile time no longer cause unrelated +statements to become tainted. +L<[perl #122669]|https://rt.perl.org/Ticket/Display.html?id=122669> + +=item * + +C<open $$fh, ...>, which vivifies a handle with a name like "main::_GEN_0", was +not giving the handle the right reference count, so a double free could happen. + +=item * + +When deciding that a bareword was a method name, the parser would get confused +if an "our" sub with the same name existed, and look up the method in the +package of the "our" sub, instead of the package of the invocant. + +=item * + +The parser no longer gets confused by C<\U=> within a double-quoted string. It +used to produce a syntax error, but now compiles it correctly. +L<[perl #80368]|https://rt.perl.org/Ticket/Display.html?id=80368> + +=item * + +It has always been the intention for the C<-B> and C<-T> file test operators to +treat UTF-8 encoded files as text. (L<perlfunc|perlfunc/-X FILEHANDLE> has +been updated to say this.) Previously, it was possible for some files to be +considered UTF-8 that actually weren't valid UTF-8. This is now fixed. The +operators now work on EBCDIC platforms as well. + +=item * + +Under some conditions warning messages raised during regular expression pattern +compilation were being output more than once. This has now been fixed. + +=item * + +A regression has been fixed that was introduced in Perl 5.20.0 (fixed in Perl +5.20.1 as well as here) in which a UTF-8 encoded regular expression pattern +that contains a single ASCII lowercase letter does not match its uppercase +counterpart. +L<[perl #122655]|https://rt.perl.org/Ticket/Display.html?id=122655> + +=item * + +Constant folding could incorrectly suppress warnings if lexical warnings (C<use +warnings> or C<no warnings>) were not in effect and C<$^W> were false at +compile time and true at run time. + +=item * + +Loading UTF8 tables during a regular expression match could cause assertion +failures under debugging builds if the previous match used the very same +regular expression. +L<[perl #122747]|https://rt.perl.org/Ticket/Display.html?id=122747> + +=item * + +Thread cloning used to work incorrectly for lexical subs, possibly causing +crashes or double frees on exit. + +=item * + +Since Perl 5.14.0, deleting C<$SomePackage::{__ANON__}> and then undefining an +anonymous subroutine could corrupt things internally, resulting in +L<Devel::Peek> crashing or L<B.pm|B> giving nonsensical data. This has been +fixed. + +=item * + +C<(caller $n)[3]> now reports names of lexical subs, instead of treating them +as "(unknown)". + +=item * + +C<sort subname LIST> now supports lexical subs for the comparison routine. + +=item * + +Aliasing (e.g., via C<*x = *y>) could confuse list assignments that mention the +two names for the same variable on either side, causing wrong values to be +assigned. +L<[perl #15667]|https://rt.perl.org/Ticket/Display.html?id=15667> + +=item * + +Long here-doc terminators could cause a bad read on short lines of input. This +has been fixed. It is doubtful that any crash could have occurred. This bug +goes back to when here-docs were introduced in Perl 3.000 twenty-five years +ago. + +=item * + +An optimization in C<split> to treat C<split/^/> like C<split/^/m> had the +unfortunate side-effect of also treating C<split/\A/> like C<split/^/m>, which +it should not. This has been fixed. (Note, however, that C<split/^x/> does +not behave like C<split/^x/m>, which is also considered to be a bug and will be +fixed in a future version.) +L<[perl #122761]|https://rt.perl.org/Ticket/Display.html?id=122761> + +=item * + +The little-known C<my Class $var> syntax (see L<fields> and L<attributes>) +could get confused in the scope of C<use utf8> if C<Class> were a constant +whose value contained Latin-1 characters. + +=item * + +Locking and unlocking values via L<Hash::Util> or C<Internals::SvREADONLY> +no longer has any effect on values that are read-only to begin. +Previously, unlocking such values could result in crashes, hangs or +other erratic behaviour. + +=item * + +The internal C<looks_like_number> function (which L<Scalar::Util> provides +access to) began erroneously to return true for "-e1" in 5.21.4, affecting +also C<-'-e1'>. This has been fixed. + +=item * + +The flip-flop operator (C<..> in scalar context) would return the same +scalar each time, unless the containing subroutine was called recursively. +Now it always returns a new scalar. [perl #122829] + +=item * + +Some unterminated C<(?(...)...)> constructs in regular expressions would +either crash or give erroneous error messages. C</(?(1)/> is one such +example. + +=item * + +C<pack "w", $tied> no longer calls FETCH twice. + +=item * + +List assignments like C<($x, $z) = (1, $y)> now work correctly if $x and $y +have been aliased by C<foreach>. + +=item * + +Some patterns including code blocks with syntax errors, such as +C</ (?{(^{})/>, would hang or fail assertions on debugging builds. Now +they produce errors. + +=item * + +An assertion failure when parsing C<sort> with debugging enabled has been +fixed. [perl #122771] + +=item * + +C<*a = *b; @a = split //, $b[1]> could do a bad read and produce junk +results. + +=item * + +In C<() = @array = split>, the C<() => at the beginning no longer confuses +the optimizer, making it assume a limit of 1. + +=item * + +Fatal warnings no longer prevent the output of syntax errors. +[perl #122966] + +=item * + +Fixed a NaN double to long double conversion error on VMS. For quiet NaNs +(and only on Itanium, not Alpha) negative infinity instead of NaN was +produced. + +=item * + +Fixed the issue that caused C<< make distclean >> to leave files behind +that shouldn't. [perl #122820] + +=item * + +AIX now sets the length in C<< getsockopt >> correctly. [perl #120835], +[rt #91183], [rt #85570]. + +=item * + +During the pattern optimization phase, we no longer recurse into +GOSUB/GOSTART when not SCF_DO_SUBSTR. This prevents the optimizer +to run "forever" and exhaust all memory. [perl #122283] + +=item * + +F<< t/op/crypt.t >> now performs SHA-256 algorithm if the default one +is disabled. [perl #121591] + +=item * + +Fixed an off-by-one error when setting the size of shared array. +[perl #122950] + +=item * + +Fixed a bug that could cause perl to execute an infinite loop during +compilation. [perl #122995] + +=item * + +On Win32, restoring in a child pseudo-process a variable that was +C<local()>ed in a parent pseudo-process before the C<fork> happened caused +memory corruption and a crash in the child pseudo-process (and therefore OS +process). [perl #40565] + +=item * + +Calling C<write> on a format with a C<^**> field could produce a panic +in sv_chop() if there were insufficient arguments or if the variable +used to fill the field was empty. [perl #123245] + +=item * + +Non-ASCII lexical sub names (use in error messages) on longer have extra +junk on the end. + +=item * + +The C<\@> subroutine prototype no longer flattens parenthesized arrays +(taking a reference to each element), but takes a reference to the array +itself. [perl #47363] + +=item * + +A block containing nothing except a C-style C<for> loop could corrupt the +stack, causing lists outside the block to lose elements or have elements +overwritten. This could happen with C<map { for(...){...} } ...> and with +lists containing C<do { for(...){...} }>. [perl #123286] + +=item * + +C<scalar()> now propagates lvalue context, so that +C<for(scalar($#foo)) { ... }> can modify C<$#foo> through C<$_>. + +=item * + +C<qr/@array(?{block})/> no longer dies with "Bizarre copy of ARRAY". +[#123344] + +=item * + +C<eval '$variable'> in nested named subroutines would sometimes look up a +global variable even with a lexical variable in scope. + +=item * + +In perl 5.20.0, C<sort CORE::fake> where 'fake' is anything other than a +keyword started chopping of the last 6 characters and treating the result +as a sort sub name. The previous behaviour of treating "CORE::fake" as a +sort sub name has been restored. [perl #123410] + +=item * + +Outside of C<use utf8>, a single-character Latin-1 lexical variable is +disallowed. The error message for it, "Can't use global $foo...", was +giving garbage instead of the variable name. + +=item * + +C<readline> on a nonexistent handle was causing C<${^LAST_FH}> to produce a +reference to an undefined scalar (or fail an assertion). Now +C<${^LAST_FH}> ends up undefined. + +=item * + +C<(...)x...> in void context now applies scalar context to the left-hand +argument, instead of the context the current sub was called in. +[perl #123020] =back =head1 Known Problems -XXX Descriptions of platform agnostic bugs we know we can't fix go here. Any -tests that had to be C<TODO>ed for the release would be noted here. Unfixed -platform specific bugs also go here. +=over 4 + +=item * + +A goal is for Perl to be able to be recompiled to work reasonably well on any +Unicode version. In Perl 5.22, though, the earliest such version is Unicode +5.1 (current is 7.0). + +=item * -[ List each fix as a =item entry ] +EBCDIC platforms =over 4 =item * -XXX +Encode and encoding are mostly broken. + +=item * + +Many cpan modules that are shipped with core show failing tests. + +=item * + +C<pack>/C<unpack> with C<"U0"> format may not work properly. =back -=head1 Errata From Previous Releases +=item * + +The following modules are known to have test failures with this version of +Perl. Patches have been submitted, so there will hopefully be new releases +soon: -=over 4 +=over =item * -XXX Add anything here that we forgot to add, or were mistaken about, in -the perldelta of a previous release. +L<B::Generate> version 1.50 -=back +=item * + +L<B::Utils> version 0.25 + +=item * -=head1 Obituary +L<Dancer> version 1.3130 -XXX If any significant core contributor has died, we've added a short obituary -here. +=item * + +L<Data::Alias> version 1.18 + +=item * + +L<Data::Util> version 0.63 + +=item * + +L<Lexical::Var> version 0.009 + +=item * + +L<Mason> version 2.22 + +=item * + +L<Padre> version 1.00 + +=item * + +L<Parse::Keyword> 0.08 + +=back + +=back =head1 Acknowledgements XXX Generate this with: - perl Porting/acknowledgements.pl v5.21.11..HEAD + perl Porting/acknowledgements.pl v5.20.0..HEAD =head1 Reporting Bugs |