In perl.git, the branch blead has been updated <http://perl5.git.perl.org/perl.git/commitdiff/c0ddbfc2a7cbd57f1a395f7869ba447249bff19b?hp=65039e73c332df6b90e51dd7c59e96b670efe070>
- Log ----------------------------------------------------------------- commit c0ddbfc2a7cbd57f1a395f7869ba447249bff19b Author: Ricardo Signes <[email protected]> Date: Tue May 19 13:38:50 2015 -0400 remove the temporary perl5220delta from Porting ----------------------------------------------------------------------- Summary of changes: 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 ed484a3..4278740 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 46b6b34..0000000 --- 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<perl5200delta>, 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<perlop/Bitwise String -Operators> for details. [rt.perl.org #123466] - -=head2 New double-diamond operator - -C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open -each file in @ARGV. So each element of @ARGV is an actual file name, and -"|foo" won't be treated as a pipe open. - -=head2 New \b boundaries in regular expressions - -=head3 qr/\b{gcb}/ - -C<gcb> stands for Grapheme Cluster Boundary. It is a Unicode property -that finds the boundary between sequences of characters that look like a -single character to a native speaker of a language. Perl has long had -the ability to deal with these through the C<\X> regular escape -sequence. Now, there is an alternative way of handling these. See -L<perlrebackslash/\b{}, \b, \B{}, \B> for details. - -=head3 qr/\b{wb}/ - -C<wb> stands for Word Boundary. It is a Unicode property -that finds the boundary between words. This is similar to the plain -C<\b> (without braces) but is more suitable for natural language -processing. It knows, for example that apostrophes can occur in the -middle of words. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. - -=head3 qr/\b{sb}/ - -C<sb> stands for Sentence Boundary. It is a Unicode property -to aid in parsing natural language sentences. -See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. - -=head2 C<no re> covers more and is lexical - -Previously running C<no re> would only turn off a few things. Now it -turns off all the enabled things. For example, previously, you -couldn't turn off debugging, once enabled, inside the same block. - -=head2 Non-Capturing Regular Expression Flag - -Regular expressions now support a C</n> flag that disables capturing -and filling in C<$1>, C<$2>, etc... inside of groups: - - "hello" =~ /(hi|hello)/n; # $1 is not set - -This is equivalent to putting C<?:> at the beginning of every capturing group. - -See L<perlre/"n"> for more information. - -=head2 C<use re 'strict'> - -This applies stricter syntax rules to regular expression patterns -compiled within its scope, which hopefully will alert you to typos and -other unintentional behavior that backwards-compatibility issues prevent -us from doing in normal regular expression compilations. Because the -behavior of this is subject to change in future Perl releases as we gain -experience, using this pragma will raise a category -C<experimental::re_strict> warning. -See L<'strict' in re|re/'strict' mode>. - -=head2 C<qr/foo/x> now ignores any Unicode pattern white space - -The C</x> regular expression modifier allows the pattern to contain -white space and comments, both of which are ignored, for improved -readability. Until now, not all the white space characters that Unicode -designates for this purpose were handled. The additional ones now -recognized are -U+0085 NEXT LINE, -U+200E LEFT-TO-RIGHT MARK, -U+200F RIGHT-TO-LEFT MARK, -U+2028 LINE SEPARATOR, -and -U+2029 PARAGRAPH SEPARATOR. - -=head2 Unicode 7.0 is now supported - -For details on what is in this release, see -L<http://www.unicode.org/versions/Unicode7.0.0/>. - -=head2 S<C<use locale>> can restrict which locale categories are affected - -It is now possible to pass a parameter to S<C<use locale>> to specify -a subset of locale categories to be locale-aware, with the remaining -ones unaffected. See L<perllocale/The "use locale" pragma> for details. - -=head2 Perl now supports POSIX 2008 locale currency additions. - -On platforms that are able to handle POSIX.1-2008, the -hash returned by -L<C<POSIX::localeconv()>|perllocale/The localeconv function> -includes the international currency fields added by that version of the -POSIX standard. These are -C<int_n_cs_precedes>, -C<int_n_sep_by_space>, -C<int_n_sign_posn>, -C<int_p_cs_precedes>, -C<int_p_sep_by_space>, -and -C<int_p_sign_posn>. - -=head2 Better heuristics on older platforms for determining locale UTF8ness - -On platforms that implement neither the C99 standard nor the POSIX 2001 -standard, determining if the current locale is UTF8 or not depends on -heuristics. These are improved in this release. - -=head2 Aliasing via reference - -Variables and subroutines can now be aliased by assigning to a reference: - - \$c = \$d; - \&x = \&y; - -Or by using a backslash before a C<foreach> iterator variable, which is -perhaps the most useful idiom this feature provides: - - foreach \%hash (@array_of_hash_refs) { ... } - -This feature is experimental and must be enabled via C<use feature -'refaliasing'>. It will warn unless the C<experimental::refaliasing> -warnings category is disabled. - -See L<perlref/Assigning to References> - -=head2 C<prototype> with no arguments - -C<prototype()> with no arguments now infers C<$_>. [perl #123514] - -=head2 New "const" subroutine attribute - -The "const" attribute can be applied to an anonymous subroutine. It causes -it to be executed immediately when it is cloned. Its value is captured and -used to create a new constant subroutine that is returned. This feature is -experimental. See L<perlsub/Constant Functions>. - -=head2 C<fileno> now works on directory handles - -When the relevant support is available in the operating system, the -C<fileno> builtin now works on directory handles, yielding the -underlying file descriptor in the same way as for filehandles. On -operating systems without such support, C<fileno> on a directory handle -continues to return the undefined value, as before, but also sets C<$!> to -indicate that the operation is not supported. - -Currently, this uses either a C<dd_fd> member in the OS C<DIR> -structure, or a dirfd(3) function as specified by POSIX.1-2008. - -=head2 List form of pipe open implemented for Win32 - -The list form of pipe: - - open my $fh, "-|", "program", @arguments; - -is now implemented on Win32. It has the same limitations as C<system -LIST> on Win32, since the Win32 API doesn't accept program arguments -as a list. - -=head2 C<close> now sets C<$!> - -When an I/O error occurs, the fact that there has been an error is recorded -in the handle. C<close> returns false for such a handle. Previously, the -value of C<$!> would be untouched by C<close>, so the common convention of -writing C<close $fh or die $!> did not work reliably. Now the handle -records the value of C<$!>, too, and C<close> restores it. - -=head2 Assignment to list repetition - -C<(...) x ...> can now be used within a list that is assigned to, as long -as the left-hand side is a valid lvalue. This allows C<(undef,undef,$foo) -= that_function()> to be written as C<((undef)x2, $foo) = that_function()>. - -=head2 Infinity and NaN (not-a-number) handling improved - -Floating point values are able to hold the special values infinity (also --infinity), and NaN (not-a-number). Now we more robustly recognize and -propagate the value in computations, and on output normalize them to C<Inf> and -C<NaN>. - -See also the L<POSIX> enhancements. - -=head2 Floating point parsing has been improved - -Parsing and printing of floating point values has been improved. - -As a completely new feature, hexadecimal floating point literals -(like 0x1.23p-4) are now supported, and they can be output with -C<printf %a>. - -=head2 Packing infinity or not-a-number into a character is now fatal - -Before, when trying to pack infinity or not-a-number into a -(signed) character, Perl would warn, and assumed you tried to -pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>, -C<< U+FFFD >> was returned. - -But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>) -result in a fatal error. - -=head2 Experimental C Backtrace API - -Starting from Perl 5.21.1, on some platforms Perl supports retrieving -the C level backtrace (similar to what symbolic debuggers like gdb do). - -The backtrace returns the stack trace of the C call frames, -with the symbol names (function names), the object names (like "perl"), -and if it can, also the source code locations (file:line). - -The supported platforms are Linux and OS X (some *BSD might work at -least partly, but they have not yet been tested). - -The feature needs to be enabled with C<Configure -Dusecbacktrace>. - -Also included is a C API to retrieve backtraces. - -See L<perlhacktips/"C backtrace"> for more information. - -=head1 Security - -=head2 Perl is now compiled with -fstack-protector-strong if available - -Perl has been compiled with the anti-stack-smashing option -C<-fstack-protector> since 5.10.1. Now Perl uses the newer variant -called C<-fstack-protector-strong>, if available. - -=head2 The L<Safe> module could allow outside packages to be replaced - -Critical bugfix: outside packages could be replaced. L<Safe> has -been patched to 2.38 to address this. - -=head2 Perl is now always compiled with -D_FORTIFY_SOURCE=2 if available - -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<sub {...}>) -and things beginning with C<\&>. Formerly it erroneously also allowed -C<undef> and references to array, hashes, and lists. [perl #4539] -[perl #123062] - -The C<\&> prototype was allowing subroutine calls, whereas now it only -allows subroutines. C<&foo> is permitted. C<&foo()> and C<foo()> are not. -[perl #77860] - -=head2 C<use encoding> is now lexical - -The L<encoding> pragma's effect is now limited to lexical scope. This -pragma is deprecated, but in the meantime, it could adversely affect -unrelated modules that are included in the same program. - -=head2 List slices returning empty lists - -List slices return an empty list now only if the original list was empty -(or if there are no indices). Formerly, a list slice would return an empty -list if all indices fell outside the original list. [perl #114498] - -=head2 C<\N{}> with a sequence of multiple spaces is now a fatal error. - -This has been deprecated since v5.18. - -=head2 S<C<use UNIVERSAL '...'>> is now a fatal error - -Importing functions from C<UNIVERSAL> has been deprecated since v5.12, and -is now a fatal error. S<C<"use UNIVERSAL">> without any arguments is still -allowed. - -=head2 In double-quotish C<\cI<X>>, I<X> must now be a printable ASCII character - -In prior releases, failure to do this raised a deprecation warning. - -=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</x> in -regex patterns (unless escaped) - -The use of these characters with C</x> outside bracketed character -classes and when not preceded by a backslash has raised a deprecation -warning since v5.18. Now they will be ignored. See L</"qr/foo/x"> -for the list of the five characters. - -=head2 Comment lines within S<C<(?[ ])>> now are ended only by a C<\n> - -S<C<(?[ ])>> is an experimental feature, introduced in v5.18. It operates -as if C</x> is always enabled. But there was a difference, comment -lines (following a C<#> character) were terminated by anything matching -C<\R> which includes all vertical whitespace, such as form feeds. For -consistency, this is now changed to match what terminates comment lines -outside S<C<(?[ ])>>, namely a C<\n> (even if escaped), which is the -same as what terminates a heredoc string and formats. - -=head2 C<(?[...])> operators now follow standard Perl precedence - -This experimental feature allows set operations in regular expression patterns. -Prior to this, the intersection operator had the same precedence as the other -binary operators. Now it has higher precedence. This could lead to different -outcomes than existing code expects (though the documentation has always noted -that this change might happen, recommending fully parenthesizing the -expressions). See L<perlrecharclass/Extended Bracketed Character Classes>. - -=head2 Omitting % and @ on hash and array names is no longer permitted - -Really old Perl let you omit the @ on array names and the % on hash -names in some spots. This has issued a deprecation warning since Perl -5.0, and is no longer permitted. - -=head2 C<"$!"> text is now in English outside C<"use locale"> scope - -Previously, the text, unlike almost everything else, always came out -based on the current underlying locale of the program. (Also affected -on some systems is C<"$^E>".) For programs that are unprepared to -handle locale, this can cause garbage text to be displayed. It's better -to display text that is translatable via some tool than garbage text -which is much harder to figure out. - -=head2 C<"$!"> text will be returned in UTF-8 when appropriate - -The stringification of C<$!> and C<$^E> will have the UTF-8 flag set -when the text is actually non-ASCII UTF-8. This will enable programs -that are set up to be locale-aware to properly output messages in the -user's native language. Code that needs to continue the 5.20 and -earlier behavior can do the stringification within the scopes of both -'use bytes' and 'use locale ":messages". No other Perl operations will -be affected by locale; only C<$!> and C<$^E> stringification. The -'bytes' pragma causes the UTF-8 flag to not be set, just as in previous -Perl releases. This resolves [perl #112208]. - -=head2 Support for C<?PATTERN?> without explicit operator has been removed - -Starting regular expressions matching only once directly with the -question mark delimiter is now a syntax error, so that the question mark -can be available for use in new operators. Write C<m?PATTERN?> instead, -explicitly using the C<m> operator: the question mark delimiter still -invokes match-once behaviour. - -=head2 C<defined(@array)> and C<defined(%hash)> are now fatal errors - -These have been deprecated since v5.6.1 and have raised deprecation -warnings since v5.16. - -=head2 Using a hash or an array as a reference are now fatal errors. - -For example, C<%foo-E<gt>{"bar"}> now causes a fatal compilation -error. These have been deprecated since before v5.8, and have raised -deprecation warnings since then. - -=head2 Changes to the C<*> prototype - -The C<*> character in a subroutine's prototype used to allow barewords to take -precedence over most, but not all subroutines. It was never consistent and -exhibited buggy behaviour. - -Now it has been changed, so subroutines always take precedence over barewords, -which brings it into conformity with similarly prototyped built-in functions: - - sub splat(*) { ... } - sub foo { ... } - splat(foo); # now always splat(foo()) - splat(bar); # still splat('bar') as before - close(foo); # close(foo()) - close(bar); # close('bar') - -=head1 Deprecations - -=head2 Setting C<${^ENCODING}> to anything but C<undef> - -This variable allows Perl scripts to be written in a non-ASCII, -non-UTF-8 encoding. However, it affects all modules globally, leading -to wrong answers and segmentation faults. New scripts should be written -in UTF-8; old scripts should be converted to UTF-8, which is easily done -with the L<encoding> pragma. - -=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<S<"use -utf8">>, and affects just the C1 controls (code points 0x80 through -0xFF), NO-BREAK SPACE, and SOFT HYPHEN. - -=head2 Inlining of C<sub () { $var }> 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<sub> expression -is evaluated. This can break the closure behaviour in those cases where -$var is subsequently modified. The subroutine won't return the new value. - -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<my> -declaration is enough for Perl to find it suspicious. - -This deprecation warning happens only for a simple variable for the body of -the sub. (A C<BEGIN> block or C<use> statement inside the sub is ignored, -because it does not become part of the sub's body.) For more complex -cases, such as C<sub () { do_something() if 0; $var }> the behaviour has -changed such that inlining does not happen if the variable is modifiable -elsewhere. Such cases should be rare. - -=head2 Use of multiple /x regexp modifiers - -It is now deprecated to say something like any of the following: - - qr/foo/xx; - /(?xax:foo)/; - use re qw(/amxx); - -That is, now C<x> should only occur once in any string of contiguous -regular expression pattern modifiers. We do not believe there are any -occurrences of this in all of CPAN. This is in preparation for a future -Perl release having C</xx> mean to allow white-space for readability in -bracketed character classes (those enclosed in square brackets: -C<[...]>). - -=head2 Using a NO-BREAK space in a character alias for C<\N{...}> is now -deprecated - -This non-graphic character is essentially indistinguishable from a -regular space, and so should not be allowed. See -L<charnames/CUSTOM ALIASES>. - -=head2 A literal C<"{"> should now be escaped in a pattern - -If you want a literal left curly bracket (also called a left brace) in a -regular expression pattern, you should now escape it by either -preceding it with a backslash (C<"\{">) or enclosing it within square -brackets C<"[{]">, or by using C<\Q>; otherwise a deprecation warning -will be raised. This was first announced as forthcoming in the v5.16 -release; it will allow future extensions to the language to happen. - -=head2 Making all warnings fatal is discouraged - -The documentation for L<fatal warnings|warnings/Fatal Warnings> notes that -C<< use warnings FATAL => 'all' >> is discouraged and provides stronger -language about the risks of fatal warnings in general. - -=head1 Performance Enhancements - -=over 4 - -=item * - -If method and class names are known at compile time, hashes are precomputed -to speed up run-time method lookup. Also, compound method names like -C<SUPER::new> are parsed at compile time, to save having to parse them at -run time. - -=item * - -Array and hash lookups (especially nested ones) that use only constants -or simple variables as keys, are now considerably faster. See -L</Internal Changes> for more details. - -=item * - -C<(...)x1>, C<("constant")x0> and C<($scalar)x0> are now optimised in list -context. If the right-hand argument is a constant 1, the repetition -operator disappears. If the right-hand argument is a constant 0, the whole -expressions is optimised to the empty list, so long as the left-hand -argument is a simple scalar or constant. C<(foo())x0> is not optimised. - -=item * - -C<substr> assignment is now optimised into 4-argument C<substr> at the end -of a subroutine (or as the argument to C<return>). Previously, this -optimisation only happened in void context. - -=item * - -Assignment to lexical variables is often optimised away. For instance, in -C<$lexical = chr $foo>, the C<chr> operator writes directly to the lexical -variable instead of returning a value that gets copied. This optimisation -has been extended to C<split>, C<x> and C<vec> on the right-hand side. It -has also been made to work with state variable initialization. - -=item * - -In "\L...", "\Q...", etc., the extra "stringify" op is now optimised away, -making these just as fast as C<lcfirst>, C<quotemeta>, etc. - -=item * - -Assignment to an empty list is now sometimes faster. In particular, it -never calls C<FETCH> on tied arguments on the right-hand side, whereas it -used to sometimes. - -=item * - -C<length> is up to 20% faster for non-magical/non-tied scalars containing a -string if it is a non-utf8 string or if C<use bytes;> is in scope. - -=item * - -Non-magical/non-tied scalars that contain only a floating point value and are -on most Perl builds with 64 bit integers now use 8-32 less bytes of memory -depending on OS. - -=item * - -In C<@array = split>, the assignment can be optimized away with C<split> -writing directly to the array. This optimisation was happening only for -package arrays other than @_ and only -sometimes. Now this optimisation happens -almost all the time. - -=item * - -C<join> is now subject to constant folding. Moreover, C<join> with a -scalar or constant for the separator and a single-item list to join is -simplified to a stringification. The separator doesn't even get evaluated. - -=item * - -C<qq(@array)> is implemented using two ops: a stringify op and a join op. -If the qq contains nothing but a single array, the stringification is -optimized away. - -=item * - -C<our $var> and C<our($s,@a,%h)> in void context are no longer evaluated at -run time. Even a whole sequence of C<our $foo;> statements will simply be -skipped over. The same applies to C<state> variables. - -=item * - -Many internal functions have been refactored to improve performance and reduce -their memory footprints. - -L<[perl #121436]|https://rt.perl.org/Ticket/Display.html?id=121436> -L<[perl #121906]|https://rt.perl.org/Ticket/Display.html?id=121906> -L<[perl #121969]|https://rt.perl.org/Ticket/Display.html?id=121969> - -=item * - -C<-T> and C<-B> filetests will return sooner when an empty file is detected. - -L<perl #121489|https://rt.perl.org/Ticket/Display.html?id=121489> - -=item * - -Refactoring of C<< pp_tied >> and CC<< pp_ref >> for small improvements. - -=item * - -Pathtools don't try to load XS on miniperl. - -=item * - -A typo fix reduces the size of the C<< OP >> structure. - -=item * - -Hash lookups where the key is a constant is faster. - -=item * - -Subroutines with an empty prototype and bodies containing just C<undef> are now -eligible for inlining. -L<[perl #122728]|https://rt.perl.org/Ticket/Display.html?id=122728> - -=item * - -Subroutines in packages no longer need to carry typeglobs around with them. -Declaring a subroutine will now put a simple sub reference in the stash if -possible, saving memory. The typeglobs still notionally exist, so accessing -them will cause the subroutine reference to be upgraded to a typeglob. This -optimization does not currently apply to XSUBs or exported subroutines, and -method calls will undo it, since they cache things in typeglobs. -L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> - -=item * - -The functions C<utf8::native_to_unicode()> and C<utf8::unicode_to_native()> -(see L<utf8>) are now optimized out on ASCII platforms. There is now not even -a minimal performance hit in writing code portable between ASCII and EBCDIC -platforms. - -=item * - -Win32 Perl uses 8 KB less of per-process memory than before for every perl -process of this version. This data is now memory mapped from disk and shared -between perl processes from the same perl binary. - -=back - -=head1 Modules and Pragmata - -XXX All changes to installed files in F<cpan/>, F<dist/>, F<ext/> and F<lib/> -go here. If Module::CoreList is updated, generate an initial draft of the -following sections using F<Porting/corelist-perldelta.pl>. A paragraph summary -for important changes should then be added by hand. In an ideal world, -dual-life modules would have a F<Changes> 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<XXX> 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<perlunicook> - -This document, by Tom Christiansen, provides examples of handling Unicode in -Perl. - -=head2 Changes to Existing Documentation - -=head3 L<perlapi> - -=over 4 - -=item * - -Note that C<SvSetSV> doesn't do set magic. - -=item * - -C<sv_usepvn_flags> - Fix documentation to mention the use of C<NewX> instead of -C<malloc>. - -L<[perl #121869]|https://rt.perl.org/Ticket/Display.html?id=121869> - -=item * - -Clarify where C<NUL> may be embedded or is required to terminate a string. - -=item * - -Previously missing documentation due to formatting errors are now included. - -=item * - -Entries are now organized into groups rather than by file where they are found. - -=item * - -Alphabetical sorting of entries is now handled by the POD generator to make -entries easier to find when scanning. - -=back - -=head3 L<perldata> - -=over 4 - -=item * - -The syntax of single-character variable names has been brought -up-to-date and more fully explained. - -=back - -=head3 L<perlebcdic> - -=over 4 - -=item * - -This document has been significantly updated in the light of recent -improvements to EBCDIC support. - -=back - -=head3 L<perlfunc> - -=over 4 - -=item * - -Mention that C<study()> is currently a no-op. - -=item * - -Calling C<delete> or C<exists> on array values is now described as "strongly -discouraged" rather than "deprecated". - -=item * - -Improve documentation of C<< our >>. - -=item * - -C<-l> now notes that it will return false if symlinks aren't supported by the -file system. - -L<[perl #121523]|https://rt.perl.org/Ticket/Display.html?id=121523> - -=item * - -Note that C<exec LIST> and C<system LIST> may fall back to the shell on -Win32. Only C<exec PROGRAM LIST> and C<system PROGRAM LIST> indirect object -syntax will reliably avoid using the shell. - -This has also been noted in L<perlport>. - -L<[perl #122046]|https://rt.perl.org/Ticket/Display.html?id=122046> - -=back - -=head3 L<perlguts> - -=over 4 - -=item * - -The OOK example has been updated to account for COW changes and a change in the -storage of the offset. - -=item * - -Details on C level symbols and libperl.t added. - -=back - -=head3 L<perlhacktips> - -=over 4 - -=item * - -Documentation has been added illustrating the perils of assuming the contents -of static memory pointed to by the return values of Perl wrappers for C library -functions doesn't change. - -=item * - -Recommended replacements for tmpfile, atoi, strtol, and strtoul added. - -=item * - -Updated documentation for the C<test.valgrind> C<make> target. - -L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> - -=back - -=head3 L<perlmodstyle> - -=over 4 - -=item * - -Instead of pointing to the module list, we are now pointing to -L<PrePAN|http://prepan.org/>. - -=back - -=head3 L<perlpolicy> - -=over 4 - -=item * - -We now have a code of conduct for the I<< p5p >> mailing list, as documented -in L<< perlpolicy/STANDARDS OF CONDUCT >>. - -=item * - -The conditions for marking an experimental feature as non-experimental are now -set out. - -=back - -=head3 L<perlport> - -=over 4 - -=item * - -Out-of-date VMS-specific information has been fixed/simplified. - -=back - -=head3 L<perlre> - -=over 4 - -=item * - -The C</x> modifier has been clarified to note that comments cannot be continued -onto the next line by escaping them. - -=back - -=head3 L<perlrebackslash> - -=over 4 - -=item * - -Added documentation of C<\b{sb}>, C<\b{wb}>, C<\b{gcb}>, and C<\b{g}>. - -=back - -=head3 L<perlrecharclass> - -=over 4 - -=item * - -Clarifications have been added to L<perlrecharclass/Character Ranges> -to the effect that Perl guarantees that C<[A-Z]>, C<[a-z]>, C<[0-9]> and -any subranges thereof in regular expression bracketed character classes -are guaranteed to match exactly what a naive English speaker would -expect them to match, even on platforms (such as EBCDIC) where special -handling is required to accomplish this. - -=item * - -The documentation of Bracketed Character Classes has been expanded to cover the -improvements in C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>). - -=back - -=head3 L<perlsec> - -=over 4 - -=item * - -Comments added on algorithmic complexity and tied hashes. - -=back - -=head3 L<perlsyn> - -=over 4 - -=item * - -An ambiguity in the documentation of the C<...> statement has been corrected. -L<[perl #122661]|https://rt.perl.org/Ticket/Display.html?id=122661> - -=item * - -The empty conditional in C<< for >> and C<< while >> is now documented -in L<< perlsyn >>. - -=back - -=head3 L<perlunicode> - -=over 4 - -=item * - -Update B<Default Word Boundaries> under -L<perlunicode/"Unicode Regular Expression Support Level">'s -B<Extended Unicode Support>. - -=back - -=head3 L<perluniintro> - -=over 4 - -=item * - -Advice for how to make sure your strings and regular expression patterns are -interpreted as Unicode has been revised to account for the new Perl 5.22 EBCDIC -handling. - -=back - -=head3 L<perlvar> - -=over 4 - -=item * - -Further clarify version number representations and usage. - -=back - -=head3 L<perlvms> - -=over 4 - -=item * - -Out-of-date and/or incorrect material has been removed. - -=item * - -Updated documentation on environment and shell interaction in VMS. - -=back - -=head3 L<perlxs> - -=over 4 - -=item * - -Added a discussion of locale issues in XS code. - -=back - -=head1 Diagnostics - -The following additions or changes have been made to diagnostic output, -including warnings and fatal error messages. For the complete list of -diagnostic messages, see L<perldiag>. - -=head2 New Diagnostics - -=head3 New Errors - -=over 4 - -=item * - -L<Bad symbol for scalar|perldiag/"Bad symbol for scalar"> - -(P) An internal request asked to add a scalar entry to something that -wasn't a symbol table entry. - -=item * - -L<Can't use a hash as a reference|perldiag/"Can't use a hash as a reference"> - -(F) You tried to use a hash as a reference, as in -C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl E<lt>= 5.6.1 -used to allow this syntax, but shouldn't have. - -=item * - -L<Can't use an array as a reference|perldiag/"Can't use an array as a reference"> - -(F) You tried to use an array as a reference, as in -C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl E<lt>= 5.6.1 used to -allow this syntax, but shouldn't have. - -=item * - -L<Can't use 'defined(@array)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(@array)' (Maybe you should just omit the defined()?)"> - -(F) defined() is not useful on arrays because it -checks for an undefined I<scalar> value. If you want to see if the -array is empty, just use C<if (@array) { # not empty }> for example. - -=item * - -L<Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)"> - -(F) C<defined()> is not usually right on hashes. - -Although C<defined %hash> is false on a plain not-yet-used hash, it -becomes true in several non-obvious circumstances, including iterators, -weak references, stash names, even remaining true after C<undef %hash>. -These things make C<defined %hash> fairly useless in practice, so it now -generates a fatal error. - -If a check for non-empty is what you wanted then just put it in boolean -context (see L<perldata/Scalar values>): - - if (%hash) { - # not empty - } - -If you had C<defined %Foo::Bar::QUUX> to check whether such a package -variable exists then that's never really been reliable, and isn't -a good way to enquire about the features of a package, or whether -it's loaded, etc. - -=item * - -L<Cannot chr %f|perldiag/"Cannot chr %f"> - -=item * - -L<Cannot compress %f in pack|perldiag/"Cannot compress %f in pack"> - -=item * - -L<Cannot pack %f with '%c'|perldiag/"Cannot pack %f with '%c'"> - -=item * - -L<Cannot print %f with '%c'|perldiag/"Cannot printf %f with '%c'"> - -=item * - -L<charnames alias definitions may not contain a sequence of multiple spaces|perldiag/"charnames alias definitions may not contain a sequence of multiple spaces"> - -(F) You defined a character name which had multiple space -characters in a row. Change them to single spaces. Usually these -names are defined in the C<:alias> import argument to C<use charnames>, but -they could be defined by a translator installed into C<$^H{charnames}>. -See L<charnames/CUSTOM ALIASES>. - -=item * - -L<charnames alias definitions may not contain trailing white-space|perldiag/"charnames alias definitions may not contain trailing white-space"> - -(F) You defined a character name which ended in a space -character. Remove the trailing space(s). Usually these names are -defined in the C<:alias> import argument to C<use charnames>, but they -could be defined by a translator installed into C<$^H{charnames}>. -See L<charnames/CUSTOM ALIASES>. - -=item * - -L<:const is not permitted on named subroutines|perldiag/":const is not permitted on named subroutines"> - -(F) The "const" attribute causes an anonymous subroutine to be run and -its value captured at the time that it is cloned. Names subroutines are -not cloned like this, so the attribute does not make sense on them. - -=item * - -L<Hexadecimal float: internal error|perldiag/"Hexadecimal float: internal error"> - -(F) Something went horribly bad in hexadecimal float handling. - -=item * - -L<Hexadecimal float: unsupported long double format|perldiag/"Hexadecimal float: unsupported long double format"> - -(F) You have configured Perl to use long doubles but -the internals of the long double format are unknown, -therefore the hexadecimal float output is impossible. - -=item * - -L<Illegal suidscript|perldiag/"Illegal suidscript"> - -(F) The script run under suidperl was somehow illegal. - -=item * - -L<In '(?...)', the '(' and '?' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(?...)', the '(' and '?' must be adjacent in regex; marked by <-- HERE in m/%s/"> - -(F) The two-character sequence C<"(?"> in -this context in a regular expression pattern should be an -indivisible token, with nothing intervening between the C<"("> -and the C<"?">, but you separated them. - -=item * - -L<In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by <-- HERE in m/%s ... [3 chars truncated] - -(F) The two-character sequence C<"(*"> in -this context in a regular expression pattern should be an -indivisible token, with nothing intervening between the C<"("> -and the C<"*">, but you separated them. - -=item * - -L<Invalid quantifier in {,} in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/"> - -(F) The pattern looks like a {min,max} quantifier, but the min or max could not -be parsed as a valid number - either it has leading zeroes, or it represents -too big a number to cope with. The S<<-- HERE> shows where in the regular -expression the problem was discovered. See L<perlre>. - -=back - -=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<perlrebackslash/\b{}, \b, \B{}, \B>. - -=item * - -L<"%s" is more clearly written simply as "%s" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"%s" is more clearly written simply as "%s" in regex; marked by <-- HERE in mE<sol>%sE<sol>> - -(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) - -You specified a character that has the given plainer way of writing it, -and which is also portable to platforms running with different character -sets. - -=item * - -L<Argument "%s" treated as 0 in increment (++)|perldiag/"Argument "%s" treated -as 0 in increment (++)"> - -(W numeric) The indicated string was fed as an argument to the C<++> operator -which expects either a number or a string matching C</^[a-zA-Z]*[0-9]*\z/>. -See L<perlop/Auto-increment and Auto-decrement> for details. - -=item * - -L<Both or neither range ends should be Unicode in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Both or neither range ends should be Unicode in regex; marked by <-- HERE in m/%s/"> - -(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) - -In a bracketed character class in a regular expression pattern, you -had a range which has exactly one end of it specified using C<\N{}>, and -the other end is specified using a non-portable mechanism. Perl treats -the range as a Unicode range, that is, all the characters in it are -considered to be the Unicode characters, and which may be different code -points on some platforms Perl runs on. For example, C<[\N{U+06}-\x08]> -is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it -matches the characters whose code points in Unicode are 6, 7, and 8. -But that C<\x08> might indicate that you meant something different, so -the warning gets raised. - -=item * - -L<Character in 'C' format overflow in pack|perldiag/"Character in 'C' format overflow in pack"> - -(W pack) You tried converting an infinity or not-a-number to an unsigned -character, which makes no sense. Perl behaved as if you tried to pack 0xFF. - -=item * - -L<Character in 'c' format overflow in pack|perldiag/"Character in 'c' format overflow in pack"> - -(W pack) You tried converting an infinity or not-a-number to a signed -character, which makes no sense. Perl behaved as if you tried to pack 0xFF. - -=item * - -L<:const is experimental|perldiag/":const is experimental"> - -(S experimental::const_attr) The "const" attribute is experimental. -If you want to use the feature, disable the warning with C<no warnings -'experimental::const_attr'>, but know that in doing so you are taking -the risk that your code may break in a future Perl version. - -=item * - -L<gmtime(%f) failed|perldiag/"gmtime(%f) failed"> - -(W overflow) You called C<gmtime> with a number that it could not handle: -too large, too small, or NaN. The returned value is C<undef>. - -=item * - -L<Hexadecimal float: exponent overflow|perldiag/"Hexadecimal float: exponent overflow"> - -(W overflow) The hexadecimal floating point has larger exponent -than the floating point supports. - -=item * - -L<Hexadecimal float: exponent underflow|perldiag/"Hexadecimal float: exponent underflow"> - -(W overflow) The hexadecimal floating point has smaller exponent -than the floating point supports. - -=item * - -L<Hexadecimal float: mantissa overflow|perldiag/"Hexadecimal float: mantissa overflow"> - -(W overflow) The hexadecimal floating point literal had more bits in -the mantissa (the part between the 0x and the exponent, also known as -the fraction or the significand) than the floating point supports. - -=item * - -L<Hexadecimal float: precision loss|perldiag/"Hexadecimal float: precision loss"> - -(W overflow) The hexadecimal floating point had internally more -digits than could be output. This can be caused by unsupported -long double formats, or by 64-bit integers not being available -(needed to retrieve the digits under some configurations). - -L<Invalid number (%f) in chr|perldiag/"Invalid number (%f) in chr"> - -(W utf8) You passed an invalid number (like an infinity or not-a-number) to -C<chr>. Those are not valid character numbers, so it returned the Unicode -replacement character (U+FFFD). - -=item * - -L<localtime(%f) failed|perldiag/"localtime(%f) failed"> - -(W overflow) You called C<localtime> with a number that it could not handle: -too large, too small, or NaN. The returned value is C<undef>. - -=item * - -L<Negative repeat count does nothing|perldiag/"Negative repeat count does nothing"> - -(W numeric) You tried to execute the -L<C<x>|perlop/Multiplicative Operators> repetition operator fewer than 0 -times, which doesn't make sense. - -=item * - -L<NO-BREAK SPACE in a charnames alias definition is deprecated|perldiag/"NO-BREAK SPACE in a charnames alias definition is deprecated"> - -(D deprecated) You defined a character name which contained a no-break -space character. Change it to a regular space. Usually these names are -defined in the C<:alias> import argument to C<use charnames>, but they -could be defined by a translator installed into C<$^H{charnames}>. See -L<charnames/CUSTOM ALIASES>. - -=item * - -L<Non-finite repeat count does nothing|perldiag/"Non-finite repeat count does nothing"> - -(W numeric) You tried to execute the -L<C<x>|perlop/Multiplicative Operators> repetition operator C<Inf> (or -C<-Inf>) or C<NaN> times, which doesn't make sense. - -=item * - -L<PerlIO layer ':win32' is experimental|perldiag/"PerlIO layer ':win32' is experimental"> - -(S experimental::win32_perlio) The C<:win32> PerlIO layer is -experimental. If you want to take the risk of using this layer, -simply disable this warning: - - no warnings "experimental::win32_perlio"; - -=item * - -L<Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of ASCII printables should be some subset of "0-9", " ... [64 chars truncated] - -(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) - -Stricter rules help to find typos and other errors. Perhaps you didn't -even intend a range here, if the C<"-"> was meant to be some other -character, or should have been escaped (like C<"\-">). If you did -intend a range, the one that was used is not portable between ASCII and -EBCDIC platforms, and doesn't have an obvious meaning to a casual -reader. - - [3-7] # OK; Obvious and portable - [d-g] # OK; Obvious and portable - [A-Y] # OK; Obvious and portable - [A-z] # WRONG; Not portable; not clear what is meant - [a-Z] # WRONG; Not portable; not clear what is meant - [%-.] # WRONG; Not portable; not clear what is meant - [\x41-Z] # WRONG; Not portable; not obvious to non-geek - -(You can force portability by specifying a Unicode range, which means that -the endpoints are specified by -L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may -still not be obvious.) -The stricter rules require that ranges that start or stop with an ASCII -character that is not a control have all their endpoints be the literal -character, and not some escape sequence (like C<"\x41">), and the ranges -must be all digits, or all uppercase letters, or all lowercase letters. - -=item * - -L<Ranges of digits should be from the same group in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of digits should be from the same group in regex; marked by <-- HERE in m/%s/"> - -(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) - -Stricter rules help to find typos and other errors. You included a -range, and at least one of the end points is a decimal digit. Under the -stricter rules, when this happens, both end points should be digits in -the same group of 10 consecutive digits. - -=item * - -L<Redundant argument in %s|perldiag/Redundant argument in %s> - -(W redundant) You called a function with more arguments than other -arguments you supplied indicated would be needed. Currently only -emitted when a printf-type format required fewer arguments than were -supplied, but might be used in the future for e.g. L<perlfunc/pack>. - -The warnings category C<< redundant >> is new. See also [RT #121025] - -=item * - -L<Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale|perldiag/"Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale"> - -You are matching a regular expression using locale rules, -and a Unicode boundary is being matched, but the locale is not a Unicode -one. This doesn't make sense. Perl will continue, assuming a Unicode -(UTF-8) locale, but the results could well be wrong except if the locale -happens to be ISO-8859-1 (Latin1) where this message is spurious and can -be ignored. - -=item * - -L<< Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by <-- HERE in mE<sol>%sE<sol> ... [4 chars truncated] - -You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a -portion of a regular expression where the character set modifiers C</a> -or C</aa> are in effect. These two modifiers indicate an ASCII -interpretation, and this doesn't make sense for a Unicode definition. -The generated regular expression will compile so that the boundary uses -all of Unicode. No other portion of the regular expression is affected. - -=item * - -L<The bitwise feature is experimental|perldiag/"The bitwise feature is experimental"> - -This warning is emitted if you use bitwise -operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled. -Simply suppress the warning if you want to use the feature, but know -that in doing so you are taking the risk of using an experimental -feature which may change or be removed in a future Perl version: - - no warnings "experimental::bitwise"; - use feature "bitwise"; - $x |.= $y; - -=item * - -L<Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Unescaped left brace in regex is deprecated, passed through in regex; marked by ... [20 chars truncated] - -(D deprecated, regexp) You used a literal C<"{"> character in a regular -expression pattern. You should change to use C<"\{"> instead, because a future -version of Perl (tentatively v5.26) will consider this to be a syntax error. If -the pattern delimiters are also braces, any matching right brace -(C<"}">) should also be escaped to avoid confusing the parser, for -example, - - qr{abc\{def\}ghi} - -=item * - -L<Use of literal non-graphic characters in variable names is deprecated|perldiag/"Use of literal non-graphic characters in variable names is deprecated"> - -=item * - -L<Useless use of attribute "const"|perldiag/Useless use of attribute "const"> - -(W misc) The "const" attribute has no effect except -on anonymous closure prototypes. You applied it to -a subroutine via L<attributes.pm|attributes>. This is only useful -inside an attribute handler for an anonymous subroutine. - -=item * - -L<E<quot>use re 'strict'E<quot> is experimental|perldiag/"use re 'strict'" is experimental> - -(S experimental::re_strict) The things that are different when a regular -expression pattern is compiled under C<'strict'> are subject to change -in future Perl releases in incompatible ways. This means that a pattern -that compiles today may not in a future Perl release. This warning is -to alert you to that risk. - -=item * - -L<Warning: unable to close filehandle %s properly: %s|perldiag/"Warning: unable to close filehandle %s properly: %s"> - -=item * - -L<Wide character (U+%X) in %s|perldiag/"Wide character (U+%X) in %s"> - -(W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8 -one), a multi-byte character was encountered. Perl considers this -character to be the specified Unicode code point. Combining non-UTF8 -locales and Unicode is dangerous. Almost certainly some characters -will have two different representations. For example, in the ISO 8859-7 -(Greek) locale, the code point 0xC3 represents a Capital Gamma. But so -also does 0x393. This will make string comparisons unreliable. - -You likely need to figure out how this multi-byte character got mixed up -with your single-byte locale (or perhaps you thought you had a UTF-8 -locale, but Perl disagrees). - -=item * - -The following two warnings for C<tr///> used to be skipped if the -transliteration contained wide characters, but now they occur regardless of -whether there are wide characters or not: - -L<Useless use of E<sol>d modifier in transliteration operator|perldiag/"Useless use of /d modifier in transliteration operator"> - -L<Replacement list is longer than search list|perldiag/Replacement list is longer than search list> - -=item * - -A new C<locale> warning category has been created, with the following warning -messages currently in it: - -=over 4 - -=item * - -L<Locale '%s' may not work well.%s|perldiag/Locale '%s' may not work well.%s> - -=item * - -L<Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".|perldiag/Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".> - -=back - -=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<Argument "%s" isn't numeric%s|perldiag/"Argument "%s" isn't numeric%s"> -now adds the following note: - - Note that for the C<Inf> and C<NaN> (infinity and not-a-number) the - definition of "numeric" is somewhat unusual: the strings themselves - (like "Inf") are considered numeric, and anything following them is - considered non-numeric. - -=item * - -L<Global symbol "%s" requires explicit package name|perldiag/"Global symbol "%s" requires explicit package name (did you forget to declare "my %s"?)"> - -This message has had '(did you forget to declare "my %s"?)' appended to it, to -make it more helpful to new Perl programmers. -L<[perl #121638]|https://rt.perl.org/Ticket/Display.html?id=121638> - -=item * - -'"my" variable &foo::bar can't be in a package' has been reworded to say -'subroutine' instead of 'variable'. - -=item * - -L<\N{} in character class restricted to one character in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"\N{} in inverted character class or as a range end-point is restricted to one charac ... [46 chars truncated] - -This message has had 'character class' changed to 'inverted character class or -as a range end-point is' to reflect improvements in C<qr/[\N{named sequence}]/> -(see under L</Selected Bug Fixes>). - -=item * - -L<panic: frexp|perldiag/"panic: frexp: %f"> - -This message has had ': %f' appended to it, to show what the offending floating -point number is. - -=item * - -B<Possible precedence problem on bitwise %c operator> reworded as -L<Possible precedence problem on bitwise %s operator|perldiag/"Possible precedence problem on bitwise %s operator">. - -=item * - -C<require> with no argument or undef used to warn about a Null filename; now -it dies with C<Missing or undefined argument to require>. - -=item * - -L<Unsuccessful %s on filename containing newline|perldiag/"Unsuccessful %s on filename containing newline"> - -This warning is now only produced when the newline is at the end of -the filename. - -=item * - -"Variable %s will not stay shared" has been changed to say "Subroutine" -when it is actually a lexical sub that will not stay shared. - -=item * - -L<Variable length lookbehind not implemented in regex mE<sol>%sE<sol>|perldiag/"Variable length lookbehind not implemented in regex m/%s/"> - -Information about Unicode behaviour has been added. - -=back - -=head2 Diagnostic Removals - -=over - -=item * - -"Ambiguous use of -foo resolved as -&foo()" - -There is actually no ambiguity here, and this impedes the use of negated -constants; e.g., C<-Inf>. - -=item * - -"Constant is not a FOO reference" - -Compile-time checking of constant dereferencing (e.g., C<< my_constant->() >>) -has been removed, since it was not taking overloading into account. -L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> -L<[perl #122607]|https://rt.perl.org/Ticket/Display.html?id=122607> - -=back - -=head1 Utility Changes - -=head2 F<x2p/> - -=over 4 - -=item * - -The F<x2p/> directory has been removed from the Perl core. - -This removes find2perl, s2p and a2p. They have all been released to CPAN as -separate distributions (App::find2perl, App::s2p, App::a2p). - -=back - -=head2 L<h2ph> - -=over 4 - -=item * - -F<h2ph> now handles hexadecimal constants in the compiler's predefined -macro definitions, as visible in C<$Config{cppsymbols}>. [rt.perl.org -#123784] - -=back - -=head2 L<encguess> - -=over 4 - -=item * - -No longer depends on non-core module anymore. - -=back - -=head1 Configuration and Compilation - -=over 4 - -=item * - -F<Configure> now checks for F<lrintl>, F<lroundl>, F<llrintl>, and F<llroundl>. - -=item * - -F<Configure> with C<-Dmksymlinks> should now be faster. [perl #122002] - -=item * - -pthreads and lcl will be linked by default if present. This allows XS modules -that require threading to work on non-threaded perls. Note that you must still -pass C<-Dusethreads> if you want a threaded perl. - -=item * - -For long doubles (to get more precision and range for floating point numbers) -one can now use the GCC quadmath library which implements the quadruple -precision floating point numbers in x86 and ia64 platforms. See F<INSTALL> for -details. - -=item * - -MurmurHash64A and MurmurHash64B can now be configured as the internal hash -function. - -=item * - -C<make test.valgrind> now supports parallel testing. - -For example: - - TEST_JOBS=9 make test.valgrind - -See L<perlhacktips/valgrind> for more information. - -L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> - -=item * - -The MAD (Misc Attribute Decoration) build option has been removed - -This was an unmaintained attempt at preserving -the Perl parse tree more faithfully so that automatic conversion of -Perl 5 to Perl 6 would have been easier. - -This build-time configuration option had been unmaintained for years, -and had probably seriously diverged on both Perl 5 and Perl 6 sides. - -=item * - -A new compilation flag, C<< -DPERL_OP_PARENT >> is available. For details, -see the discussion below at L<< /Internal Changes >>. - -=back - -=head1 Testing - -=over 4 - -=item * - -F<t/porting/re_context.t> has been added to test that L<utf8> and its -dependencies only use the subset of the C<$1..$n> capture vars that -Perl_save_re_context() is hard-coded to localize, because that function has no -efficient way of determining at runtime what vars to localize. - -=item * - -Tests for performance issues have been added in the file F<t/perf/taint.t>. - -=item * - -Some regular expression tests are written in such a way that they will -run very slowly if certain optimizations break. These tests have been -moved into new files, F<< t/re/speed.t >> and F<< t/re/speed_thr.t >>, -and are run with a C<< watchdog() >>. - -=item * - -C<< test.pl >> now allows C<< plan skip_all => $reason >>, to make it -more compatible with C<< Test::More >>. - -=item * - -A new test script, F<op/infnan.t>, has been added to test if Inf and NaN are -working correctly. See L</Infinity and NaN (not-a-number) handling improved>. - -=back - -=head1 Platform Support - -=head2 Regained Platforms - -=over 4 - -=item IRIX and Tru64 platforms are working again. - -(Some C<make test> 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<qr/[i-j]/> to -match only C<"i"> and C<"j">, since there are 7 characters between the -code points for C<"i"> and C<"j">. This special handling had only been -invoked when both ends of the range are literals. Now it is also -invoked if any of the C<\N{...}> forms for specifying a character by -name or Unicode code point is used instead of a literal. See -L<perlrecharclass/Character Ranges>. - -=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<finite>, C<finitel>, and C<isfinite> detection has been added to -C<configure.com>, environment handling has had some minor changes, and -a fix for legacy feature checking status. - -=back - -=item Win32 - -=over 4 - -=item * - -F<miniperl.exe> is now built with C<-fno-strict-aliasing>, allowing 64-bit -builds to complete on GCC 4.8. -L<[perl #123976]|https://rt.perl.org/Ticket/Display.html?id=123976> - -=item * - -C<test-prep> again depends on C<test-prep-gcc> for GCC builds. -L<[perl #124221]|https://rt.perl.org/Ticket/Display.html?id=124221> - -=item * - -Perl can now be built in C++ mode on Windows by setting the makefile macro -C<USE_CPLUSPLUS> to the value "define". - -=item * - -List form pipe open no longer falls back to the shell. - -=item * - -In release 5.21.8 compiling on VC with dmake was broken. Fixed. - -=item * - -New C<DebugSymbols> and C<DebugFull> configuration options added to -Windows makefiles. - -=item * - -L<B> now compiles again on Windows. - -=item * - -Previously, on Visual C++ for Win64 built Perls only, when compiling every Perl -XS module (including CPAN ones) and Perl aware .c file with a 64 bit Visual C++, -would unconditionally have around a dozen warnings from hv_func.h. These -warnings have been silenced. GCC all bitness and Visual C++ for Win32 were -not affected. - -=item * - -Support for building without PerlIO has been removed from the Windows -makefiles. Non-PerlIO builds were all but deprecated in Perl 5.18.0 and are -already not supported by F<Configure> on POSIX systems. - -=item * - -Between 2 and 6 ms and 7 I/O calls have been saved per attempt to open a perl -module for each path in C<@INC>. - -=item * - -Intel C builds are now always built with C99 mode on. - -=item * - -C<%I64d> is now being used instead of C<%lld> for MinGW. - -=item * - -In the experimental C<:win32> layer, a crash in C<open> was fixed. Also -opening C</dev/null>, which works the Win32 Perl's normal C<:unix> layer, was -implemented for C<:win32>. -L<[perl #122224]|https://rt.perl.org/Ticket/Display.html?id=122224> - -=item * - -A new makefile option, C<USE_LONG_DOUBLE>, has been added to the Windows -dmake makefile for gcc builds only. Set this to "define" if you want perl to -use long doubles to give more accuracy and range for floating point numbers. - -=back - -=item OpenBSD - -On OpenBSD, Perl will now default to using the system C<malloc> due to the -security features it provides. Perl's own malloc wrapper has been in use -since v5.14 due to performance reasons, but the OpenBSD project believes -the tradeoff is worth it and would prefer that users who need the speed -specifically ask for it. - -L<[perl #122000]|https://rt.perl.org/Ticket/Display.html?id=122000>. - -=item Solaris - -=over 4 - -=item * - -We now look for the Sun Studio compiler in both F</opt/solstudio*> and -F</opt/solarisstudio*>. - -=item * - -Builds on Solaris 10 with C<-Dusedtrace> would fail early since make -didn't follow implied dependencies to build C<perldtrace.h>. Added an -explicit dependency to C<depend>. -L<[perl #120120]|https://rt.perl.org/Ticket/Display.html?id=120120> - -=item * - -C<c99> options have been cleaned up, hints look for C<solstudio> -as well as C<SUNWspro>, and support for native C<setenv> has been added. - -=back - -=back - -=head1 Internal Changes - -=over 4 - -=item * - -Perl 5.21.2 introduced a new build option, C<-DPERL_OP_PARENT>, which causes -the last C<op_sibling> pointer to refer back to the parent rather than being -C<NULL>, and where instead a new flag indicates the end of the chain. In this -release, the new implementation has been revised; in particular: - -=over 4 - -=item * - -On C<PERL_OP_PARENT> builds, the C<op_sibling> field has been renamed -C<op_sibparent> to reflect its new dual purpose. Since the intention is that -this field should primarily be accessed via macros, this change should be -transparent for code written to work under C<PERL_OP_PARENT>. - -=item * - -The newly-introduced C<op_lastsib> flag bit has been renamed C<op_moresib> and -its logic inverted; i.e. it is initialised to zero in a new op, and is changed -to 1 when an op gains a sibling. - -=item * - -The function C<Perl_op_parent> is now only available on C<PERL_OP_PARENT> -builds. Using it on a plain build will be a compile-timer error. - -=item * - -Three new macros, C<OpMORESIB_set>, C<OpLASTSIB_set>, C<OpMAYBESIB_set> have -been added, which are intended to be a low-level portable way to set -C<op_sibling> / C<op_sibparent> while also updating C<op_moresib>. The first -sets the sibling pointer to a new sibling, the second makes the op the last -sibling, and the third conditionally does the first or second action. The -C<op_sibling_splice()> function is retained as a higher-level interface that -can also maintain consistency in the parent at the same time (e.g. by updating -C<op_first> and C<op_last> where appropriate). - -=item * - -The macro C<OpSIBLING_set>, added in Perl 5.21.2, has been removed. It didn't -manipulate C<op_moresib> and has been superseded by C<OpMORESIB_set> et al. - -=item * - -The C<op_sibling_splice> function now accepts a null C<parent> argument where -the splicing doesn't affect the first or last ops in the sibling chain, and -thus where the parent doesn't need to be updated accordingly. - -=back - -=item * - -Macros have been created to allow XS code to better manipulate the POSIX locale **** PATCH TRUNCATED AT 2000 LINES -- 1273 NOT SHOWN **** -- Perl5 Master Repository
