From c0ddbfc2a7cbd57f1a395f7869ba447249bff19b Mon Sep 17 00:00:00 2001 From: Ricardo Signes Date: Tue, 19 May 2015 13:38:50 -0400 Subject: remove the temporary perl5220delta from Porting --- MANIFEST | 1 - Porting/perl5220delta.pod | 3226 ---------------------------------------- t/porting/known_pod_issues.dat | 4 +- 3 files changed, 1 insertion(+), 3230 deletions(-) delete mode 100644 Porting/perl5220delta.pod diff --git a/MANIFEST b/MANIFEST index ed484a37bd..427874087e 100644 --- a/MANIFEST +++ b/MANIFEST @@ -4734,7 +4734,6 @@ Porting/manicheck Check against MANIFEST Porting/manisort Sort the MANIFEST Porting/new-perldelta.pl Generate a new perldelta Porting/newtests-perldelta.pl Generate Perldelta stub for newly added tests -Porting/perl5220delta.pod Perl changes in version 5.22.0 Porting/perldelta_template.pod Template for creating new perldelta.pod files Porting/perlhist_calculate.pl Perform calculations to update perlhist Porting/pod_lib.pl Code for handling generated pods diff --git a/Porting/perl5220delta.pod b/Porting/perl5220delta.pod deleted file mode 100644 index 46b6b342ff..0000000000 --- a/Porting/perl5220delta.pod +++ /dev/null @@ -1,3226 +0,0 @@ -=encoding utf8 - -=head1 NAME - -perldelta - what is new for perl v5.22.0 - -=head1 DESCRIPTION - -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.18.0, first read -L, which describes differences between 5.18.0 and 5.20.0. - -=head1 Core Enhancements - -=head2 New bitwise operators - -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 for details. [rt.perl.org #123466] - -=head2 New double-diamond operator - -C<<< <<>> >>> is like C<< <> >> but uses three-argument C 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 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 for details. - -=head3 qr/\b{wb}/ - -C 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 for details. - -=head3 qr/\b{sb}/ - -C stands for Sentence Boundary. It is a Unicode property -to aid in parsing natural language sentences. -See L for details. - -=head2 C covers more and is lexical - -Previously running C 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 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 for more information. - -=head2 C - -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 warning. -See L<'strict' in re|re/'strict' mode>. - -=head2 C now ignores any Unicode pattern white space - -The C 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. - -=head2 S> can restrict which locale categories are affected - -It is now possible to pass a parameter to S> to specify -a subset of locale categories to be locale-aware, with the remaining -ones unaffected. See L 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|perllocale/The localeconv function> -includes the international currency fields added by that version of the -POSIX standard. These are -C, -C, -C, -C, -C, -and -C. - -=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 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. It will warn unless the C -warnings category is disabled. - -See L - -=head2 C with no arguments - -C 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. - -=head2 C now works on directory handles - -When the relevant support is available in the operating system, the -C 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 on a directory handle -continues to return the undefined value, as before, but also sets C<$!> to -indicate that the operation is not supported. - -Currently, this uses either a C member in the OS C -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 on Win32, since the Win32 API doesn't accept program arguments -as a list. - -=head2 C now sets C<$!> - -When an I/O error occurs, the fact that there has been an error is recorded -in the handle. C returns false for such a handle. Previously, the -value of C<$!> would be untouched by C, so the common convention of -writing C did not work reliably. Now the handle -records the value of C<$!>, too, and C 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 and -C. - -See also the L 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. - -=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. - -Also included is a C API to retrieve backtraces. - -See L for more information. - -=head1 Security - -=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 module could allow outside packages to be replaced - -Critical bugfix: outside packages could be replaced. L has -been patched to 2.38 to address this. - -=head2 Perl is now always compiled with -D_FORTIFY_SOURCE=2 if available - -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 - -=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) -and things beginning with C<\&>. Formerly it erroneously also allowed -C 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 are not. -[perl #77860] - -=head2 C is now lexical - -The L 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> is now a fatal error - -Importing functions from C has been deprecated since v5.12, and -is now a fatal error. S> without any arguments is still -allowed. - -=head2 In double-quotish C<\cI>, I must now be a printable ASCII character - -In prior releases, failure to do this raised a deprecation warning. - -=head2 Splitting the tokens C<(?> and C<(*> in regular expressions is -now a fatal compilation error. - -These had been deprecated since v5.18. - -=head2 5 additional characters are treated as white space under C in -regex patterns (unless escaped) - -The use of these characters with C 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 -for the list of the five characters. - -=head2 Comment lines within S> now are ended only by a C<\n> - -S> is an experimental feature, introduced in v5.18. It operates -as if C 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>, 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. - -=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 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 instead, -explicitly using the C operator: the question mark delimiter still -invokes match-once behaviour. - -=head2 C and C 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{"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 - -=head2 Setting C<${^ENCODING}> to anything but C - -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 pragma. - -=head2 C<< /\C/ >> character class - -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. - -=head2 Use of non-graphic characters in single-character variable names - -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>, and affects just the C1 controls (code points 0x80 through -0xFF), NO-BREAK SPACE, and SOFT HYPHEN. - -=head2 Inlining of C with observable side-effects - -In many cases Perl makes sub () { $var } into an inlinable constant -subroutine, capturing the value of $var at the time the C 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. - -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. - -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. - - sub make_constant { - my $var = shift; - return sub () { $var }; # fine - } - - 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 -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 block or C statement inside the sub is ignored, -because it does not become part of the sub's body.) For more complex -cases, such as C 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 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 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 - -This non-graphic character is essentially indistinguishable from a -regular space, and so should not be allowed. See -L. - -=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 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 * - -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 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 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 assignment is now optimised into 4-argument C at the end -of a subroutine (or as the argument to C). 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 operator writes directly to the lexical -variable instead of returning a value that gets copied. This optimisation -has been extended to C, C and C 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, C, etc. - -=item * - -Assignment to an empty list is now sometimes faster. In particular, it -never calls C on tied arguments on the right-hand side, whereas it -used to sometimes. - -=item * - -C is up to 20% faster for non-magical/non-tied scalars containing a -string if it is a non-utf8 string or if C 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 -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 is now subject to constant folding. Moreover, C 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 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 and C in void context are no longer evaluated at -run time. Even a whole sequence of C statements will simply be -skipped over. The same applies to C 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 - -=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 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 and C -(see L) 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 - -=head1 Modules and Pragmata - -XXX All changes to installed files in F, F, F and F -go here. If Module::CoreList is updated, generate an initial draft of the -following sections using F. A paragraph summary -for important changes should then be added by hand. In an ideal world, -dual-life modules would have a F file that could be cribbed. - -[ Within each section, list entries as a =item entry ] - -=head2 New Modules and Pragmata - -=over 4 - -=item * - -XXX - -=back - -=head2 Updated Modules and Pragmata - -=over 4 - -=item * - -L has been upgraded from version A.xx to B.yy. - -=back - -=head2 Removed Modules and Pragmata - -=over 4 - -=item * - -XXX - -=back - -=head1 Documentation - -=head2 New Documentation - -=head3 L - -This document, by Tom Christiansen, provides examples of handling Unicode in -Perl. - -=head2 Changes to Existing Documentation - -=head3 L - -=over 4 - -=item * - -Note that C doesn't do set magic. - -=item * - -C - Fix documentation to mention the use of C instead of -C. - -L<[perl #121869]|https://rt.perl.org/Ticket/Display.html?id=121869> - -=item * - -Clarify where C 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 - -=over 4 - -=item * - -The syntax of single-character variable names has been brought -up-to-date and more fully explained. - -=back - -=head3 L - -=over 4 - -=item * - -This document has been significantly updated in the light of recent -improvements to EBCDIC support. - -=back - -=head3 L - -=over 4 - -=item * - -Mention that C is currently a no-op. - -=item * - -Calling C or C 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 and C may fall back to the shell on -Win32. Only C and C indirect object -syntax will reliably avoid using the shell. - -This has also been noted in L. - -L<[perl #122046]|https://rt.perl.org/Ticket/Display.html?id=122046> - -=back - -=head3 L - -=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 - -=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 C target. - -L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> - -=back - -=head3 L - -=over 4 - -=item * - -Instead of pointing to the module list, we are now pointing to -L. - -=back - -=head3 L - -=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 * - -The conditions for marking an experimental feature as non-experimental are now -set out. - -=back - -=head3 L - -=over 4 - -=item * - -Out-of-date VMS-specific information has been fixed/simplified. - -=back - -=head3 L - -=over 4 - -=item * - -The C modifier has been clarified to note that comments cannot be continued -onto the next line by escaping them. - -=back - -=head3 L - -=over 4 - -=item * - -Added documentation of C<\b{sb}>, C<\b{wb}>, C<\b{gcb}>, and C<\b{g}>. - -=back - -=head3 L - -=over 4 - -=item * - -Clarifications have been added to L -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 (see under L). - -=back - -=head3 L - -=over 4 - -=item * - -Comments added on algorithmic complexity and tied hashes. - -=back - -=head3 L - -=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 - -=over 4 - -=item * - -Update B under -L's -B. - -=back - -=head3 L - -=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 - -=over 4 - -=item * - -Further clarify version number representations and usage. - -=back - -=head3 L - -=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 - -=over 4 - -=item * - -Added a discussion of locale issues in XS code. - -=back - -=head1 Diagnostics - -The following additions or changes have been made to diagnostic output, -including warnings and fatal error messages. For the complete list of -diagnostic messages, see L. - -=head2 New Diagnostics - -=head3 New Errors - -=over 4 - -=item * - -L - -(P) An internal request asked to add a scalar entry to something that -wasn't a symbol table entry. - -=item * - -L - -(F) You tried to use a hash as a reference, as in -C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl E= 5.6.1 -used to allow this syntax, but shouldn't have. - -=item * - -L - -(F) You tried to use an array as a reference, as in -C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl E= 5.6.1 used to -allow this syntax, but shouldn't have. - -=item * - -L - -(F) defined() is not useful on arrays because it -checks for an undefined I value. If you want to see if the -array is empty, just use C for example. - -=item * - -L - -(F) C is not usually right on hashes. - -Although C 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. -These things make C 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): - - if (%hash) { - # not empty - } - -If you had C 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 - -=item * - -L - -=item * - -L - -=item * - -L - -=item * - -L - -(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, but -they could be defined by a translator installed into C<$^H{charnames}>. -See L. - -=item * - -L - -(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, but they -could be defined by a translator installed into C<$^H{charnames}>. -See L. - -=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 - -(F) Something went horribly bad in hexadecimal float handling. - -=item * - -L - -(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 - -(F) The script run under suidperl was somehow illegal. - -=item * - -L in mE%sE|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 mE%sE|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%sE|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. - -=back - -=head3 New Warnings - -=over 4 - -=item * - -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. - -=item * - -L<"%s" is more clearly written simply as "%s" in regex; marked by E-- HERE in mE%sE|perldiag/"%s" is more clearly written simply as "%s" in regex; marked by <-- HERE in mE%sE> - -(W regexp) (only under C> 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 - -(W numeric) The indicated string was fed as an argument to the C<++> operator -which expects either a number or a string matching C. -See L for details. - -=item * - -L-- HERE in mE%sE|perldiag/"Both or neither range ends should be Unicode in regex; marked by <-- HERE in m/%s/"> - -(W regexp) (only under C> 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 - -(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 - -(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, but know that in doing so you are taking -the risk that your code may break in a future Perl version. - -=item * - -L - -(W overflow) You called C with a number that it could not handle: -too large, too small, or NaN. The returned value is C. - -=item * - -L - -(W overflow) The hexadecimal floating point has larger exponent -than the floating point supports. - -=item * - -L - -(W overflow) The hexadecimal floating point has smaller exponent -than the floating point supports. - -=item * - -L - -(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 - -(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 - -(W utf8) You passed an invalid number (like an infinity or not-a-number) to -C. Those are not valid character numbers, so it returned the Unicode -replacement character (U+FFFD). - -=item * - -L - -(W overflow) You called C with a number that it could not handle: -too large, too small, or NaN. The returned value is C. - -=item * - -L - -(W numeric) You tried to execute the -L|perlop/Multiplicative Operators> repetition operator fewer than 0 -times, which doesn't make sense. - -=item * - -L - -(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, but they -could be defined by a translator installed into C<$^H{charnames}>. See -L. - -=item * - -L - -(W numeric) You tried to execute the -L|perlop/Multiplicative Operators> repetition operator C (or -C<-Inf>) or C times, which doesn't make sense. - -=item * - -L - -(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-- HERE in mE%sE|perldiag/"Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by <-- HERE in mE%sE"> - -(W regexp) (only under C> 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|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-- HERE in mE%sE|perldiag/"Ranges of digits should be from the same group in regex; marked by <-- HERE in m/%s/"> - -(W regexp) (only under C> 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 - -(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. - -The warnings category C<< redundant >> is new. See also [RT #121025] - -=item * - -L - -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 Eu for '%s' instead of E%s in regex; marked by E-- HERE in mE%sE|perldiag/"Using Eu for '%s' instead of E%s in regex; marked by <-- HERE in mE%sE" >> - -You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a -portion of a regular expression where the character set modifiers C -or C 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 - -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%sE|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 - -=item * - -L - -(W misc) The "const" attribute has no effect except -on anonymous closure prototypes. You applied it to -a subroutine via L. This is only useful -inside an attribute handler for an anonymous subroutine. - -=item * - -Luse re 'strict'E 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 - -=item * - -L - -(W locale) While in a single-byte locale (I, 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 used to be skipped if the -transliteration contained wide characters, but now they occur regardless of -whether there are wide characters or not: - -Ld modifier in transliteration operator|perldiag/"Useless use of /d modifier in transliteration operator"> - -L - -=item * - -A new C warning category has been created, with the following warning -messages currently in it: - -=over 4 - -=item * - -L - -=item * - -L - -=back - -=back - -=head2 Changes to Existing Diagnostics - -=over 4 - -=item * - -<> 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 -now adds the following note: - - Note that for the C and C (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 - -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%sE|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 -(see under L). - -=item * - -L - -This message has had ': %f' appended to it, to show what the offending floating -point number is. - -=item * - -B reworded as -L. - -=item * - -C with no argument or undef used to warn about a Null filename; now -it dies with C. - -=item * - -L - -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%sE|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 - -=head2 F - -=over 4 - -=item * - -The F 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 - -=over 4 - -=item * - -F now handles hexadecimal constants in the compiler's predefined -macro definitions, as visible in C<$Config{cppsymbols}>. [rt.perl.org -#123784] - -=back - -=head2 L - -=over 4 - -=item * - -No longer depends on non-core module anymore. - -=back - -=head1 Configuration and Compilation - -=over 4 - -=item * - -F now checks for F, F, F, and F. - -=item * - -F 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 for -details. - -=item * - -MurmurHash64A and MurmurHash64B can now be configured as the internal hash -function. - -=item * - -C now supports parallel testing. - -For example: - - TEST_JOBS=9 make test.valgrind - -See L 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 - -=over 4 - -=item * - -F has been added to test that L 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 * - -Tests for performance issues have been added in the file F. - -=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, has been added to test if Inf and NaN are -working correctly. See L. - -=back - -=head1 Platform Support - -=head2 Regained Platforms - -=over 4 - -=item IRIX and Tru64 platforms are working again. - -(Some C failures remain.) - -=item z/OS running EBCDIC Code Page 1047 - -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 NeXTSTEP/OPENSTEP - -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 Platform-Specific Notes - -=over 4 - -=item EBCDIC - -Special handling is required on EBCDIC platforms to get C 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. - -=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 * - -When spawning a subprocess without waiting, the return value is now -the correct PID. - -=item * - -Fix a prototype so linking doesn't fail under the VMS C++ compiler. - -=item * - -C, C, and C detection has been added to -C, environment handling has had some minor changes, and -a fix for legacy feature checking status. - -=back - -=item Win32 - -=over 4 - -=item * - -F 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 again depends on C 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 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 and C configuration options added to -Windows makefiles. - -=item * - -L 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 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 was fixed. Also -opening C, 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, 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 - -=item OpenBSD - -On OpenBSD, Perl will now default to using the system C 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 * - -We now look for the Sun Studio compiler in both F and -F. - -=item * - -Builds on Solaris 10 with C<-Dusedtrace> would fail early since make -didn't follow implied dependencies to build C. Added an -explicit dependency to C. -L<[perl #120120]|https://rt.perl.org/Ticket/Display.html?id=120120> - -=item * - -C options have been cleaned up, hints look for C -as well as C, and support for native C has been added. - -=back - -=back - -=head1 Internal Changes - -=over 4 - -=item * - -Perl 5.21.2 introduced a new build option, C<-DPERL_OP_PARENT>, which causes -the last C pointer to refer back to the parent rather than being -C, 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 * - -On C builds, the C field has been renamed -C 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. - -=item * - -The newly-introduced C flag bit has been renamed C 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 is now only available on C -builds. Using it on a plain build will be a compile-timer error. - -=item * - -Three new macros, C, C, C have -been added, which are intended to be a low-level portable way to set -C / C while also updating C. 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 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 and C where appropriate). - -=item * - -The macro C, added in Perl 5.21.2, has been removed. It didn't -manipulate C and has been superseded by C et al. - -=item * - -The C function now accepts a null C 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 - -=item * - -Macros have been created to allow XS code to better manipulate the POSIX locale -category C. See L. - -=item * - -The previous C et al replacement function, C, has now been -superseded by C. See L 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 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, C, C and C have been added -to the API. - -=item * - -The internal C function in F has been renamed -C and added to the API. - -=item * - -C 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 in an XSUB is forbidden. -CvPADLIST has be reused for a different internal purpose for XSUBs. Guard all -CvPADLIST expressions with C 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. 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. This prevents perl from -recursing infinity if an overloaded object is assigned to any of those -variables. [perl #122445] - -=item * - -C which is marked as public API but undocumented has been -removed from public API. If you use C macro in your XS code to -preextend the mortal stack, you are unaffected by this change. - -=item * - -C, 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. - -=item * - -Internally Perl no longer uses the C flag. C now -returns a true value for anything not marked PADTMP. C 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 function accepts C and C -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 no longer does anything and has been moved to F. - -=item * - -C 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 is a new API function that works like -C, 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. C 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 (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 has been added, which will return true for CVs that -notionally have GVs, but without reifying the GV. C also returns a GV -now for lexical subs. -L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> - -=item * - -Added L. Changing the program's locale should be avoided -by XS code. Nevertheless, certain non-Perl libraries called from XS, such as -C 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 field of OPs are now -auto-generated from data in F. The noticeable effect of this -is that some of the flag output of C might differ slightly, and the -flag output of C may differ considerably (they both use the same set -of labels now). Also in debugging builds, there is a new assert in -C that checks that the op doesn't have any unrecognized flags set in -C. - -=item * - -Added L. -Changing the program's locale should be avoided by XS code. Nevertheless, -certain non-Perl libraries called from XS, such as C 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 deprecated variable C has been removed. - -=item * - -Perl now tries to keep the locale category C 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 would change it. Now such a call will change the -underlying locale of the C 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 for -guidance. - -=item * - -A new macro L|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, C, C, C, -C, C, C, C, -C, C, C, C. - -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 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 and C macros added in an earlier 5.21.x -release have been renamed C and C, following the -existing convention. - -=item * - -A new op class, C, has been added. This is a subclass of -C with an C field added, which points to an array of unions -of C, C etc. It is intended for where an op needs to store more data -than a simple C or whatever. Currently the only op of this type is -C (see below). - -=item * - -A new op has been added, C, 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, C, C and C ops is now performed -by a single C op. It can also handle C, C and -C. A non-simple index expression, such as C<[$i+1]> is still done -using C, and single-level array lookup with a small constant -index is still done using C. - -=back - -=head1 Selected Bug Fixes - -=over 4 - -=item * - -C and C 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 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= >> 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 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 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 in scalar context was not pushing an item on to the stack, resulting -in bugs. (C would print 5.) It has -been fixed to return C. -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 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, 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. 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 acted the same as C. This has been fixed. [rt.perl.org #123836] - -=item * - -Perl 5.14.0 introduced a bug whereby C 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 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. [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 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. - -=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. [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>), -and there must be a string of at least 128 consecutive bytes to match. -[perl #123539] - -=item * - -C now works on very long strings instead of dying with 'Substitution -loop'. [perl #103260] [perl #123071] - -=item * - -C no longer crashes with not-a-number values. [perl #123495] - -=item * - -C<\()> (reference to an empty list) and C 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 with no arguments used to read the previous item on the -stack, so C 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) 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/${EE{})// >>, 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 case in -pp_formline() didn't set the pointer used to mark the chop position, -which led to the C 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), -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 call no longer overwrites existing items on the stack, -causing C<(semctl(-1,0,0,0))[0]> to give an "uninitialized" warning. - -=item * - -C with no space before C 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 -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, C, statement labels, special blocks (C) and pod are now -permitted as the first thing in a C or C block, the block after -C or C (or other functions) returning a handle, and within -C<${...}>, C<@{...}>, etc. [perl #122782] - -=item * - -The repetition operator C now propagates lvalue context to its left-hand -argument when used in contexts like C. That allows -C 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). 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, C, C -and C. - -=item * - -List assignments were sometimes buggy if the same scalar ended up on both -sides of the assignment due to used of C, C or C. The -result would be the wrong value getting assigned. - -=item * - -C (with one argument) was accidentally changed in 5.16 -to mean C. 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. - -=item * - -When C 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 and C 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 or C 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. - -Some subroutines with an explicit C were being made inlinable, -contrary to the documentation, Now C always prevents inlining. - -=item * - -On some systems, such as VMS, C can return a non-ASCII string. If a -scalar assigned to had contained a UTF8 string previously, then C -would not turn off the UTF8 flag, thus corrupting the return value. This -would happen with C<$lexical = crypt ...>. - -=item * - -C no longer calls C twice on a tied first argument. - -=item * - -An unterminated here-doc on the last line of a quote-like operator -(C, C) 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 now returns the data for the program's underlying -locale even when called from outside the scope of S>. - -=item * - -C now works properly on platforms which don't have -C and/or C, 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. - -=item * - -C 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>, 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 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 -instead of C, and so would fail for the vast majority -of devices, leaving C<$!> as C. - -=item * - -C, -C, -and -C -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 in an eval could leave a spurious -C subroutine definition, which would produce a "Subroutine -BEGIN redefined" warning on the next use of C, or other C -block. [perl #122107] - -=item * - -C 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 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 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) 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 and C no longer wipe out constants -of the same name declared by C. 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 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, 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 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 or C) 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 crashing or L 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 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 to treat C like C had the -unfortunate side-effect of also treating C like C, which -it should not. This has been fixed. (Note, however, that C does -not behave like C, 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 syntax (see L and L) -could get confused in the scope of C if C were a constant -whose value contained Latin-1 characters. - -=item * - -Locking and unlocking values via L or C -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 function (which L 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 is one such -example. - -=item * - -C 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. - -=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 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 -Ced in a parent pseudo-process before the C happened caused -memory corruption and a crash in the child pseudo-process (and therefore OS -process). [perl #40565] - -=item * - -Calling C 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 loop could corrupt the -stack, causing lists outside the block to lose elements or have elements -overwritten. This could happen with C and with -lists containing C. [perl #123286] - -=item * - -C now propagates lvalue context, so that -C can modify C<$#foo> through C<$_>. - -=item * - -C no longer dies with "Bizarre copy of ARRAY". -[#123344] - -=item * - -C 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 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, 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 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 - -=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 * - -EBCDIC platforms - -=over 4 - -=item * - -Encode and encoding are mostly broken. - -=item * - -Many cpan modules that are shipped with core show failing tests. - -=item * - -C/C with C<"U0"> format may not work properly. - -=back - -=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 - -=item * - -L version 1.50 - -=item * - -L version 0.25 - -=item * - -L version 1.3130 - -=item * - -L version 1.18 - -=item * - -L version 0.63 - -=item * - -L version 0.009 - -=item * - -L version 2.22 - -=item * - -L version 1.00 - -=item * - -L 0.08 - -=back - -=back - -=head1 Acknowledgements - -XXX Generate this with: - - perl Porting/acknowledgements.pl v5.20.0..HEAD - -=head1 Reporting Bugs - -If you find what you think is a bug, you might check the articles recently -posted to the comp.lang.perl.misc newsgroup and the perl bug database at -https://rt.perl.org/ . There may also be information at -http://www.perl.org/ , the Perl Home Page. - -If you believe you have an unreported bug, please run the L program -included with your release. Be sure to trim your bug down to a tiny but -sufficient test case. Your bug report, along with the output of C, -will be sent off to perlbug@perl.org to be analysed by the Perl porting team. - -If the bug you are reporting has security implications, which make it -inappropriate to send to a publicly archived mailing list, then please send it -to perl5-security-report@perl.org. This points to a closed subscription -unarchived mailing list, which includes all the core committers, who will be -able to help assess the impact of issues, figure out a resolution, and help -co-ordinate the release of patches to mitigate or fix the problem across all -platforms on which Perl is supported. Please only use this address for -security issues in the Perl core, not for modules independently distributed on -CPAN. - -=head1 SEE ALSO - -The F file for an explanation of how to view exhaustive details on -what changed. - -The F file for how to build Perl. - -The F file for general stuff. - -The F and F files for copyright information. - -=cut diff --git a/t/porting/known_pod_issues.dat b/t/porting/known_pod_issues.dat index 44e522c664..6d370df4c7 100644 --- a/t/porting/known_pod_issues.dat +++ b/t/porting/known_pod_issues.dat @@ -93,10 +93,10 @@ HTTP::Lite iconv(1) iconv(3) inetd(8) +invoker IO::Socket::IP IPC::Run IPC::Signal -invoker kill(3) langinfo(3) LaTeX::Encode @@ -276,7 +276,6 @@ pod/perlcygwin.pod Verbatim line length including indents exceeds 79 by 24 pod/perldebguts.pod Verbatim line length including indents exceeds 79 by 34 pod/perldebtut.pod Verbatim line length including indents exceeds 79 by 22 pod/perldebug.pod Verbatim line length including indents exceeds 79 by 3 -pod/perldelta.pod Pod NAME already used 1 pod/perldtrace.pod Verbatim line length including indents exceeds 79 by 26 pod/perlfunc.pod ? Should you be using F<...> or maybe L<...> instead of 1 pod/perlgit.pod Verbatim line length including indents exceeds 79 by 12 @@ -328,4 +327,3 @@ lib/config.pod ? Should you be using L<...> instead of -1 lib/extutils/embed.pm Verbatim line length including indents exceeds 79 by 2 lib/perl5db.pl ? Should you be using L<...> instead of 1 lib/pod/text/overstrike.pm Verbatim line length including indents exceeds 79 by 1 -porting/perl5220delta.pod Pod NAME already used 1 -- cgit v1.2.1