| 1 | =encoding utf8 |
| 2 | |
| 3 | =head1 NAME |
| 4 | |
| 5 | perl5220delta - what is new for perl v5.22.0 |
| 6 | |
| 7 | =head1 DESCRIPTION |
| 8 | |
| 9 | This document describes differences between the 5.20.0 release and the 5.22.0 |
| 10 | release. |
| 11 | |
| 12 | If you are upgrading from an earlier release such as 5.18.0, first read |
| 13 | L<perl5200delta>, which describes differences between 5.18.0 and 5.20.0. |
| 14 | |
| 15 | =head1 Core Enhancements |
| 16 | |
| 17 | =head2 New bitwise operators |
| 18 | |
| 19 | A new experimental facility has been added that makes the four standard |
| 20 | bitwise operators (C<& | ^ ~>) treat their operands consistently as |
| 21 | numbers, and introduces four new dotted operators (C<&. |. ^. ~.>) that |
| 22 | treat their operands consistently as strings. The same applies to the |
| 23 | assignment variants (C<&= |= ^= &.= |.= ^.=>). |
| 24 | |
| 25 | To use this, enable the "bitwise" feature and disable the |
| 26 | "experimental::bitwise" warnings category. See L<perlop/Bitwise String |
| 27 | Operators> for details. |
| 28 | L<[perl #123466]|https://rt.perl.org/Ticket/Display.html?id=123466>. |
| 29 | |
| 30 | =head2 New double-diamond operator |
| 31 | |
| 32 | C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open |
| 33 | each file in C<@ARGV>. This means that each element of C<@ARGV> will be treated |
| 34 | as an actual file name, and C<"|foo"> won't be treated as a pipe open. |
| 35 | |
| 36 | =head2 New C<\b> boundaries in regular expressions |
| 37 | |
| 38 | =head3 C<qr/\b{gcb}/> |
| 39 | |
| 40 | C<gcb> stands for Grapheme Cluster Boundary. It is a Unicode property |
| 41 | that finds the boundary between sequences of characters that look like a |
| 42 | single character to a native speaker of a language. Perl has long had |
| 43 | the ability to deal with these through the C<\X> regular escape |
| 44 | sequence. Now, there is an alternative way of handling these. See |
| 45 | L<perlrebackslash/\b{}, \b, \B{}, \B> for details. |
| 46 | |
| 47 | =head3 C<qr/\b{wb}/> |
| 48 | |
| 49 | C<wb> stands for Word Boundary. It is a Unicode property |
| 50 | that finds the boundary between words. This is similar to the plain |
| 51 | C<\b> (without braces) but is more suitable for natural language |
| 52 | processing. It knows, for example, that apostrophes can occur in the |
| 53 | middle of words. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. |
| 54 | |
| 55 | =head3 C<qr/\b{sb}/> |
| 56 | |
| 57 | C<sb> stands for Sentence Boundary. It is a Unicode property |
| 58 | to aid in parsing natural language sentences. |
| 59 | See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. |
| 60 | |
| 61 | =head2 Non-Capturing Regular Expression Flag |
| 62 | |
| 63 | Regular expressions now support a C</n> flag that disables capturing |
| 64 | and filling in C<$1>, C<$2>, etc inside of groups: |
| 65 | |
| 66 | "hello" =~ /(hi|hello)/n; # $1 is not set |
| 67 | |
| 68 | This is equivalent to putting C<?:> at the beginning of every capturing group. |
| 69 | |
| 70 | See L<perlre/"n"> for more information. |
| 71 | |
| 72 | =head2 C<use re 'strict'> |
| 73 | |
| 74 | This applies stricter syntax rules to regular expression patterns |
| 75 | compiled within its scope. This will hopefully alert you to typos and |
| 76 | other unintentional behavior that backwards-compatibility issues prevent |
| 77 | us from reporting in normal regular expression compilations. Because the |
| 78 | behavior of this is subject to change in future Perl releases as we gain |
| 79 | experience, using this pragma will raise a warning of category |
| 80 | C<experimental::re_strict>. |
| 81 | See L<'strict' in re|re/'strict' mode>. |
| 82 | |
| 83 | =head2 Unicode 7.0 (with correction) is now supported |
| 84 | |
| 85 | For details on what is in this release, see |
| 86 | L<http://www.unicode.org/versions/Unicode7.0.0/>. |
| 87 | The version of Unicode 7.0 that comes with Perl includes |
| 88 | a correction dealing with glyph shaping in Arabic |
| 89 | (see L<http://www.unicode.org/errata/#current_errata>). |
| 90 | |
| 91 | |
| 92 | =head2 S<C<use locale>> can restrict which locale categories are affected |
| 93 | |
| 94 | It is now possible to pass a parameter to S<C<use locale>> to specify |
| 95 | a subset of locale categories to be locale-aware, with the remaining |
| 96 | ones unaffected. See L<perllocale/The "use locale" pragma> for details. |
| 97 | |
| 98 | =head2 Perl now supports POSIX 2008 locale currency additions |
| 99 | |
| 100 | On platforms that are able to handle POSIX.1-2008, the |
| 101 | hash returned by |
| 102 | L<C<POSIX::localeconv()>|perllocale/The localeconv function> |
| 103 | includes the international currency fields added by that version of the |
| 104 | POSIX standard. These are |
| 105 | C<int_n_cs_precedes>, |
| 106 | C<int_n_sep_by_space>, |
| 107 | C<int_n_sign_posn>, |
| 108 | C<int_p_cs_precedes>, |
| 109 | C<int_p_sep_by_space>, |
| 110 | and |
| 111 | C<int_p_sign_posn>. |
| 112 | |
| 113 | =head2 Better heuristics on older platforms for determining locale UTF-8ness |
| 114 | |
| 115 | On platforms that implement neither the C99 standard nor the POSIX 2001 |
| 116 | standard, determining if the current locale is UTF-8 or not depends on |
| 117 | heuristics. These are improved in this release. |
| 118 | |
| 119 | =head2 Aliasing via reference |
| 120 | |
| 121 | Variables and subroutines can now be aliased by assigning to a reference: |
| 122 | |
| 123 | \$c = \$d; |
| 124 | \&x = \&y; |
| 125 | |
| 126 | Aliasing can also be accomplished |
| 127 | by using a backslash before a C<foreach> iterator variable; this is |
| 128 | perhaps the most useful idiom this feature provides: |
| 129 | |
| 130 | foreach \%hash (@array_of_hash_refs) { ... } |
| 131 | |
| 132 | This feature is experimental and must be enabled via S<C<use feature |
| 133 | 'refaliasing'>>. It will warn unless the C<experimental::refaliasing> |
| 134 | warnings category is disabled. |
| 135 | |
| 136 | See L<perlref/Assigning to References> |
| 137 | |
| 138 | =head2 C<prototype> with no arguments |
| 139 | |
| 140 | C<prototype()> with no arguments now infers C<$_>. |
| 141 | L<[perl #123514]|https://rt.perl.org/Ticket/Display.html?id=123514>. |
| 142 | |
| 143 | =head2 New C<:const> subroutine attribute |
| 144 | |
| 145 | The C<const> attribute can be applied to an anonymous subroutine. It |
| 146 | causes the new sub to be executed immediately whenever one is created |
| 147 | (I<i.e.> when the C<sub> expression is evaluated). Its value is captured |
| 148 | and used to create a new constant subroutine that is returned. This |
| 149 | feature is experimental. See L<perlsub/Constant Functions>. |
| 150 | |
| 151 | =head2 C<fileno> now works on directory handles |
| 152 | |
| 153 | When the relevant support is available in the operating system, the |
| 154 | C<fileno> builtin now works on directory handles, yielding the |
| 155 | underlying file descriptor in the same way as for filehandles. On |
| 156 | operating systems without such support, C<fileno> on a directory handle |
| 157 | continues to return the undefined value, as before, but also sets C<$!> to |
| 158 | indicate that the operation is not supported. |
| 159 | |
| 160 | Currently, this uses either a C<dd_fd> member in the OS C<DIR> |
| 161 | structure, or a C<dirfd(3)> function as specified by POSIX.1-2008. |
| 162 | |
| 163 | =head2 List form of pipe open implemented for Win32 |
| 164 | |
| 165 | The list form of pipe: |
| 166 | |
| 167 | open my $fh, "-|", "program", @arguments; |
| 168 | |
| 169 | is now implemented on Win32. It has the same limitations as C<system |
| 170 | LIST> on Win32, since the Win32 API doesn't accept program arguments |
| 171 | as a list. |
| 172 | |
| 173 | =head2 Assignment to list repetition |
| 174 | |
| 175 | C<(...) x ...> can now be used within a list that is assigned to, as long |
| 176 | as the left-hand side is a valid lvalue. This allows S<C<(undef,undef,$foo) |
| 177 | = that_function()>> to be written as S<C<((undef)x2, $foo) = that_function()>>. |
| 178 | |
| 179 | =head2 Infinity and NaN (not-a-number) handling improved |
| 180 | |
| 181 | Floating point values are able to hold the special values infinity, negative |
| 182 | infinity, and NaN (not-a-number). Now we more robustly recognize and |
| 183 | propagate the value in computations, and on output normalize them to the strings |
| 184 | C<Inf>, C<-Inf>, and C<NaN>. |
| 185 | |
| 186 | See also the L<POSIX> enhancements. |
| 187 | |
| 188 | =head2 Floating point parsing has been improved |
| 189 | |
| 190 | Parsing and printing of floating point values has been improved. |
| 191 | |
| 192 | As a completely new feature, hexadecimal floating point literals |
| 193 | (like C<0x1.23p-4>) are now supported, and they can be output with |
| 194 | S<C<printf "%a">>. See L<perldata/Scalar value constructors> for more |
| 195 | details. |
| 196 | |
| 197 | =head2 Packing infinity or not-a-number into a character is now fatal |
| 198 | |
| 199 | Before, when trying to pack infinity or not-a-number into a |
| 200 | (signed) character, Perl would warn, and assumed you tried to |
| 201 | pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>, |
| 202 | C<< U+FFFD >> was returned. |
| 203 | |
| 204 | But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>) |
| 205 | result in a fatal error. |
| 206 | |
| 207 | =head2 Experimental C Backtrace API |
| 208 | |
| 209 | Perl now supports (via a C level API) retrieving |
| 210 | the C level backtrace (similar to what symbolic debuggers like gdb do). |
| 211 | |
| 212 | The backtrace returns the stack trace of the C call frames, |
| 213 | with the symbol names (function names), the object names (like "perl"), |
| 214 | and if it can, also the source code locations (file:line). |
| 215 | |
| 216 | The supported platforms are Linux and OS X (some *BSD might work at |
| 217 | least partly, but they have not yet been tested). |
| 218 | |
| 219 | The feature needs to be enabled with C<Configure -Dusecbacktrace>. |
| 220 | |
| 221 | See L<perlhacktips/"C backtrace"> for more information. |
| 222 | |
| 223 | =head1 Security |
| 224 | |
| 225 | =head2 Perl is now compiled with C<-fstack-protector-strong> if available |
| 226 | |
| 227 | Perl has been compiled with the anti-stack-smashing option |
| 228 | C<-fstack-protector> since 5.10.1. Now Perl uses the newer variant |
| 229 | called C<-fstack-protector-strong>, if available. |
| 230 | |
| 231 | =head2 The L<Safe> module could allow outside packages to be replaced |
| 232 | |
| 233 | Critical bugfix: outside packages could be replaced. L<Safe> has |
| 234 | been patched to 2.38 to address this. |
| 235 | |
| 236 | =head2 Perl is now always compiled with C<-D_FORTIFY_SOURCE=2> if available |
| 237 | |
| 238 | The 'code hardening' option called C<_FORTIFY_SOURCE>, available in |
| 239 | gcc 4.*, is now always used for compiling Perl, if available. |
| 240 | |
| 241 | Note that this isn't necessarily a huge step since in many platforms |
| 242 | the step had already been taken several years ago: many Linux |
| 243 | distributions (like Fedora) have been using this option for Perl, |
| 244 | and OS X has enforced the same for many years. |
| 245 | |
| 246 | =head1 Incompatible Changes |
| 247 | |
| 248 | =head2 Subroutine signatures moved before attributes |
| 249 | |
| 250 | The experimental sub signatures feature, as introduced in 5.20, parsed |
| 251 | signatures after attributes. In this release, following feedback from users |
| 252 | of the experimental feature, the positioning has been moved such that |
| 253 | signatures occur after the subroutine name (if any) and before the attribute |
| 254 | list (if any). |
| 255 | |
| 256 | =head2 C<&> and C<\&> prototypes accepts only subs |
| 257 | |
| 258 | The C<&> prototype character now accepts only anonymous subs (C<sub |
| 259 | {...}>), things beginning with C<\&>, or an explicit C<undef>. Formerly |
| 260 | it erroneously also allowed references to arrays, hashes, and lists. |
| 261 | L<[perl #4539]|https://rt.perl.org/Ticket/Display.html?id=4539>. |
| 262 | L<[perl #123062]|https://rt.perl.org/Ticket/Display.html?id=123062>. |
| 263 | L<[perl #123062]|https://rt.perl.org/Ticket/Display.html?id=123475>. |
| 264 | |
| 265 | In addition, the C<\&> prototype was allowing subroutine calls, whereas |
| 266 | now it only allows subroutines: C<&foo> is still permitted as an argument, |
| 267 | while C<&foo()> and C<foo()> no longer are. |
| 268 | L<[perl #77860]|https://rt.perl.org/Ticket/Display.html?id=77860>. |
| 269 | |
| 270 | =head2 C<use encoding> is now lexical |
| 271 | |
| 272 | The L<encoding> pragma's effect is now limited to lexical scope. This |
| 273 | pragma is deprecated, but in the meantime, it could adversely affect |
| 274 | unrelated modules that are included in the same program; this change |
| 275 | fixes that. |
| 276 | |
| 277 | =head2 List slices returning empty lists |
| 278 | |
| 279 | List slices now return an empty list only if the original list was empty |
| 280 | (or if there are no indices). Formerly, a list slice would return an empty |
| 281 | list if all indices fell outside the original list; now it returns a list |
| 282 | of C<undef> values in that case. |
| 283 | L<[perl #114498]|https://rt.perl.org/Ticket/Display.html?id=114498>. |
| 284 | |
| 285 | =head2 C<\N{}> with a sequence of multiple spaces is now a fatal error |
| 286 | |
| 287 | E.g. S<C<\N{TOOE<nbsp>E<nbsp>MANY SPACES}>> or S<C<\N{TRAILING SPACE }>>. |
| 288 | This has been deprecated since v5.18. |
| 289 | |
| 290 | =head2 S<C<use UNIVERSAL '...'>> is now a fatal error |
| 291 | |
| 292 | Importing functions from C<UNIVERSAL> has been deprecated since v5.12, and |
| 293 | is now a fatal error. S<C<use UNIVERSAL>> without any arguments is still |
| 294 | allowed. |
| 295 | |
| 296 | =head2 In double-quotish C<\cI<X>>, I<X> must now be a printable ASCII character |
| 297 | |
| 298 | In prior releases, failure to do this raised a deprecation warning. |
| 299 | |
| 300 | =head2 Splitting the tokens C<(?> and C<(*> in regular expressions is now a fatal compilation error. |
| 301 | |
| 302 | These had been deprecated since v5.18. |
| 303 | |
| 304 | =head2 C<qr/foo/x> now ignores all Unicode pattern white space |
| 305 | |
| 306 | The C</x> regular expression modifier allows the pattern to contain |
| 307 | white space and comments (both of which are ignored) for improved |
| 308 | readability. Until now, not all the white space characters that Unicode |
| 309 | designates for this purpose were handled. The additional ones now |
| 310 | recognized are: |
| 311 | |
| 312 | U+0085 NEXT LINE |
| 313 | U+200E LEFT-TO-RIGHT MARK |
| 314 | U+200F RIGHT-TO-LEFT MARK |
| 315 | U+2028 LINE SEPARATOR |
| 316 | U+2029 PARAGRAPH SEPARATOR |
| 317 | |
| 318 | The use of these characters with C</x> outside bracketed character |
| 319 | classes and when not preceded by a backslash has raised a deprecation |
| 320 | warning since v5.18. Now they will be ignored. |
| 321 | |
| 322 | =head2 Comment lines within S<C<(?[ ])>> are now ended only by a C<\n> |
| 323 | |
| 324 | S<C<(?[ ])>> is an experimental feature, introduced in v5.18. It operates |
| 325 | as if C</x> is always enabled. But there was a difference: comment |
| 326 | lines (following a C<#> character) were terminated by anything matching |
| 327 | C<\R> which includes all vertical whitespace, such as form feeds. For |
| 328 | consistency, this is now changed to match what terminates comment lines |
| 329 | outside S<C<(?[ ])>>, namely a C<\n> (even if escaped), which is the |
| 330 | same as what terminates a heredoc string and formats. |
| 331 | |
| 332 | =head2 C<(?[...])> operators now follow standard Perl precedence |
| 333 | |
| 334 | This experimental feature allows set operations in regular expression patterns. |
| 335 | Prior to this, the intersection operator had the same precedence as the other |
| 336 | binary operators. Now it has higher precedence. This could lead to different |
| 337 | outcomes than existing code expects (though the documentation has always noted |
| 338 | that this change might happen, recommending fully parenthesizing the |
| 339 | expressions). See L<perlrecharclass/Extended Bracketed Character Classes>. |
| 340 | |
| 341 | =head2 Omitting C<%> and C<@> on hash and array names is no longer permitted |
| 342 | |
| 343 | Really old Perl let you omit the C<@> on array names and the C<%> on hash |
| 344 | names in some spots. This has issued a deprecation warning since Perl |
| 345 | 5.000, and is no longer permitted. |
| 346 | |
| 347 | =head2 C<"$!"> text is now in English outside the scope of C<use locale> |
| 348 | |
| 349 | Previously, the text, unlike almost everything else, always came out |
| 350 | based on the current underlying locale of the program. (Also affected |
| 351 | on some systems is C<"$^E">.) For programs that are unprepared to |
| 352 | handle locale differences, this can cause garbage text to be displayed. |
| 353 | It's better to display text that is translatable via some tool than |
| 354 | garbage text which is much harder to figure out. |
| 355 | |
| 356 | =head2 C<"$!"> text will be returned in UTF-8 when appropriate |
| 357 | |
| 358 | The stringification of C<$!> and C<$^E> will have the UTF-8 flag set |
| 359 | when the text is actually non-ASCII UTF-8. This will enable programs |
| 360 | that are set up to be locale-aware to properly output messages in the |
| 361 | user's native language. Code that needs to continue the 5.20 and |
| 362 | earlier behavior can do the stringification within the scopes of both |
| 363 | S<C<use bytes>> and S<C<use locale ":messages">>. Within these two |
| 364 | scopes, no other Perl operations will |
| 365 | be affected by locale; only C<$!> and C<$^E> stringification. The |
| 366 | C<bytes> pragma causes the UTF-8 flag to not be set, just as in previous |
| 367 | Perl releases. This resolves |
| 368 | L<[perl #112208]|https://rt.perl.org/Ticket/Display.html?id=112208>. |
| 369 | |
| 370 | =head2 Support for C<?PATTERN?> without explicit operator has been removed |
| 371 | |
| 372 | The C<m?PATTERN?> construct, which allows matching a regex only once, |
| 373 | previously had an alternative form that was written directly with a question |
| 374 | mark delimiter, omitting the explicit C<m> operator. This usage has produced |
| 375 | a deprecation warning since 5.14.0. It is now a syntax error, so that the |
| 376 | question mark can be available for use in new operators. |
| 377 | |
| 378 | =head2 C<defined(@array)> and C<defined(%hash)> are now fatal errors |
| 379 | |
| 380 | These have been deprecated since v5.6.1 and have raised deprecation |
| 381 | warnings since v5.16. |
| 382 | |
| 383 | =head2 Using a hash or an array as a reference are now fatal errors |
| 384 | |
| 385 | For example, C<< %foo->{"bar"} >> now causes a fatal compilation |
| 386 | error. These have been deprecated since before v5.8, and have raised |
| 387 | deprecation warnings since then. |
| 388 | |
| 389 | =head2 Changes to the C<*> prototype |
| 390 | |
| 391 | The C<*> character in a subroutine's prototype used to allow barewords to take |
| 392 | precedence over most, but not all, subroutine names. It was never |
| 393 | consistent and exhibited buggy behavior. |
| 394 | |
| 395 | Now it has been changed, so subroutines always take precedence over barewords, |
| 396 | which brings it into conformity with similarly prototyped built-in functions: |
| 397 | |
| 398 | sub splat(*) { ... } |
| 399 | sub foo { ... } |
| 400 | splat(foo); # now always splat(foo()) |
| 401 | splat(bar); # still splat('bar') as before |
| 402 | close(foo); # close(foo()) |
| 403 | close(bar); # close('bar') |
| 404 | |
| 405 | =head1 Deprecations |
| 406 | |
| 407 | =head2 Setting C<${^ENCODING}> to anything but C<undef> |
| 408 | |
| 409 | This variable allows Perl scripts to be written in an encoding other than |
| 410 | ASCII or UTF-8. However, it affects all modules globally, leading |
| 411 | to wrong answers and segmentation faults. New scripts should be written |
| 412 | in UTF-8; old scripts should be converted to UTF-8, which is easily done |
| 413 | with the L<piconv> utility. |
| 414 | |
| 415 | =head2 Use of non-graphic characters in single-character variable names |
| 416 | |
| 417 | The syntax for single-character variable names is more lenient than |
| 418 | for longer variable names, allowing the one-character name to be a |
| 419 | punctuation character or even invisible (a non-graphic). Perl v5.20 |
| 420 | deprecated the ASCII-range controls as such a name. Now, all |
| 421 | non-graphic characters that formerly were allowed are deprecated. |
| 422 | The practical effect of this occurs only when not under C<S<use |
| 423 | utf8>>, and affects just the C1 controls (code points 0x80 through |
| 424 | 0xFF), NO-BREAK SPACE, and SOFT HYPHEN. |
| 425 | |
| 426 | =head2 Inlining of C<sub () { $var }> with observable side-effects |
| 427 | |
| 428 | In many cases Perl makes S<C<sub () { $var }>> into an inlinable constant |
| 429 | subroutine, capturing the value of C<$var> at the time the C<sub> expression |
| 430 | is evaluated. This can break the closure behavior in those cases where |
| 431 | C<$var> is subsequently modified, since the subroutine won't return the |
| 432 | changed value. (Note that this all only applies to anonymous subroutines |
| 433 | with an empty prototype (S<C<sub ()>>).) |
| 434 | |
| 435 | This usage is now deprecated in those cases where the variable could be |
| 436 | modified elsewhere. Perl detects those cases and emits a deprecation |
| 437 | warning. Such code will likely change in the future and stop producing a |
| 438 | constant. |
| 439 | |
| 440 | If your variable is only modified in the place where it is declared, then |
| 441 | Perl will continue to make the sub inlinable with no warnings. |
| 442 | |
| 443 | sub make_constant { |
| 444 | my $var = shift; |
| 445 | return sub () { $var }; # fine |
| 446 | } |
| 447 | |
| 448 | sub make_constant_deprecated { |
| 449 | my $var; |
| 450 | $var = shift; |
| 451 | return sub () { $var }; # deprecated |
| 452 | } |
| 453 | |
| 454 | sub make_constant_deprecated2 { |
| 455 | my $var = shift; |
| 456 | log_that_value($var); # could modify $var |
| 457 | return sub () { $var }; # deprecated |
| 458 | } |
| 459 | |
| 460 | In the second example above, detecting that C<$var> is assigned to only once |
| 461 | is too hard to detect. That it happens in a spot other than the C<my> |
| 462 | declaration is enough for Perl to find it suspicious. |
| 463 | |
| 464 | This deprecation warning happens only for a simple variable for the body of |
| 465 | the sub. (A C<BEGIN> block or C<use> statement inside the sub is ignored, |
| 466 | because it does not become part of the sub's body.) For more complex |
| 467 | cases, such as S<C<sub () { do_something() if 0; $var }>> the behavior has |
| 468 | changed such that inlining does not happen if the variable is modifiable |
| 469 | elsewhere. Such cases should be rare. |
| 470 | |
| 471 | =head2 Use of multiple C</x> regexp modifiers |
| 472 | |
| 473 | It is now deprecated to say something like any of the following: |
| 474 | |
| 475 | qr/foo/xx; |
| 476 | /(?xax:foo)/; |
| 477 | use re qw(/amxx); |
| 478 | |
| 479 | That is, now C<x> should only occur once in any string of contiguous |
| 480 | regular expression pattern modifiers. We do not believe there are any |
| 481 | occurrences of this in all of CPAN. This is in preparation for a future |
| 482 | Perl release having C</xx> permit white-space for readability in |
| 483 | bracketed character classes (those enclosed in square brackets: |
| 484 | C<[...]>). |
| 485 | |
| 486 | =head2 Using a NO-BREAK space in a character alias for C<\N{...}> is now deprecated |
| 487 | |
| 488 | This non-graphic character is essentially indistinguishable from a |
| 489 | regular space, and so should not be allowed. See |
| 490 | L<charnames/CUSTOM ALIASES>. |
| 491 | |
| 492 | =head2 A literal C<"{"> should now be escaped in a pattern |
| 493 | |
| 494 | If you want a literal left curly bracket (also called a left brace) in a |
| 495 | regular expression pattern, you should now escape it by either |
| 496 | preceding it with a backslash (C<"\{">) or enclosing it within square |
| 497 | brackets C<"[{]">, or by using C<\Q>; otherwise a deprecation warning |
| 498 | will be raised. This was first announced as forthcoming in the v5.16 |
| 499 | release; it will allow future extensions to the language to happen. |
| 500 | |
| 501 | =head2 Making all warnings fatal is discouraged |
| 502 | |
| 503 | The documentation for L<fatal warnings|warnings/Fatal Warnings> notes that |
| 504 | C<< use warnings FATAL => 'all' >> is discouraged, and provides stronger |
| 505 | language about the risks of fatal warnings in general. |
| 506 | |
| 507 | =head1 Performance Enhancements |
| 508 | |
| 509 | =over 4 |
| 510 | |
| 511 | =item * |
| 512 | |
| 513 | If a method or class name is known at compile time, a hash is precomputed |
| 514 | to speed up run-time method lookup. Also, compound method names like |
| 515 | C<SUPER::new> are parsed at compile time, to save having to parse them at |
| 516 | run time. |
| 517 | |
| 518 | =item * |
| 519 | |
| 520 | Array and hash lookups (especially nested ones) that use only constants |
| 521 | or simple variables as keys, are now considerably faster. See |
| 522 | L</Internal Changes> for more details. |
| 523 | |
| 524 | =item * |
| 525 | |
| 526 | C<(...)x1>, C<("constant")x0> and C<($scalar)x0> are now optimised in list |
| 527 | context. If the right-hand argument is a constant 1, the repetition |
| 528 | operator disappears. If the right-hand argument is a constant 0, the whole |
| 529 | expression is optimised to the empty list, so long as the left-hand |
| 530 | argument is a simple scalar or constant. (That is, C<(foo())x0> is not |
| 531 | subject to this optimisation.) |
| 532 | |
| 533 | =item * |
| 534 | |
| 535 | C<substr> assignment is now optimised into 4-argument C<substr> at the end |
| 536 | of a subroutine (or as the argument to C<return>). Previously, this |
| 537 | optimisation only happened in void context. |
| 538 | |
| 539 | =item * |
| 540 | |
| 541 | In C<"\L...">, C<"\Q...">, etc., the extra "stringify" op is now optimised |
| 542 | away, making these just as fast as C<lcfirst>, C<quotemeta>, etc. |
| 543 | |
| 544 | =item * |
| 545 | |
| 546 | Assignment to an empty list is now sometimes faster. In particular, it |
| 547 | never calls C<FETCH> on tied arguments on the right-hand side, whereas it |
| 548 | used to sometimes. |
| 549 | |
| 550 | =item * |
| 551 | |
| 552 | There is a performance improvement of up to 20% when C<length> is applied to |
| 553 | a non-magical, non-tied string, and either C<use bytes> is in scope or the |
| 554 | string doesn't use UTF-8 internally. |
| 555 | |
| 556 | =item * |
| 557 | |
| 558 | On most perl builds with 64-bit integers, memory usage for non-magical, |
| 559 | non-tied scalars containing only a floating point value has been reduced |
| 560 | by between 8 and 32 bytes, depending on OS. |
| 561 | |
| 562 | =item * |
| 563 | |
| 564 | In C<@array = split>, the assignment can be optimized away, so that C<split> |
| 565 | writes directly to the array. This optimisation was happening only for |
| 566 | package arrays other than C<@_>, and only sometimes. Now this |
| 567 | optimisation happens almost all the time. |
| 568 | |
| 569 | =item * |
| 570 | |
| 571 | C<join> is now subject to constant folding. So for example |
| 572 | S<C<join "-", "a", "b">> is converted at compile-time to C<"a-b">. |
| 573 | Moreover, C<join> with a scalar or constant for the separator and a |
| 574 | single-item list to join is simplified to a stringification, and the |
| 575 | separator doesn't even get evaluated. |
| 576 | |
| 577 | =item * |
| 578 | |
| 579 | C<qq(@array)> is implemented using two ops: a stringify op and a join op. |
| 580 | If the C<qq> contains nothing but a single array, the stringification is |
| 581 | optimized away. |
| 582 | |
| 583 | =item * |
| 584 | |
| 585 | S<C<our $var>> and S<C<our($s,@a,%h)>> in void context are no longer evaluated at |
| 586 | run time. Even a whole sequence of S<C<our $foo;>> statements will simply be |
| 587 | skipped over. The same applies to C<state> variables. |
| 588 | |
| 589 | =item * |
| 590 | |
| 591 | Many internal functions have been refactored to improve performance and reduce |
| 592 | their memory footprints. |
| 593 | L<[perl #121436]|https://rt.perl.org/Ticket/Display.html?id=121436> |
| 594 | L<[perl #121906]|https://rt.perl.org/Ticket/Display.html?id=121906> |
| 595 | L<[perl #121969]|https://rt.perl.org/Ticket/Display.html?id=121969> |
| 596 | |
| 597 | =item * |
| 598 | |
| 599 | C<-T> and C<-B> filetests will return sooner when an empty file is detected. |
| 600 | L<[perl #121489]|https://rt.perl.org/Ticket/Display.html?id=121489> |
| 601 | |
| 602 | =item * |
| 603 | |
| 604 | Hash lookups where the key is a constant are faster. |
| 605 | |
| 606 | =item * |
| 607 | |
| 608 | Subroutines with an empty prototype and a body containing just C<undef> are now |
| 609 | eligible for inlining. |
| 610 | L<[perl #122728]|https://rt.perl.org/Ticket/Display.html?id=122728> |
| 611 | |
| 612 | =item * |
| 613 | |
| 614 | Subroutines in packages no longer need to be stored in typeglobs: |
| 615 | declaring a subroutine will now put a simple sub reference directly in the |
| 616 | stash if possible, saving memory. The typeglob still notionally exists, |
| 617 | so accessing it will cause the stash entry to be upgraded to a typeglob |
| 618 | (I<i.e.> this is just an internal implementation detail). |
| 619 | This optimization does not currently apply to XSUBs or exported |
| 620 | subroutines, and method calls will undo it, since they cache things in |
| 621 | typeglobs. |
| 622 | L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> |
| 623 | |
| 624 | =item * |
| 625 | |
| 626 | The functions C<utf8::native_to_unicode()> and C<utf8::unicode_to_native()> |
| 627 | (see L<utf8>) are now optimized out on ASCII platforms. There is now not even |
| 628 | a minimal performance hit in writing code portable between ASCII and EBCDIC |
| 629 | platforms. |
| 630 | |
| 631 | =item * |
| 632 | |
| 633 | Win32 Perl uses 8 KB less of per-process memory than before for every perl |
| 634 | process, because some data is now memory mapped from disk and shared |
| 635 | between processes from the same perl binary. |
| 636 | |
| 637 | =back |
| 638 | |
| 639 | =head1 Modules and Pragmata |
| 640 | |
| 641 | =head2 Updated Modules and Pragmata |
| 642 | |
| 643 | Many of the libraries distributed with perl have been upgraded since v5.20.0. |
| 644 | For a complete list of changes, run: |
| 645 | |
| 646 | corelist --diff 5.20.0 5.22.0 |
| 647 | |
| 648 | You can substitute your favorite version in place of 5.20.0, too. |
| 649 | |
| 650 | Some notable changes include: |
| 651 | |
| 652 | =over 4 |
| 653 | |
| 654 | =item * |
| 655 | |
| 656 | L<Archive::Tar> has been upgraded to version 2.04. |
| 657 | |
| 658 | Tests can now be run in parallel. |
| 659 | |
| 660 | =item * |
| 661 | |
| 662 | L<attributes> has been upgraded to version 0.27. |
| 663 | |
| 664 | The usage of C<memEQs> in the XS has been corrected. |
| 665 | L<[perl #122701]|https://rt.perl.org/Ticket/Display.html?id=122701> |
| 666 | |
| 667 | Avoid reading beyond the end of a buffer. [perl #122629] |
| 668 | |
| 669 | =item * |
| 670 | |
| 671 | L<B> has been upgraded to version 1.58. |
| 672 | |
| 673 | It provides a new C<B::safename> function, based on the existing |
| 674 | C<< B::GV->SAFENAME >>, that converts C<\cOPEN> to C<^OPEN>. |
| 675 | |
| 676 | Nulled COPs are now of class C<B::COP>, rather than C<B::OP>. |
| 677 | |
| 678 | C<B::REGEXP> objects now provide a C<qr_anoncv> method for accessing the |
| 679 | implicit CV associated with C<qr//> things containing code blocks, and a |
| 680 | C<compflags> method that returns the pertinent flags originating from the |
| 681 | C<qr//blahblah> op. |
| 682 | |
| 683 | C<B::PMOP> now provides a C<pmregexp> method returning a C<B::REGEXP> object. |
| 684 | Two new classes, C<B::PADNAME> and C<B::PADNAMELIST>, have been introduced. |
| 685 | |
| 686 | A bug where, after an ithread creation or psuedofork, special/immortal SVs in |
| 687 | the child ithread/psuedoprocess did not have the correct class of |
| 688 | C<B::SPECIAL>, has been fixed. |
| 689 | The C<id> and C<outid> PADLIST methods have been added. |
| 690 | |
| 691 | =item * |
| 692 | |
| 693 | L<B::Concise> has been upgraded to version 0.996. |
| 694 | |
| 695 | Null ops that are part of the execution chain are now given sequence |
| 696 | numbers. |
| 697 | |
| 698 | Private flags for nulled ops are now dumped with mnemonics as they would be |
| 699 | for the non-nulled counterparts. |
| 700 | |
| 701 | =item * |
| 702 | |
| 703 | L<B::Deparse> has been upgraded to version 1.35. |
| 704 | |
| 705 | It now deparses C<+sub : attr { ... }> correctly at the start of a |
| 706 | statement. Without the initial C<+>, C<sub> would be a statement label. |
| 707 | |
| 708 | C<BEGIN> blocks are now emitted in the right place most of the time, but |
| 709 | the change unfortunately introduced a regression, in that C<BEGIN> blocks |
| 710 | occurring just before the end of the enclosing block may appear below it |
| 711 | instead. |
| 712 | |
| 713 | C<B::Deparse> no longer puts erroneous C<local> here and there, such as for |
| 714 | C<LIST = tr/a//d>. [perl #119815] |
| 715 | |
| 716 | Adjacent C<use> statements are no longer accidentally nested if one |
| 717 | contains a C<do> block. [perl #115066] |
| 718 | |
| 719 | Parenthesised arrays in lists passed to C<\> are now correctly deparsed |
| 720 | with parentheses (I<e.g.>, C<\(@a, (@b), @c)> now retains the parentheses |
| 721 | around @b), thus preserving the flattening behavior of referenced |
| 722 | parenthesised arrays. Formerly, it only worked for one array: C<\(@a)>. |
| 723 | |
| 724 | C<local our> is now deparsed correctly, with the C<our> included. |
| 725 | |
| 726 | C<for($foo; !$bar; $baz) {...}> was deparsed without the C<!> (or C<not>). |
| 727 | This has been fixed. |
| 728 | |
| 729 | Core keywords that conflict with lexical subroutines are now deparsed with |
| 730 | the C<CORE::> prefix. |
| 731 | |
| 732 | C<foreach state $x (...) {...}> now deparses correctly with C<state> and |
| 733 | not C<my>. |
| 734 | |
| 735 | C<our @array = split(...)> now deparses correctly with C<our> in those |
| 736 | cases where the assignment is optimized away. |
| 737 | |
| 738 | It now deparses C<our(I<LIST>)> and typed lexical (C<my Dog $spot>) correctly. |
| 739 | |
| 740 | Deparse C<$#_> as that instead of as C<$#{_}>. |
| 741 | L<[perl #123947]|https://rt.perl.org/Ticket/Display.html?id=123947> |
| 742 | |
| 743 | BEGIN blocks at the end of the enclosing scope are now deparsed in the |
| 744 | right place. [perl #77452] |
| 745 | |
| 746 | BEGIN blocks were sometimes deparsed as __ANON__, but are now always called |
| 747 | BEGIN. |
| 748 | |
| 749 | Lexical subroutines are now fully deparsed. [perl #116553] |
| 750 | |
| 751 | C<Anything =~ y///r> with C</r> no longer omits the left-hand operand. |
| 752 | |
| 753 | The op trees that make up regexp code blocks are now deparsed for real. |
| 754 | Formerly, the original string that made up the regular expression was used. |
| 755 | That caused problems with C<qr/(?{E<lt>E<lt>heredoc})/> and multiline code blocks, |
| 756 | which were deparsed incorrectly. [perl #123217] [perl #115256] |
| 757 | |
| 758 | C<$;> at the end of a statement no longer loses its semicolon. |
| 759 | [perl #123357] |
| 760 | |
| 761 | Some cases of subroutine declarations stored in the stash in shorthand form |
| 762 | were being omitted. |
| 763 | |
| 764 | Non-ASCII characters are now consistently escaped in strings, instead of |
| 765 | some of the time. (There are still outstanding problems with regular |
| 766 | expressions and identifiers that have not been fixed.) |
| 767 | |
| 768 | When prototype sub calls are deparsed with C<&> (I<e.g.>, under the B<-P> |
| 769 | option), C<scalar> is now added where appropriate, to force the scalar |
| 770 | context implied by the prototype. |
| 771 | |
| 772 | C<require(foo())>, C<do(foo())>, C<goto(foo())> and similar constructs with |
| 773 | loop controls are now deparsed correctly. The outer parentheses are not |
| 774 | optional. |
| 775 | |
| 776 | Whitespace is no longer escaped in regular expressions, because it was |
| 777 | getting erroneously escaped within C<(?x:...)> sections. |
| 778 | |
| 779 | C<sub foo { foo() }> is now deparsed with those mandatory parentheses. |
| 780 | |
| 781 | C</@array/> is now deparsed as a regular expression, and not just |
| 782 | C<@array>. |
| 783 | |
| 784 | C</@{-}/>, C</@{+}/> and C<$#{1}> are now deparsed with the braces, which |
| 785 | are mandatory in these cases. |
| 786 | |
| 787 | In deparsing feature bundles, C<B::Deparse> was emitting C<no feature;> first |
| 788 | instead of C<no feature ':all';>. This has been fixed. |
| 789 | |
| 790 | C<chdir FH> is now deparsed without quotation marks. |
| 791 | |
| 792 | C<\my @a> is now deparsed without parentheses. (Parenthese would flatten |
| 793 | the array.) |
| 794 | |
| 795 | C<system> and C<exec> followed by a block are now deparsed correctly. |
| 796 | Formerly there was an erroneous C<do> before the block. |
| 797 | |
| 798 | C<< use constant QR =E<gt> qr/.../flags >> followed by C<"" =~ QR> is no longer |
| 799 | without the flags. |
| 800 | |
| 801 | Deparsing C<BEGIN { undef &foo }> with the B<-w> switch enabled started to |
| 802 | emit 'uninitialized' warnings in Perl 5.14. This has been fixed. |
| 803 | |
| 804 | Deparsing calls to subs with a C<(;+)> prototype resulted in an infinite |
| 805 | loop. The C<(;$>) C<(_)> and C<(;_)> prototypes were given the wrong |
| 806 | precedence, causing C<foo($aE<lt>$b)> to be deparsed without the parentheses. |
| 807 | |
| 808 | Deparse now provides a defined state sub in inner subs. |
| 809 | |
| 810 | =item * |
| 811 | |
| 812 | L<B::Op_private> has been added. |
| 813 | |
| 814 | L<B::Op_private> provides detailed information about the flags used in the |
| 815 | C<op_private> field of perl opcodes. |
| 816 | |
| 817 | =item * |
| 818 | |
| 819 | L<bigint>, L<bignum>, L<bigrat> have been upgraded to version 0.39. |
| 820 | |
| 821 | Document in CAVEATS that using strings as numbers won't always invoke |
| 822 | the big number overloading, and how to invoke it. [rt.perl.org #123064] |
| 823 | |
| 824 | =item * |
| 825 | |
| 826 | L<Carp> has been upgraded to version 1.36. |
| 827 | |
| 828 | C<Carp::Heavy> now ignores version mismatches with Carp if Carp is newer |
| 829 | than 1.12, since C<Carp::Heavy>'s guts were merged into Carp at that |
| 830 | point. |
| 831 | L<[perl #121574]|https://rt.perl.org/Ticket/Display.html?id=121574> |
| 832 | |
| 833 | Carp now handles non-ASCII platforms better. |
| 834 | |
| 835 | Off-by-one error fix for Perl E<lt> 5.14. |
| 836 | |
| 837 | =item * |
| 838 | |
| 839 | L<constant> has been upgraded to version 1.33. |
| 840 | |
| 841 | It now accepts fully-qualified constant names, allowing constants to be defined |
| 842 | in packages other than the caller. |
| 843 | |
| 844 | =item * |
| 845 | |
| 846 | L<CPAN> has been upgraded to version 2.11. |
| 847 | |
| 848 | Add support for C<Cwd::getdcwd()> and introduce workaround for a misbehavior |
| 849 | seen on Strawberry Perl 5.20.1. |
| 850 | |
| 851 | Fix C<chdir()> after building dependencies bug. |
| 852 | |
| 853 | Introduce experimental support for plugins/hooks. |
| 854 | |
| 855 | Integrate the C<App::Cpan> sources. |
| 856 | |
| 857 | Do not check recursion on optional dependencies. |
| 858 | |
| 859 | Sanity check F<META.yml> to contain a hash. |
| 860 | L<[cpan #95271]|https://rt.cpan.org/Ticket/Display.html?id=95271> |
| 861 | |
| 862 | =item * |
| 863 | |
| 864 | L<CPAN::Meta::Requirements> has been upgraded to version 2.132. |
| 865 | |
| 866 | Works around limitations in C<version::vpp> detecting v-string magic and adds |
| 867 | support for forthcoming L<ExtUtils::MakeMaker> bootstrap F<version.pm> for |
| 868 | Perls older than 5.10.0. |
| 869 | |
| 870 | =item * |
| 871 | |
| 872 | L<Data::Dumper> has been upgraded to version 2.158. |
| 873 | |
| 874 | Fixes CVE-2014-4330 by adding a configuration variable/option to limit |
| 875 | recursion when dumping deep data structures. |
| 876 | |
| 877 | Changes to resolve Coverity issues. |
| 878 | XS dumps incorrectly stored the name of code references stored in a |
| 879 | GLOB. |
| 880 | L<[perl #122070]|https://rt.perl.org/Ticket/Display.html?id=122070> |
| 881 | |
| 882 | =item * |
| 883 | |
| 884 | L<DynaLoader> has been upgraded to version 1.32. |
| 885 | |
| 886 | Remove C<dl_nonlazy> global if unused in Dynaloader. [perl #122926] |
| 887 | |
| 888 | =item * |
| 889 | |
| 890 | L<Encode> has been upgraded to version 2.72. |
| 891 | |
| 892 | C<piconv> now has better error handling when the encoding name is nonexistent, |
| 893 | and a build breakage when upgrading L<Encode> in perl-5.8.2 and earlier has |
| 894 | been fixed. |
| 895 | |
| 896 | Building in C++ mode on Windows now works. |
| 897 | |
| 898 | =item * |
| 899 | |
| 900 | L<Errno> has been upgraded to version 1.23. |
| 901 | |
| 902 | Add C<-P> to the preprocessor command-line on GCC 5. GCC added extra |
| 903 | line directives, breaking parsing of error code definitions. [rt.perl.org |
| 904 | #123784] |
| 905 | |
| 906 | =item * |
| 907 | |
| 908 | L<experimental> has been upgraded to version 0.013. |
| 909 | |
| 910 | Hardcodes features for Perls older than 5.15.7. |
| 911 | |
| 912 | =item * |
| 913 | |
| 914 | L<ExtUtils::CBuilder> has been upgraded to version 0.280221. |
| 915 | |
| 916 | Fixes a regression on Android. |
| 917 | L<[perl #122675]|https://rt.perl.org/Ticket/Display.html?id=122675> |
| 918 | |
| 919 | =item * |
| 920 | |
| 921 | L<ExtUtils::Manifest> has been upgraded to version 1.70. |
| 922 | |
| 923 | Fixes a bug with C<maniread()>'s handling of quoted filenames and improves |
| 924 | C<manifind()> to follow symlinks. |
| 925 | L<[perl #122415]|https://rt.perl.org/Ticket/Display.html?id=122415> |
| 926 | |
| 927 | =item * |
| 928 | |
| 929 | L<ExtUtils::ParseXS> has been upgraded to version 3.28. |
| 930 | |
| 931 | Only declare C<file> unused if we actually define it. |
| 932 | Improve generated C<RETVAL> code generation to avoid repeated |
| 933 | references to C<ST(0)>. [perl #123278] |
| 934 | Broaden and document the C</OBJ$/> to C</REF$/> typemap optimization |
| 935 | for the C<DESTROY> method. [perl #123418] |
| 936 | |
| 937 | =item * |
| 938 | |
| 939 | L<Fcntl> has been upgraded to version 1.13. |
| 940 | |
| 941 | Add support for the Linux pipe buffer size C<fcntl()> commands. |
| 942 | |
| 943 | =item * |
| 944 | |
| 945 | L<File::Find> has been upgraded to version 1.29. |
| 946 | |
| 947 | C<find()> and C<finddepth()> will now warn if passed inappropriate or |
| 948 | misspelled options. |
| 949 | |
| 950 | =item * |
| 951 | |
| 952 | L<File::Glob> has been upgraded to version 1.24. |
| 953 | |
| 954 | Avoid C<SvIV()> expanding to call C<get_sv()> three times in a few |
| 955 | places. [perl #123606] |
| 956 | |
| 957 | =item * |
| 958 | |
| 959 | L<HTTP::Tiny> has been upgraded to version 0.054. |
| 960 | |
| 961 | C<keep_alive> is now fork-safe and thread-safe. |
| 962 | |
| 963 | =item * |
| 964 | |
| 965 | L<IO> has been upgraded to version 1.35. |
| 966 | |
| 967 | The XS implementation has been fixed for the sake of older Perls. |
| 968 | |
| 969 | =item * |
| 970 | |
| 971 | L<IO::Socket> has been upgraded to version 1.38. |
| 972 | |
| 973 | Document the limitations of the C<connected()> method. [perl #123096] |
| 974 | |
| 975 | =item * |
| 976 | |
| 977 | L<IO::Socket::IP> has been upgraded to version 0.37. |
| 978 | |
| 979 | A better fix for subclassing C<connect()>. |
| 980 | L<[cpan #95983]|https://rt.cpan.org/Ticket/Display.html?id=95983> |
| 981 | L<[cpan #97050]|https://rt.cpan.org/Ticket/Display.html?id=97050> |
| 982 | |
| 983 | Implements Timeout for C<connect()>. |
| 984 | L<[cpan #92075]|https://rt.cpan.org/Ticket/Display.html?id=92075> |
| 985 | |
| 986 | =item * |
| 987 | |
| 988 | The libnet collection of modules has been upgraded to version 3.05. |
| 989 | |
| 990 | Support for IPv6 and SSL to C<Net::FTP>, C<Net::NNTP>, C<Net::POP3> and C<Net::SMTP>. |
| 991 | Improvements in C<Net::SMTP> authentication. |
| 992 | |
| 993 | =item * |
| 994 | |
| 995 | L<Locale::Codes> has been upgraded to version 3.34. |
| 996 | |
| 997 | Fixed a bug in the scripts used to extract data from spreadsheets that |
| 998 | prevented the SHP currency code from being found. |
| 999 | L<[cpan #94229]|https://rt.cpan.org/Ticket/Display.html?id=94229> |
| 1000 | |
| 1001 | New codes have been added. |
| 1002 | |
| 1003 | =item * |
| 1004 | |
| 1005 | L<Math::BigInt> has been upgraded to version 1.9997. |
| 1006 | |
| 1007 | Synchronize POD changes from the CPAN release. |
| 1008 | C<< Math::BigFloat->blog(x) >> would sometimes return C<blog(2*x)> when |
| 1009 | the accuracy was greater than 70 digits. |
| 1010 | The result of C<< Math::BigFloat->bdiv() >> in list context now |
| 1011 | satisfies C<< x = quotient * divisor + remainder >>. |
| 1012 | |
| 1013 | Correct handling of subclasses. |
| 1014 | L<[cpan #96254]|https://rt.cpan.org/Ticket/Display.html?id=96254> |
| 1015 | L<[cpan #96329]|https://rt.cpan.org/Ticket/Display.html?id=96329> |
| 1016 | |
| 1017 | =item * |
| 1018 | |
| 1019 | L<Module::Metadata> has been upgraded to version 1.000026. |
| 1020 | |
| 1021 | Support installations on older perls with an L<ExtUtils::MakeMaker> earlier |
| 1022 | than 6.63_03 |
| 1023 | |
| 1024 | =item * |
| 1025 | |
| 1026 | L<overload> has been upgraded to version 1.26. |
| 1027 | |
| 1028 | A redundant C<ref $sub> check has been removed. |
| 1029 | |
| 1030 | =item * |
| 1031 | |
| 1032 | The PathTools module collection has been upgraded to version 3.56. |
| 1033 | |
| 1034 | A warning from the B<gcc> compiler is now avoided when building the XS. |
| 1035 | |
| 1036 | Don't turn leading C<//> into C</> on Cygwin. [perl #122635] |
| 1037 | |
| 1038 | =item * |
| 1039 | |
| 1040 | L<perl5db.pl> has been upgraded to version 1.49. |
| 1041 | |
| 1042 | The debugger would cause an assertion failure. |
| 1043 | L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127> |
| 1044 | |
| 1045 | C<fork()> in the debugger under C<tmux> will now create a new window for |
| 1046 | the forked process. L<[perl |
| 1047 | #121333]|https://rt.perl.org/Ticket/Display.html?id=121333> |
| 1048 | |
| 1049 | The debugger now saves the current working directory on startup and |
| 1050 | restores it when you restart your program with C<R> or C<rerun>. L<[perl |
| 1051 | #121509]|https://rt.perl.org/Ticket/Display.html?id=121509> |
| 1052 | |
| 1053 | =item * |
| 1054 | |
| 1055 | L<PerlIO::scalar> has been upgraded to version 0.22. |
| 1056 | |
| 1057 | Reading from a position well past the end of the scalar now correctly |
| 1058 | returns end of file. [perl #123443] |
| 1059 | |
| 1060 | Seeking to a negative position still fails, but no longer leaves the |
| 1061 | file position set to a negation location. |
| 1062 | |
| 1063 | C<eof()> on a C<PerlIO::scalar> handle now properly returns true when |
| 1064 | the file position is past the 2GB mark on 32-bit systems. |
| 1065 | |
| 1066 | Attempting to write at file positions impossible for the platform now |
| 1067 | fail early rather than wrapping at 4GB. |
| 1068 | |
| 1069 | =item * |
| 1070 | |
| 1071 | L<Pod::Perldoc> has been upgraded to version 3.25. |
| 1072 | |
| 1073 | Filehandles opened for reading or writing now have C<:encoding(UTF-8)> set. |
| 1074 | L<[cpan #98019]|https://rt.cpan.org/Ticket/Display.html?id=98019> |
| 1075 | |
| 1076 | =item * |
| 1077 | |
| 1078 | L<POSIX> has been upgraded to version 1.53. |
| 1079 | |
| 1080 | The C99 math functions and constants (for example C<acosh>, C<isinf>, C<isnan>, C<round>, |
| 1081 | C<trunc>; C<M_E>, C<M_SQRT2>, C<M_PI>) have been added. |
| 1082 | |
| 1083 | C<POSIX::tmpnam()> now produces a deprecation warning. [perl #122005] |
| 1084 | |
| 1085 | =item * |
| 1086 | |
| 1087 | L<Safe> has been upgraded to version 2.39. |
| 1088 | |
| 1089 | C<reval> was not propagating void context properly. |
| 1090 | |
| 1091 | =item * |
| 1092 | |
| 1093 | Scalar-List-Utils has been upgraded to version 1.41. |
| 1094 | |
| 1095 | A new module, L<Sub::Util>, has been added, containing functions related to |
| 1096 | CODE refs, including C<subname> (inspired by C<Sub::Identity>) and C<set_subname> |
| 1097 | (copied and renamed from C<Sub::Name>). |
| 1098 | The use of C<GetMagic> in C<List::Util::reduce()> has also been fixed. |
| 1099 | L<[cpan #63211]|https://rt.cpan.org/Ticket/Display.html?id=63211> |
| 1100 | |
| 1101 | =item * |
| 1102 | |
| 1103 | L<SDBM_File> has been upgraded to version 1.13. |
| 1104 | |
| 1105 | Simplified the build process. [perl #123413] |
| 1106 | |
| 1107 | =item * |
| 1108 | |
| 1109 | L<Time::Piece> has been upgraded to version 1.29. |
| 1110 | |
| 1111 | When pretty printing negative C<Time::Seconds>, the "minus" is no longer lost. |
| 1112 | |
| 1113 | =item * |
| 1114 | |
| 1115 | L<Unicode::Collate> has been upgraded to version 1.12. |
| 1116 | |
| 1117 | Version 0.67's improved discontiguous contractions is invalidated by default |
| 1118 | and is supported as a parameter C<long_contraction>. |
| 1119 | |
| 1120 | =item * |
| 1121 | |
| 1122 | L<Unicode::Normalize> has been upgraded to version 1.18. |
| 1123 | |
| 1124 | The XSUB implementation has been removed in favor of pure Perl. |
| 1125 | |
| 1126 | =item * |
| 1127 | |
| 1128 | L<Unicode::UCD> has been upgraded to version 0.61. |
| 1129 | |
| 1130 | A new function L<property_values()|Unicode::UCD/prop_values()> |
| 1131 | has been added to return a given property's possible values. |
| 1132 | |
| 1133 | A new function L<charprop()|Unicode::UCD/charprop()> |
| 1134 | has been added to return the value of a given property for a given code |
| 1135 | point. |
| 1136 | |
| 1137 | A new function L<charprops_all()|Unicode::UCD/charprops_all()> |
| 1138 | has been added to return the values of all Unicode properties for a |
| 1139 | given code point. |
| 1140 | |
| 1141 | A bug has been fixed so that L<propaliases()|Unicode::UCD/prop_aliases()> |
| 1142 | returns the correct short and long names for the Perl extensions where |
| 1143 | it was incorrect. |
| 1144 | |
| 1145 | A bug has been fixed so that |
| 1146 | L<prop_value_aliases()|Unicode::UCD/prop_value_aliases()> |
| 1147 | returns C<undef> instead of a wrong result for properties that are Perl |
| 1148 | extensions. |
| 1149 | |
| 1150 | This module now works on EBCDIC platforms. |
| 1151 | |
| 1152 | =item * |
| 1153 | |
| 1154 | L<utf8> has been upgraded to version 1.17 |
| 1155 | |
| 1156 | A mismatch between the documentation and the code in C<utf8::downgrade()> |
| 1157 | was fixed in favor of the documentation. The optional second argument |
| 1158 | is now correctly treated as a perl boolean (true/false semantics) and |
| 1159 | not as an integer. |
| 1160 | |
| 1161 | =item * |
| 1162 | |
| 1163 | L<version> has been upgraded to version 0.9909. |
| 1164 | |
| 1165 | Numerous changes. See the F<Changes> file in the CPAN distribution for |
| 1166 | details. |
| 1167 | |
| 1168 | =item * |
| 1169 | |
| 1170 | L<Win32> has been upgraded to version 0.51. |
| 1171 | |
| 1172 | C<GetOSName()> now supports Windows 8.1, and building in C++ mode now works. |
| 1173 | |
| 1174 | =item * |
| 1175 | |
| 1176 | L<Win32API::File> has been upgraded to version 0.1202 |
| 1177 | |
| 1178 | Building in C++ mode now works. |
| 1179 | |
| 1180 | =item * |
| 1181 | |
| 1182 | L<XSLoader> has been upgraded to version 0.20. |
| 1183 | |
| 1184 | Allow XSLoader to load modules from a different namespace. |
| 1185 | [perl #122455] |
| 1186 | |
| 1187 | =back |
| 1188 | |
| 1189 | =head2 Removed Modules and Pragmata |
| 1190 | |
| 1191 | The following modules (and associated modules) have been removed from the core |
| 1192 | perl distribution: |
| 1193 | |
| 1194 | =over 4 |
| 1195 | |
| 1196 | =item * |
| 1197 | |
| 1198 | L<CGI> |
| 1199 | |
| 1200 | =item * |
| 1201 | |
| 1202 | L<Module::Build> |
| 1203 | |
| 1204 | =back |
| 1205 | |
| 1206 | =head1 Documentation |
| 1207 | |
| 1208 | =head2 New Documentation |
| 1209 | |
| 1210 | =head3 L<perlunicook> |
| 1211 | |
| 1212 | This document, by Tom Christiansen, provides examples of handling Unicode in |
| 1213 | Perl. |
| 1214 | |
| 1215 | =head2 Changes to Existing Documentation |
| 1216 | |
| 1217 | =head3 L<perlaix> |
| 1218 | |
| 1219 | =over 4 |
| 1220 | |
| 1221 | =item * |
| 1222 | |
| 1223 | A note on long doubles has been added. |
| 1224 | |
| 1225 | =back |
| 1226 | |
| 1227 | |
| 1228 | =head3 L<perlapi> |
| 1229 | |
| 1230 | =over 4 |
| 1231 | |
| 1232 | =item * |
| 1233 | |
| 1234 | Note that C<SvSetSV> doesn't do set magic. |
| 1235 | |
| 1236 | =item * |
| 1237 | |
| 1238 | C<sv_usepvn_flags> - fix documentation to mention the use of C<Newx> instead of |
| 1239 | C<malloc>. |
| 1240 | |
| 1241 | L<[perl #121869]|https://rt.perl.org/Ticket/Display.html?id=121869> |
| 1242 | |
| 1243 | =item * |
| 1244 | |
| 1245 | Clarify where C<NUL> may be embedded or is required to terminate a string. |
| 1246 | |
| 1247 | =item * |
| 1248 | |
| 1249 | Some documentation that was previously missing due to formatting errors is |
| 1250 | now included. |
| 1251 | |
| 1252 | =item * |
| 1253 | |
| 1254 | Entries are now organized into groups rather than by the file where they |
| 1255 | are found. |
| 1256 | |
| 1257 | =item * |
| 1258 | |
| 1259 | Alphabetical sorting of entries is now done consistently (automatically |
| 1260 | by the POD generator) to make entries easier to find when scanning. |
| 1261 | |
| 1262 | =back |
| 1263 | |
| 1264 | =head3 L<perldata> |
| 1265 | |
| 1266 | =over 4 |
| 1267 | |
| 1268 | =item * |
| 1269 | |
| 1270 | The syntax of single-character variable names has been brought |
| 1271 | up-to-date and more fully explained. |
| 1272 | |
| 1273 | =item * |
| 1274 | |
| 1275 | Hexadecimal floating point numbers are described, as are infinity and |
| 1276 | NaN. |
| 1277 | |
| 1278 | =back |
| 1279 | |
| 1280 | =head3 L<perlebcdic> |
| 1281 | |
| 1282 | =over 4 |
| 1283 | |
| 1284 | =item * |
| 1285 | |
| 1286 | This document has been significantly updated in the light of recent |
| 1287 | improvements to EBCDIC support. |
| 1288 | |
| 1289 | =back |
| 1290 | |
| 1291 | =head3 L<perlfilter> |
| 1292 | |
| 1293 | =over 4 |
| 1294 | |
| 1295 | =item * |
| 1296 | |
| 1297 | Added a L<LIMITATIONS|perlfilter/LIMITATIONS> section. |
| 1298 | |
| 1299 | =back |
| 1300 | |
| 1301 | |
| 1302 | =head3 L<perlfunc> |
| 1303 | |
| 1304 | =over 4 |
| 1305 | |
| 1306 | =item * |
| 1307 | |
| 1308 | Mention that C<study()> is currently a no-op. |
| 1309 | |
| 1310 | =item * |
| 1311 | |
| 1312 | Calling C<delete> or C<exists> on array values is now described as "strongly |
| 1313 | discouraged" rather than "deprecated". |
| 1314 | |
| 1315 | =item * |
| 1316 | |
| 1317 | Improve documentation of C<< our >>. |
| 1318 | |
| 1319 | =item * |
| 1320 | |
| 1321 | C<-l> now notes that it will return false if symlinks aren't supported by the |
| 1322 | file system. |
| 1323 | L<[perl #121523]|https://rt.perl.org/Ticket/Display.html?id=121523> |
| 1324 | |
| 1325 | =item * |
| 1326 | |
| 1327 | Note that C<exec LIST> and C<system LIST> may fall back to the shell on |
| 1328 | Win32. Only the indirect-object syntax C<exec PROGRAM LIST> and |
| 1329 | C<system PROGRAM LIST> will reliably avoid using the shell. |
| 1330 | |
| 1331 | This has also been noted in L<perlport>. |
| 1332 | |
| 1333 | L<[perl #122046]|https://rt.perl.org/Ticket/Display.html?id=122046> |
| 1334 | |
| 1335 | =back |
| 1336 | |
| 1337 | =head3 L<perlguts> |
| 1338 | |
| 1339 | =over 4 |
| 1340 | |
| 1341 | =item * |
| 1342 | |
| 1343 | The OOK example has been updated to account for COW changes and a change in the |
| 1344 | storage of the offset. |
| 1345 | |
| 1346 | =item * |
| 1347 | |
| 1348 | Details on C level symbols and libperl.t added. |
| 1349 | |
| 1350 | =item * |
| 1351 | |
| 1352 | Information on Unicode handling has been added |
| 1353 | |
| 1354 | =item * |
| 1355 | |
| 1356 | Information on EBCDIC handling has been added |
| 1357 | |
| 1358 | =back |
| 1359 | |
| 1360 | =head3 L<perlhack> |
| 1361 | |
| 1362 | =over 4 |
| 1363 | |
| 1364 | =item * |
| 1365 | |
| 1366 | A note has been added about running on platforms with non-ASCII |
| 1367 | character sets |
| 1368 | |
| 1369 | =item * |
| 1370 | |
| 1371 | A note has been added about performance testing |
| 1372 | |
| 1373 | =back |
| 1374 | |
| 1375 | =head3 L<perlhacktips> |
| 1376 | |
| 1377 | =over 4 |
| 1378 | |
| 1379 | =item * |
| 1380 | |
| 1381 | Documentation has been added illustrating the perils of assuming that |
| 1382 | there is no change to the contents of static memory pointed to by the |
| 1383 | return values of Perl's wrappers for C library functions. |
| 1384 | |
| 1385 | =item * |
| 1386 | |
| 1387 | Replacements for C<tmpfile>, C<atoi>, C<strtol>, and C<strtoul> are now |
| 1388 | recommended. |
| 1389 | |
| 1390 | =item * |
| 1391 | |
| 1392 | Updated documentation for the C<test.valgrind> C<make> target. |
| 1393 | L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> |
| 1394 | |
| 1395 | =item * |
| 1396 | |
| 1397 | Information is given about writing test files portably to non-ASCII |
| 1398 | platforms. |
| 1399 | |
| 1400 | =item * |
| 1401 | |
| 1402 | A note has been added about how to get a C language stack backtrace. |
| 1403 | |
| 1404 | =back |
| 1405 | |
| 1406 | =head3 L<perlhpux> |
| 1407 | |
| 1408 | =over 4 |
| 1409 | |
| 1410 | =item * |
| 1411 | |
| 1412 | Note that the message "Redeclaration of "sendpath" with a different |
| 1413 | storage class specifier" is harmless. |
| 1414 | |
| 1415 | =back |
| 1416 | |
| 1417 | =head3 L<perllocale> |
| 1418 | |
| 1419 | =over 4 |
| 1420 | |
| 1421 | =item * |
| 1422 | |
| 1423 | Updated for the enhancements in v5.22, along with some clarifications. |
| 1424 | |
| 1425 | =back |
| 1426 | |
| 1427 | =head3 L<perlmodstyle> |
| 1428 | |
| 1429 | =over 4 |
| 1430 | |
| 1431 | =item * |
| 1432 | |
| 1433 | Instead of pointing to the module list, we are now pointing to |
| 1434 | L<PrePAN|http://prepan.org/>. |
| 1435 | |
| 1436 | =back |
| 1437 | |
| 1438 | =head3 L<perlop> |
| 1439 | |
| 1440 | =over 4 |
| 1441 | |
| 1442 | =item * |
| 1443 | |
| 1444 | Updated for the enhancements in v5.22, along with some clarifications. |
| 1445 | |
| 1446 | =back |
| 1447 | |
| 1448 | =head3 L<perlpodspec> |
| 1449 | |
| 1450 | =over 4 |
| 1451 | |
| 1452 | =item * |
| 1453 | |
| 1454 | The specification of the pod language is changing so that the default |
| 1455 | encoding of pods that aren't in UTF-8 (unless otherwise indicated) is |
| 1456 | CP1252 instead of ISO 8859-1 (Latin1). |
| 1457 | |
| 1458 | =back |
| 1459 | |
| 1460 | =head3 L<perlpolicy> |
| 1461 | |
| 1462 | =over 4 |
| 1463 | |
| 1464 | =item * |
| 1465 | |
| 1466 | We now have a code of conduct for the I<< p5p >> mailing list, as documented |
| 1467 | in L<< perlpolicy/STANDARDS OF CONDUCT >>. |
| 1468 | |
| 1469 | =item * |
| 1470 | |
| 1471 | The conditions for marking an experimental feature as non-experimental are now |
| 1472 | set out. |
| 1473 | |
| 1474 | =item * |
| 1475 | |
| 1476 | Clarification has been made as to what sorts of changes are permissible in |
| 1477 | maintenance releases. |
| 1478 | |
| 1479 | =back |
| 1480 | |
| 1481 | =head3 L<perlport> |
| 1482 | |
| 1483 | =over 4 |
| 1484 | |
| 1485 | =item * |
| 1486 | |
| 1487 | Out-of-date VMS-specific information has been fixed and/or simplified. |
| 1488 | |
| 1489 | =item * |
| 1490 | |
| 1491 | Notes about EBCDIC have been added. |
| 1492 | |
| 1493 | =back |
| 1494 | |
| 1495 | =head3 L<perlre> |
| 1496 | |
| 1497 | =over 4 |
| 1498 | |
| 1499 | =item * |
| 1500 | |
| 1501 | The description of the C</x> modifier has been clarified to note that |
| 1502 | comments cannot be continued onto the next line by escaping them; and |
| 1503 | there is now a list of all the characters that are considered whitespace |
| 1504 | by this modifier. |
| 1505 | |
| 1506 | =item * |
| 1507 | |
| 1508 | The new C</n> modifier is described. |
| 1509 | |
| 1510 | =item * |
| 1511 | |
| 1512 | A note has been added on how to make bracketed character class ranges |
| 1513 | portable to non-ASCII machines. |
| 1514 | |
| 1515 | =back |
| 1516 | |
| 1517 | =head3 L<perlrebackslash> |
| 1518 | |
| 1519 | =over 4 |
| 1520 | |
| 1521 | =item * |
| 1522 | |
| 1523 | Added documentation of C<\b{sb}>, C<\b{wb}>, C<\b{gcb}>, and C<\b{g}>. |
| 1524 | |
| 1525 | =back |
| 1526 | |
| 1527 | =head3 L<perlrecharclass> |
| 1528 | |
| 1529 | =over 4 |
| 1530 | |
| 1531 | =item * |
| 1532 | |
| 1533 | Clarifications have been added to L<perlrecharclass/Character Ranges> |
| 1534 | to the effect C<[A-Z]>, C<[a-z]>, C<[0-9]> and |
| 1535 | any subranges thereof in regular expression bracketed character classes |
| 1536 | are guaranteed to match exactly what a naive English speaker would |
| 1537 | expect them to match, even on platforms (such as EBCDIC) where perl |
| 1538 | has to do extra work to accomplish this. |
| 1539 | |
| 1540 | =item * |
| 1541 | |
| 1542 | The documentation of Bracketed Character Classes has been expanded to cover the |
| 1543 | improvements in C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>). |
| 1544 | |
| 1545 | =back |
| 1546 | |
| 1547 | =head3 L<perlref> |
| 1548 | |
| 1549 | =over 4 |
| 1550 | |
| 1551 | =item * |
| 1552 | |
| 1553 | A new section has been added |
| 1554 | L<Assigning to References|perlref/Assigning to References> |
| 1555 | |
| 1556 | =back |
| 1557 | |
| 1558 | =head3 L<perlsec> |
| 1559 | |
| 1560 | =over 4 |
| 1561 | |
| 1562 | =item * |
| 1563 | |
| 1564 | Comments added on algorithmic complexity and tied hashes. |
| 1565 | |
| 1566 | =back |
| 1567 | |
| 1568 | =head3 L<perlsyn> |
| 1569 | |
| 1570 | =over 4 |
| 1571 | |
| 1572 | =item * |
| 1573 | |
| 1574 | An ambiguity in the documentation of the C<...> statement has been corrected. |
| 1575 | L<[perl #122661]|https://rt.perl.org/Ticket/Display.html?id=122661> |
| 1576 | |
| 1577 | =item * |
| 1578 | |
| 1579 | The empty conditional in C<< for >> and C<< while >> is now documented |
| 1580 | in L<< perlsyn >>. |
| 1581 | |
| 1582 | =back |
| 1583 | |
| 1584 | =head3 L<perlunicode> |
| 1585 | |
| 1586 | =over 4 |
| 1587 | |
| 1588 | =item * |
| 1589 | |
| 1590 | This has had extensive revisions to bring it up-to-date with current |
| 1591 | Unicode support and to make it more readable. Notable is that Unicode |
| 1592 | 7.0 changed what it should do with non-characters. Perl retains the old |
| 1593 | way of handling for reasons of backward compatibility. See |
| 1594 | L<perlunicode/Noncharacter code points>. |
| 1595 | |
| 1596 | =back |
| 1597 | |
| 1598 | =head3 L<perluniintro> |
| 1599 | |
| 1600 | =over 4 |
| 1601 | |
| 1602 | =item * |
| 1603 | |
| 1604 | Advice for how to make sure your strings and regular expression patterns are |
| 1605 | interpreted as Unicode has been updated. |
| 1606 | |
| 1607 | =back |
| 1608 | |
| 1609 | =head3 L<perlvar> |
| 1610 | |
| 1611 | =over 4 |
| 1612 | |
| 1613 | =item * |
| 1614 | |
| 1615 | C<$]> is no longer listed as being deprecated. Instead, discussion has |
| 1616 | been added on the advantages and disadvantages of using it versus |
| 1617 | C<$^V>. C<$OLD_PERL_VERSION> was re-added to the documentation as the long |
| 1618 | form of C<$]>. |
| 1619 | |
| 1620 | =item * |
| 1621 | |
| 1622 | C<${^ENCODING}> is now marked as deprecated. |
| 1623 | |
| 1624 | =item * |
| 1625 | |
| 1626 | The entry for C<%^H> has been clarified to indicate it can only handle |
| 1627 | simple values. |
| 1628 | |
| 1629 | =back |
| 1630 | |
| 1631 | =head3 L<perlvms> |
| 1632 | |
| 1633 | =over 4 |
| 1634 | |
| 1635 | =item * |
| 1636 | |
| 1637 | Out-of-date and/or incorrect material has been removed. |
| 1638 | |
| 1639 | =item * |
| 1640 | |
| 1641 | Updated documentation on environment and shell interaction in VMS. |
| 1642 | |
| 1643 | =back |
| 1644 | |
| 1645 | =head3 L<perlxs> |
| 1646 | |
| 1647 | =over 4 |
| 1648 | |
| 1649 | =item * |
| 1650 | |
| 1651 | Added a discussion of locale issues in XS code. |
| 1652 | |
| 1653 | =back |
| 1654 | |
| 1655 | =head1 Diagnostics |
| 1656 | |
| 1657 | The following additions or changes have been made to diagnostic output, |
| 1658 | including warnings and fatal error messages. For the complete list of |
| 1659 | diagnostic messages, see L<perldiag>. |
| 1660 | |
| 1661 | =head2 New Diagnostics |
| 1662 | |
| 1663 | =head3 New Errors |
| 1664 | |
| 1665 | =over 4 |
| 1666 | |
| 1667 | =item * |
| 1668 | |
| 1669 | L<Bad symbol for scalar|perldiag/"Bad symbol for scalar"> |
| 1670 | |
| 1671 | (P) An internal request asked to add a scalar entry to something that |
| 1672 | wasn't a symbol table entry. |
| 1673 | |
| 1674 | =item * |
| 1675 | |
| 1676 | L<Can't use a hash as a reference|perldiag/"Can't use a hash as a reference"> |
| 1677 | |
| 1678 | (F) You tried to use a hash as a reference, as in |
| 1679 | C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl E<lt>= 5.6.1 |
| 1680 | used to allow this syntax, but shouldn't have. |
| 1681 | |
| 1682 | =item * |
| 1683 | |
| 1684 | L<Can't use an array as a reference|perldiag/"Can't use an array as a reference"> |
| 1685 | |
| 1686 | (F) You tried to use an array as a reference, as in |
| 1687 | C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl E<lt>= 5.6.1 used to |
| 1688 | allow this syntax, but shouldn't have. |
| 1689 | |
| 1690 | =item * |
| 1691 | |
| 1692 | 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()?)"> |
| 1693 | |
| 1694 | (F) C<defined()> is not useful on arrays because it |
| 1695 | checks for an undefined I<scalar> value. If you want to see if the |
| 1696 | array is empty, just use S<C<if (@array) { # not empty }>> for example. |
| 1697 | |
| 1698 | =item * |
| 1699 | |
| 1700 | 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()?)"> |
| 1701 | |
| 1702 | (F) C<defined()> is not usually right on hashes. |
| 1703 | |
| 1704 | Although S<C<defined %hash>> is false on a plain not-yet-used hash, it |
| 1705 | becomes true in several non-obvious circumstances, including iterators, |
| 1706 | weak references, stash names, even remaining true after S<C<undef %hash>>. |
| 1707 | These things make S<C<defined %hash>> fairly useless in practice, so it now |
| 1708 | generates a fatal error. |
| 1709 | |
| 1710 | If a check for non-empty is what you wanted then just put it in boolean |
| 1711 | context (see L<perldata/Scalar values>): |
| 1712 | |
| 1713 | if (%hash) { |
| 1714 | # not empty |
| 1715 | } |
| 1716 | |
| 1717 | If you had S<C<defined %Foo::Bar::QUUX>> to check whether such a package |
| 1718 | variable exists then that's never really been reliable, and isn't |
| 1719 | a good way to enquire about the features of a package, or whether |
| 1720 | it's loaded, etc. |
| 1721 | |
| 1722 | =item * |
| 1723 | |
| 1724 | L<Cannot chr %f|perldiag/"Cannot chr %f"> |
| 1725 | |
| 1726 | (F) You passed an invalid number (like an infinity or not-a-number) to |
| 1727 | C<chr>. |
| 1728 | |
| 1729 | =item * |
| 1730 | |
| 1731 | L<Cannot compress %f in pack|perldiag/"Cannot compress %f in pack"> |
| 1732 | |
| 1733 | (F) You tried converting an infinity or not-a-number to an unsigned |
| 1734 | character, which makes no sense. |
| 1735 | |
| 1736 | =item * |
| 1737 | |
| 1738 | L<Cannot pack %f with '%c'|perldiag/"Cannot pack %f with '%c'"> |
| 1739 | |
| 1740 | (F) You tried converting an infinity or not-a-number to a character, |
| 1741 | which makes no sense. |
| 1742 | |
| 1743 | =item * |
| 1744 | |
| 1745 | L<Cannot print %f with '%c'|perldiag/"Cannot printf %f with '%c'"> |
| 1746 | |
| 1747 | (F) You tried printing an infinity or not-a-number as a character (C<%c>), |
| 1748 | which makes no sense. Maybe you meant C<'%s'>, or just stringifying it? |
| 1749 | |
| 1750 | =item * |
| 1751 | |
| 1752 | L<charnames alias definitions may not contain a sequence of multiple spaces|perldiag/"charnames alias definitions may not contain a sequence of multiple spaces"> |
| 1753 | |
| 1754 | (F) You defined a character name which had multiple space |
| 1755 | characters in a row. Change them to single spaces. Usually these |
| 1756 | names are defined in the C<:alias> import argument to C<use charnames>, but |
| 1757 | they could be defined by a translator installed into C<$^H{charnames}>. |
| 1758 | See L<charnames/CUSTOM ALIASES>. |
| 1759 | |
| 1760 | =item * |
| 1761 | |
| 1762 | L<charnames alias definitions may not contain trailing white-space|perldiag/"charnames alias definitions may not contain trailing white-space"> |
| 1763 | |
| 1764 | (F) You defined a character name which ended in a space |
| 1765 | character. Remove the trailing space(s). Usually these names are |
| 1766 | defined in the C<:alias> import argument to C<use charnames>, but they |
| 1767 | could be defined by a translator installed into C<$^H{charnames}>. |
| 1768 | See L<charnames/CUSTOM ALIASES>. |
| 1769 | |
| 1770 | =item * |
| 1771 | |
| 1772 | L<:const is not permitted on named subroutines|perldiag/":const is not permitted on named subroutines"> |
| 1773 | |
| 1774 | (F) The C<const> attribute causes an anonymous subroutine to be run and |
| 1775 | its value captured at the time that it is cloned. Named subroutines are |
| 1776 | not cloned like this, so the attribute does not make sense on them. |
| 1777 | |
| 1778 | =item * |
| 1779 | |
| 1780 | L<Hexadecimal float: internal error|perldiag/"Hexadecimal float: internal error"> |
| 1781 | |
| 1782 | (F) Something went horribly bad in hexadecimal float handling. |
| 1783 | |
| 1784 | =item * |
| 1785 | |
| 1786 | L<Hexadecimal float: unsupported long double format|perldiag/"Hexadecimal float: unsupported long double format"> |
| 1787 | |
| 1788 | (F) You have configured Perl to use long doubles but |
| 1789 | the internals of the long double format are unknown, |
| 1790 | therefore the hexadecimal float output is impossible. |
| 1791 | |
| 1792 | =item * |
| 1793 | |
| 1794 | L<Illegal suidscript|perldiag/"Illegal suidscript"> |
| 1795 | |
| 1796 | (F) The script run under suidperl was somehow illegal. |
| 1797 | |
| 1798 | =item * |
| 1799 | |
| 1800 | 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/"> |
| 1801 | |
| 1802 | (F) The two-character sequence C<"(?"> in |
| 1803 | this context in a regular expression pattern should be an |
| 1804 | indivisible token, with nothing intervening between the C<"("> |
| 1805 | and the C<"?">, but you separated them. |
| 1806 | |
| 1807 | =item * |
| 1808 | |
| 1809 | 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/"> |
| 1810 | |
| 1811 | (F) The two-character sequence C<"(*"> in |
| 1812 | this context in a regular expression pattern should be an |
| 1813 | indivisible token, with nothing intervening between the C<"("> |
| 1814 | and the C<"*">, but you separated them. |
| 1815 | |
| 1816 | =item * |
| 1817 | |
| 1818 | 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/"> |
| 1819 | |
| 1820 | (F) The pattern looks like a {min,max} quantifier, but the min or max could not |
| 1821 | be parsed as a valid number: either it has leading zeroes, or it represents |
| 1822 | too big a number to cope with. The S<<-- HERE> shows where in the regular |
| 1823 | expression the problem was discovered. See L<perlre>. |
| 1824 | |
| 1825 | =item * |
| 1826 | |
| 1827 | L<'%s' is an unknown bound type in regex|perldiag/"'%s' is an unknown bound type in regex; marked by <-- HERE in m/%s/"> |
| 1828 | |
| 1829 | (F) You used C<\b{...}> or C<\B{...}> and the C<...> is not known to |
| 1830 | Perl. The current valid ones are given in |
| 1831 | L<perlrebackslash/\b{}, \b, \B{}, \B>. |
| 1832 | |
| 1833 | =item * |
| 1834 | |
| 1835 | L<Missing or undefined argument to require|perldiag/Missing or undefined argument to require> |
| 1836 | |
| 1837 | (F) You tried to call C<require> with no argument or with an undefined |
| 1838 | value as an argument. C<require> expects either a package name or a |
| 1839 | file-specification as an argument. See L<perlfunc/require>. |
| 1840 | |
| 1841 | Formerly, C<require> with no argument or C<undef> warned about a Null filename. |
| 1842 | |
| 1843 | =back |
| 1844 | |
| 1845 | =head3 New Warnings |
| 1846 | |
| 1847 | =over 4 |
| 1848 | |
| 1849 | =item * |
| 1850 | |
| 1851 | L<\C is deprecated in regex|perldiag/"\C is deprecated in regex; marked by <-- HERE in m/%s/"> |
| 1852 | |
| 1853 | (D deprecated) The C<< /\C/ >> character class was deprecated in v5.20, and |
| 1854 | now emits a warning. It is intended that it will become an error in v5.24. |
| 1855 | This character class matches a single byte even if it appears within a |
| 1856 | multi-byte character, breaks encapsulation, and can corrupt UTF-8 |
| 1857 | strings. |
| 1858 | |
| 1859 | =item * |
| 1860 | |
| 1861 | 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>> |
| 1862 | |
| 1863 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) |
| 1864 | |
| 1865 | You specified a character that has the given plainer way of writing it, |
| 1866 | and which is also portable to platforms running with different character |
| 1867 | sets. |
| 1868 | |
| 1869 | =item * |
| 1870 | |
| 1871 | L<Argument "%s" treated as 0 in increment (++)|perldiag/"Argument "%s" treated |
| 1872 | as 0 in increment (++)"> |
| 1873 | |
| 1874 | (W numeric) The indicated string was fed as an argument to the C<++> operator |
| 1875 | which expects either a number or a string matching C</^[a-zA-Z]*[0-9]*\z/>. |
| 1876 | See L<perlop/Auto-increment and Auto-decrement> for details. |
| 1877 | |
| 1878 | =item * |
| 1879 | |
| 1880 | 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/"> |
| 1881 | |
| 1882 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) |
| 1883 | |
| 1884 | In a bracketed character class in a regular expression pattern, you |
| 1885 | had a range which has exactly one end of it specified using C<\N{}>, and |
| 1886 | the other end is specified using a non-portable mechanism. Perl treats |
| 1887 | the range as a Unicode range, that is, all the characters in it are |
| 1888 | considered to be the Unicode characters, and which may be different code |
| 1889 | points on some platforms Perl runs on. For example, C<[\N{U+06}-\x08]> |
| 1890 | is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it |
| 1891 | matches the characters whose code points in Unicode are 6, 7, and 8. |
| 1892 | But that C<\x08> might indicate that you meant something different, so |
| 1893 | the warning gets raised. |
| 1894 | |
| 1895 | =item * |
| 1896 | |
| 1897 | 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".> |
| 1898 | |
| 1899 | (W locale) You are 1) running under "C<use locale>"; 2) the current |
| 1900 | locale is not a UTF-8 one; 3) you tried to do the designated case-change |
| 1901 | operation on the specified Unicode character; and 4) the result of this |
| 1902 | operation would mix Unicode and locale rules, which likely conflict. |
| 1903 | |
| 1904 | The warnings category C<locale> is new. |
| 1905 | |
| 1906 | =item * |
| 1907 | |
| 1908 | L<:const is experimental|perldiag/":const is experimental"> |
| 1909 | |
| 1910 | (S experimental::const_attr) The C<const> attribute is experimental. |
| 1911 | If you want to use the feature, disable the warning with C<no warnings |
| 1912 | 'experimental::const_attr'>, but know that in doing so you are taking |
| 1913 | the risk that your code may break in a future Perl version. |
| 1914 | |
| 1915 | =item * |
| 1916 | |
| 1917 | L<gmtime(%f) failed|perldiag/"gmtime(%f) failed"> |
| 1918 | |
| 1919 | (W overflow) You called C<gmtime> with a number that it could not handle: |
| 1920 | too large, too small, or NaN. The returned value is C<undef>. |
| 1921 | |
| 1922 | =item * |
| 1923 | |
| 1924 | L<Hexadecimal float: exponent overflow|perldiag/"Hexadecimal float: exponent overflow"> |
| 1925 | |
| 1926 | (W overflow) The hexadecimal floating point has larger exponent |
| 1927 | than the floating point supports. |
| 1928 | |
| 1929 | =item * |
| 1930 | |
| 1931 | L<Hexadecimal float: exponent underflow|perldiag/"Hexadecimal float: exponent underflow"> |
| 1932 | |
| 1933 | (W overflow) The hexadecimal floating point has smaller exponent |
| 1934 | than the floating point supports. |
| 1935 | |
| 1936 | =item * |
| 1937 | |
| 1938 | L<Hexadecimal float: mantissa overflow|perldiag/"Hexadecimal float: mantissa overflow"> |
| 1939 | |
| 1940 | (W overflow) The hexadecimal floating point literal had more bits in |
| 1941 | the mantissa (the part between the C<0x> and the exponent, also known as |
| 1942 | the fraction or the significand) than the floating point supports. |
| 1943 | |
| 1944 | =item * |
| 1945 | |
| 1946 | L<Hexadecimal float: precision loss|perldiag/"Hexadecimal float: precision loss"> |
| 1947 | |
| 1948 | (W overflow) The hexadecimal floating point had internally more |
| 1949 | digits than could be output. This can be caused by unsupported |
| 1950 | long double formats, or by 64-bit integers not being available |
| 1951 | (needed to retrieve the digits under some configurations). |
| 1952 | |
| 1953 | =item * |
| 1954 | |
| 1955 | L<Locale '%s' may not work well.%s|perldiag/Locale '%s' may not work well.%s> |
| 1956 | |
| 1957 | (W locale) You are using the named locale, which is a non-UTF-8 one, and |
| 1958 | which perl has determined is not fully compatible with what it can |
| 1959 | handle. The second C<%s> gives a reason. |
| 1960 | |
| 1961 | The warnings category C<locale> is new. |
| 1962 | |
| 1963 | =item * |
| 1964 | |
| 1965 | L<localtime(%f) failed|perldiag/"localtime(%f) failed"> |
| 1966 | |
| 1967 | (W overflow) You called C<localtime> with a number that it could not handle: |
| 1968 | too large, too small, or NaN. The returned value is C<undef>. |
| 1969 | |
| 1970 | =item * |
| 1971 | |
| 1972 | L<Negative repeat count does nothing|perldiag/"Negative repeat count does nothing"> |
| 1973 | |
| 1974 | (W numeric) You tried to execute the |
| 1975 | L<C<x>|perlop/Multiplicative Operators> repetition operator fewer than 0 |
| 1976 | times, which doesn't make sense. |
| 1977 | |
| 1978 | =item * |
| 1979 | |
| 1980 | L<NO-BREAK SPACE in a charnames alias definition is deprecated|perldiag/"NO-BREAK SPACE in a charnames alias definition is deprecated"> |
| 1981 | |
| 1982 | (D deprecated) You defined a character name which contained a no-break |
| 1983 | space character. Change it to a regular space. Usually these names are |
| 1984 | defined in the C<:alias> import argument to C<use charnames>, but they |
| 1985 | could be defined by a translator installed into C<$^H{charnames}>. See |
| 1986 | L<charnames/CUSTOM ALIASES>. |
| 1987 | |
| 1988 | =item * |
| 1989 | |
| 1990 | L<Non-finite repeat count does nothing|perldiag/"Non-finite repeat count does nothing"> |
| 1991 | |
| 1992 | (W numeric) You tried to execute the |
| 1993 | L<C<x>|perlop/Multiplicative Operators> repetition operator C<Inf> (or |
| 1994 | C<-Inf>) or NaN times, which doesn't make sense. |
| 1995 | |
| 1996 | =item * |
| 1997 | |
| 1998 | L<PerlIO layer ':win32' is experimental|perldiag/"PerlIO layer ':win32' is experimental"> |
| 1999 | |
| 2000 | (S experimental::win32_perlio) The C<:win32> PerlIO layer is |
| 2001 | experimental. If you want to take the risk of using this layer, |
| 2002 | simply disable this warning: |
| 2003 | |
| 2004 | no warnings "experimental::win32_perlio"; |
| 2005 | |
| 2006 | =item * |
| 2007 | |
| 2008 | L<Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by <-- HERE in mE<sol>%sE<sol>"> |
| 2009 | |
| 2010 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) |
| 2011 | |
| 2012 | Stricter rules help to find typos and other errors. Perhaps you didn't |
| 2013 | even intend a range here, if the C<"-"> was meant to be some other |
| 2014 | character, or should have been escaped (like C<"\-">). If you did |
| 2015 | intend a range, the one that was used is not portable between ASCII and |
| 2016 | EBCDIC platforms, and doesn't have an obvious meaning to a casual |
| 2017 | reader. |
| 2018 | |
| 2019 | [3-7] # OK; Obvious and portable |
| 2020 | [d-g] # OK; Obvious and portable |
| 2021 | [A-Y] # OK; Obvious and portable |
| 2022 | [A-z] # WRONG; Not portable; not clear what is meant |
| 2023 | [a-Z] # WRONG; Not portable; not clear what is meant |
| 2024 | [%-.] # WRONG; Not portable; not clear what is meant |
| 2025 | [\x41-Z] # WRONG; Not portable; not obvious to non-geek |
| 2026 | |
| 2027 | (You can force portability by specifying a Unicode range, which means that |
| 2028 | the endpoints are specified by |
| 2029 | L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may |
| 2030 | still not be obvious.) |
| 2031 | The stricter rules require that ranges that start or stop with an ASCII |
| 2032 | character that is not a control have all their endpoints be a literal |
| 2033 | character, and not some escape sequence (like C<"\x41">), and the ranges |
| 2034 | must be all digits, or all uppercase letters, or all lowercase letters. |
| 2035 | |
| 2036 | =item * |
| 2037 | |
| 2038 | 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/"> |
| 2039 | |
| 2040 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) |
| 2041 | |
| 2042 | Stricter rules help to find typos and other errors. You included a |
| 2043 | range, and at least one of the end points is a decimal digit. Under the |
| 2044 | stricter rules, when this happens, both end points should be digits in |
| 2045 | the same group of 10 consecutive digits. |
| 2046 | |
| 2047 | =item * |
| 2048 | |
| 2049 | L<Redundant argument in %s|perldiag/Redundant argument in %s> |
| 2050 | |
| 2051 | (W redundant) You called a function with more arguments than were |
| 2052 | needed, as indicated by information within other arguments you supplied |
| 2053 | (I<e.g>. a printf format). Currently only emitted when a printf-type format |
| 2054 | required fewer arguments than were supplied, but might be used in the |
| 2055 | future for I<e.g.> L<perlfunc/pack>. |
| 2056 | |
| 2057 | The warnings category C<< redundant >> is new. See also |
| 2058 | L<[perl #121025]|https://rt.perl.org/Ticket/Display.html?id=121025>. |
| 2059 | |
| 2060 | =item * |
| 2061 | |
| 2062 | L<Replacement list is longer than search list|perldiag/Replacement list is longer than search list> |
| 2063 | |
| 2064 | This is not a new diagnostic, but in earlier releases was accidentally |
| 2065 | not displayed if the transliteration contained wide characters. This is |
| 2066 | now fixed, so that you may see this diagnostic in places where you |
| 2067 | previously didn't (but should have). |
| 2068 | |
| 2069 | =item * |
| 2070 | |
| 2071 | 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"> |
| 2072 | |
| 2073 | (W locale) You are matching a regular expression using locale rules, |
| 2074 | and a Unicode boundary is being matched, but the locale is not a Unicode |
| 2075 | one. This doesn't make sense. Perl will continue, assuming a Unicode |
| 2076 | (UTF-8) locale, but the results could well be wrong except if the locale |
| 2077 | happens to be ISO-8859-1 (Latin1) where this message is spurious and can |
| 2078 | be ignored. |
| 2079 | |
| 2080 | The warnings category C<locale> is new. |
| 2081 | |
| 2082 | =item * |
| 2083 | |
| 2084 | 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>" >> |
| 2085 | |
| 2086 | (W regexp) You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a |
| 2087 | portion of a regular expression where the character set modifiers C</a> |
| 2088 | or C</aa> are in effect. These two modifiers indicate an ASCII |
| 2089 | interpretation, and this doesn't make sense for a Unicode definition. |
| 2090 | The generated regular expression will compile so that the boundary uses |
| 2091 | all of Unicode. No other portion of the regular expression is affected. |
| 2092 | |
| 2093 | =item * |
| 2094 | |
| 2095 | L<The bitwise feature is experimental|perldiag/"The bitwise feature is experimental"> |
| 2096 | |
| 2097 | (S experimental::bitwise) This warning is emitted if you use bitwise |
| 2098 | operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled. |
| 2099 | Simply suppress the warning if you want to use the feature, but know |
| 2100 | that in doing so you are taking the risk of using an experimental |
| 2101 | feature which may change or be removed in a future Perl version: |
| 2102 | |
| 2103 | no warnings "experimental::bitwise"; |
| 2104 | use feature "bitwise"; |
| 2105 | $x |.= $y; |
| 2106 | |
| 2107 | =item * |
| 2108 | |
| 2109 | L<Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in m/%s/"> |
| 2110 | |
| 2111 | (D deprecated, regexp) You used a literal C<"{"> character in a regular |
| 2112 | expression pattern. You should change to use C<"\{"> instead, because a future |
| 2113 | version of Perl (tentatively v5.26) will consider this to be a syntax error. If |
| 2114 | the pattern delimiters are also braces, any matching right brace |
| 2115 | (C<"}">) should also be escaped to avoid confusing the parser, for |
| 2116 | example, |
| 2117 | |
| 2118 | qr{abc\{def\}ghi} |
| 2119 | |
| 2120 | =item * |
| 2121 | |
| 2122 | L<Use of literal non-graphic characters in variable names is deprecated|perldiag/"Use of literal non-graphic characters in variable names is deprecated"> |
| 2123 | |
| 2124 | (D deprecated) Using literal non-graphic (including control) |
| 2125 | characters in the source to refer to the I<^FOO> variables, like C<$^X> and |
| 2126 | C<${^GLOBAL_PHASE}> is now deprecated. |
| 2127 | |
| 2128 | =item * |
| 2129 | |
| 2130 | L<Useless use of attribute "const"|perldiag/Useless use of attribute "const"> |
| 2131 | |
| 2132 | (W misc) The C<const> attribute has no effect except |
| 2133 | on anonymous closure prototypes. You applied it to |
| 2134 | a subroutine via L<attributes.pm|attributes>. This is only useful |
| 2135 | inside an attribute handler for an anonymous subroutine. |
| 2136 | |
| 2137 | =item * |
| 2138 | |
| 2139 | L<Useless use of E<sol>d modifier in transliteration operator|perldiag/"Useless use of /d modifier in transliteration operator"> |
| 2140 | |
| 2141 | This is not a new diagnostic, but in earlier releases was accidentally |
| 2142 | not displayed if the transliteration contained wide characters. This is |
| 2143 | now fixed, so that you may see this diagnostic in places where you |
| 2144 | previously didn't (but should have). |
| 2145 | |
| 2146 | =item * |
| 2147 | |
| 2148 | L<E<quot>use re 'strict'E<quot> is experimental|perldiag/"use re 'strict'" is experimental> |
| 2149 | |
| 2150 | (S experimental::re_strict) The things that are different when a regular |
| 2151 | expression pattern is compiled under C<'strict'> are subject to change |
| 2152 | in future Perl releases in incompatible ways; there are also proposals |
| 2153 | to change how to enable strict checking instead of using this subpragma. |
| 2154 | This means that a pattern that compiles today may not in a future Perl |
| 2155 | release. This warning is to alert you to that risk. |
| 2156 | |
| 2157 | =item * |
| 2158 | |
| 2159 | L<Warning: unable to close filehandle properly: %s|perldiag/"Warning: unable to close filehandle properly: %s"> |
| 2160 | |
| 2161 | L<Warning: unable to close filehandle %s properly: %s|perldiag/"Warning: unable to close filehandle %s properly: %s"> |
| 2162 | |
| 2163 | (S io) Previously, perl silently ignored any errors when doing an implicit |
| 2164 | close of a filehandle, I<i.e.> where the reference count of the filehandle |
| 2165 | reached zero and the user's code hadn't already called C<close()>; I<e.g.> |
| 2166 | |
| 2167 | { |
| 2168 | open my $fh, '>', $file or die "open: '$file': $!\n"; |
| 2169 | print $fh, $data or die; |
| 2170 | } # implicit close here |
| 2171 | |
| 2172 | In a situation such as disk full, due to buffering, the error may only be |
| 2173 | detected during the final close, so not checking the result of the close is |
| 2174 | dangerous. |
| 2175 | |
| 2176 | So perl now warns in such situations. |
| 2177 | |
| 2178 | =item * |
| 2179 | |
| 2180 | L<Wide character (U+%X) in %s|perldiag/"Wide character (U+%X) in %s"> |
| 2181 | |
| 2182 | (W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8 |
| 2183 | one), a multi-byte character was encountered. Perl considers this |
| 2184 | character to be the specified Unicode code point. Combining non-UTF-8 |
| 2185 | locales and Unicode is dangerous. Almost certainly some characters |
| 2186 | will have two different representations. For example, in the ISO 8859-7 |
| 2187 | (Greek) locale, the code point 0xC3 represents a Capital Gamma. But so |
| 2188 | also does 0x393. This will make string comparisons unreliable. |
| 2189 | |
| 2190 | You likely need to figure out how this multi-byte character got mixed up |
| 2191 | with your single-byte locale (or perhaps you thought you had a UTF-8 |
| 2192 | locale, but Perl disagrees). |
| 2193 | |
| 2194 | The warnings category C<locale> is new. |
| 2195 | |
| 2196 | =back |
| 2197 | |
| 2198 | =head2 Changes to Existing Diagnostics |
| 2199 | |
| 2200 | =over 4 |
| 2201 | |
| 2202 | =item * |
| 2203 | |
| 2204 | <> should be quotes |
| 2205 | |
| 2206 | This warning has been changed to |
| 2207 | L<< <> at require-statement should be quotes|perldiag/"<> at require-statement should be quotes" >> |
| 2208 | to make the issue more identifiable. |
| 2209 | |
| 2210 | =item * |
| 2211 | |
| 2212 | L<Argument "%s" isn't numeric%s|perldiag/"Argument "%s" isn't numeric%s"> |
| 2213 | |
| 2214 | The L<perldiag> entry for this warning has added this clarifying note: |
| 2215 | |
| 2216 | Note that for the Inf and NaN (infinity and not-a-number) the |
| 2217 | definition of "numeric" is somewhat unusual: the strings themselves |
| 2218 | (like "Inf") are considered numeric, and anything following them is |
| 2219 | considered non-numeric. |
| 2220 | |
| 2221 | =item * |
| 2222 | |
| 2223 | L<Global symbol "%s" requires explicit package name|perldiag/"Global symbol "%s" requires explicit package name (did you forget to declare "my %s"?)"> |
| 2224 | |
| 2225 | This message has had '(did you forget to declare "my %s"?)' appended to it, to |
| 2226 | make it more helpful to new Perl programmers. |
| 2227 | L<[perl #121638]|https://rt.perl.org/Ticket/Display.html?id=121638> |
| 2228 | |
| 2229 | =item * |
| 2230 | |
| 2231 | '"my" variable &foo::bar can't be in a package' has been reworded to say |
| 2232 | 'subroutine' instead of 'variable'. |
| 2233 | |
| 2234 | =item * |
| 2235 | |
| 2236 | L<<< \N{} in character class restricted to one character in regex; marked by |
| 2237 | S<< <-- HERE >> in mE<sol>%sE<sol>|perldiag/"\N{} in inverted character |
| 2238 | class or as a range end-point is restricted to one character in regex; |
| 2239 | marked by <-- HERE in m/%s/" >>> |
| 2240 | |
| 2241 | This message has had I<character class> changed to I<inverted character |
| 2242 | class or as a range end-point is> to reflect improvements in |
| 2243 | C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>). |
| 2244 | |
| 2245 | =item * |
| 2246 | |
| 2247 | L<panic: frexp|perldiag/"panic: frexp: %f"> |
| 2248 | |
| 2249 | This message has had ': C<%f>' appended to it, to show what the offending |
| 2250 | floating point number is. |
| 2251 | |
| 2252 | =item * |
| 2253 | |
| 2254 | I<Possible precedence problem on bitwise %c operator> reworded as |
| 2255 | L<Possible precedence problem on bitwise %s operator|perldiag/"Possible precedence problem on bitwise %s operator">. |
| 2256 | |
| 2257 | =item * |
| 2258 | |
| 2259 | L<Unsuccessful %s on filename containing newline|perldiag/"Unsuccessful %s on filename containing newline"> |
| 2260 | |
| 2261 | This warning is now only produced when the newline is at the end of |
| 2262 | the filename. |
| 2263 | |
| 2264 | =item * |
| 2265 | |
| 2266 | "Variable C<%s> will not stay shared" has been changed to say "Subroutine" |
| 2267 | when it is actually a lexical sub that will not stay shared. |
| 2268 | |
| 2269 | =item * |
| 2270 | |
| 2271 | L<Variable length lookbehind not implemented in regex mE<sol>%sE<sol>|perldiag/"Variable length lookbehind not implemented in regex m/%s/"> |
| 2272 | |
| 2273 | The L<perldiag> entry for this warning has had information about Unicode |
| 2274 | behavior added. |
| 2275 | |
| 2276 | =back |
| 2277 | |
| 2278 | =head2 Diagnostic Removals |
| 2279 | |
| 2280 | =over |
| 2281 | |
| 2282 | =item * |
| 2283 | |
| 2284 | "Ambiguous use of -foo resolved as -&foo()" |
| 2285 | |
| 2286 | There is actually no ambiguity here, and this impedes the use of negated |
| 2287 | constants; I<e.g.>, C<-Inf>. |
| 2288 | |
| 2289 | =item * |
| 2290 | |
| 2291 | "Constant is not a FOO reference" |
| 2292 | |
| 2293 | Compile-time checking of constant dereferencing (I<e.g.>, C<< my_constant->() >>) |
| 2294 | has been removed, since it was not taking overloading into account. |
| 2295 | L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> |
| 2296 | L<[perl #122607]|https://rt.perl.org/Ticket/Display.html?id=122607> |
| 2297 | |
| 2298 | =back |
| 2299 | |
| 2300 | =head1 Utility Changes |
| 2301 | |
| 2302 | =head2 F<find2perl>, F<s2p> and F<a2p> removal |
| 2303 | |
| 2304 | =over 4 |
| 2305 | |
| 2306 | =item * |
| 2307 | |
| 2308 | The F<x2p/> directory has been removed from the Perl core. |
| 2309 | |
| 2310 | This removes find2perl, s2p and a2p. They have all been released to CPAN as |
| 2311 | separate distributions (C<App::find2perl>, C<App::s2p>, C<App::a2p>). |
| 2312 | |
| 2313 | =back |
| 2314 | |
| 2315 | =head2 L<h2ph> |
| 2316 | |
| 2317 | =over 4 |
| 2318 | |
| 2319 | =item * |
| 2320 | |
| 2321 | F<h2ph> now handles hexadecimal constants in the compiler's predefined |
| 2322 | macro definitions, as visible in C<$Config{cppsymbols}>. |
| 2323 | L<[perl #123784]|https://rt.perl.org/Ticket/Display.html?id=123784>. |
| 2324 | |
| 2325 | =back |
| 2326 | |
| 2327 | =head2 L<encguess> |
| 2328 | |
| 2329 | =over 4 |
| 2330 | |
| 2331 | =item * |
| 2332 | |
| 2333 | No longer depends on non-core modules. |
| 2334 | |
| 2335 | =back |
| 2336 | |
| 2337 | =head1 Configuration and Compilation |
| 2338 | |
| 2339 | =over 4 |
| 2340 | |
| 2341 | =item * |
| 2342 | |
| 2343 | F<Configure> now checks for C<lrintl()>, C<lroundl()>, C<llrintl()>, and |
| 2344 | C<llroundl()>. |
| 2345 | |
| 2346 | =item * |
| 2347 | |
| 2348 | F<Configure> with C<-Dmksymlinks> should now be faster. |
| 2349 | L<[perl #122002]|https://rt.perl.org/Ticket/Display.html?id=122002>. |
| 2350 | |
| 2351 | =item * |
| 2352 | |
| 2353 | The C<pthreads> and C<cl> libraries will be linked by default if present. |
| 2354 | This allows XS modules that require threading to work on non-threaded |
| 2355 | perls. Note that you must still pass C<-Dusethreads> if you want a |
| 2356 | threaded perl. |
| 2357 | |
| 2358 | =item * |
| 2359 | |
| 2360 | To get more precision and range for floating point numbers one can now |
| 2361 | use the GCC quadmath library which implements the quadruple precision |
| 2362 | floating point numbers on x86 and IA-64 platforms. See F<INSTALL> for |
| 2363 | details. |
| 2364 | |
| 2365 | =item * |
| 2366 | |
| 2367 | MurmurHash64A and MurmurHash64B can now be configured as the internal hash |
| 2368 | function. |
| 2369 | |
| 2370 | =item * |
| 2371 | |
| 2372 | C<make test.valgrind> now supports parallel testing. |
| 2373 | |
| 2374 | For example: |
| 2375 | |
| 2376 | TEST_JOBS=9 make test.valgrind |
| 2377 | |
| 2378 | See L<perlhacktips/valgrind> for more information. |
| 2379 | |
| 2380 | L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> |
| 2381 | |
| 2382 | =item * |
| 2383 | |
| 2384 | The MAD (Misc Attribute Decoration) build option has been removed |
| 2385 | |
| 2386 | This was an unmaintained attempt at preserving |
| 2387 | the Perl parse tree more faithfully so that automatic conversion of |
| 2388 | Perl 5 to Perl 6 would have been easier. |
| 2389 | |
| 2390 | This build-time configuration option had been unmaintained for years, |
| 2391 | and had probably seriously diverged on both Perl 5 and Perl 6 sides. |
| 2392 | |
| 2393 | =item * |
| 2394 | |
| 2395 | A new compilation flag, C<< -DPERL_OP_PARENT >> is available. For details, |
| 2396 | see the discussion below at L<< /Internal Changes >>. |
| 2397 | |
| 2398 | =item * |
| 2399 | |
| 2400 | Pathtools no longer tries to load XS on miniperl. This speeds up building perl |
| 2401 | slightly. |
| 2402 | |
| 2403 | =back |
| 2404 | |
| 2405 | =head1 Testing |
| 2406 | |
| 2407 | =over 4 |
| 2408 | |
| 2409 | =item * |
| 2410 | |
| 2411 | F<t/porting/re_context.t> has been added to test that L<utf8> and its |
| 2412 | dependencies only use the subset of the C<$1..$n> capture vars that |
| 2413 | C<Perl_save_re_context()> is hard-coded to localize, because that function |
| 2414 | has no efficient way of determining at runtime what vars to localize. |
| 2415 | |
| 2416 | =item * |
| 2417 | |
| 2418 | Tests for performance issues have been added in the file F<t/perf/taint.t>. |
| 2419 | |
| 2420 | =item * |
| 2421 | |
| 2422 | Some regular expression tests are written in such a way that they will |
| 2423 | run very slowly if certain optimizations break. These tests have been |
| 2424 | moved into new files, F<< t/re/speed.t >> and F<< t/re/speed_thr.t >>, |
| 2425 | and are run with a C<< watchdog() >>. |
| 2426 | |
| 2427 | =item * |
| 2428 | |
| 2429 | C<< test.pl >> now allows C<< plan skip_all => $reason >>, to make it |
| 2430 | more compatible with C<< Test::More >>. |
| 2431 | |
| 2432 | =item * |
| 2433 | |
| 2434 | A new test script, F<op/infnan.t>, has been added to test if infinity and NaN are |
| 2435 | working correctly. See L</Infinity and NaN (not-a-number) handling improved>. |
| 2436 | |
| 2437 | =back |
| 2438 | |
| 2439 | =head1 Platform Support |
| 2440 | |
| 2441 | =head2 Regained Platforms |
| 2442 | |
| 2443 | =over 4 |
| 2444 | |
| 2445 | =item IRIX and Tru64 platforms are working again. |
| 2446 | |
| 2447 | Some C<make test> failures remain: |
| 2448 | L<[perl #123977]|https://rt.perl.org/Ticket/Display.html?id=123977> |
| 2449 | and L<[perl #125298]|https://rt.perl.org/Ticket/Display.html?id=125298> |
| 2450 | for IRIX; L<[perl #124212]|https://rt.perl.org/Ticket/Display.html?id=124212>, |
| 2451 | L<[cpan #99605]|https://rt.cpan.org/Public/Bug/Display.html?id=99605>, and |
| 2452 | L<[cpan #104836]|https://rt.cpan.org/Ticket/Display.html?id=104836> for Tru64. |
| 2453 | |
| 2454 | =item z/OS running EBCDIC Code Page 1047 |
| 2455 | |
| 2456 | Core perl now works on this EBCDIC platform. Earlier perls also worked, but, |
| 2457 | even though support wasn't officially withdrawn, recent perls would not compile |
| 2458 | and run well. Perl 5.20 would work, but had many bugs which have now been |
| 2459 | fixed. Many CPAN modules that ship with Perl still fail tests, including |
| 2460 | C<Pod::Simple>. However the version of C<Pod::Simple> currently on CPAN should work; |
| 2461 | it was fixed too late to include in Perl 5.22. Work is under way to fix many |
| 2462 | of the still-broken CPAN modules, which likely will be installed on CPAN when |
| 2463 | completed, so that you may not have to wait until Perl 5.24 to get a working |
| 2464 | version. |
| 2465 | |
| 2466 | =back |
| 2467 | |
| 2468 | =head2 Discontinued Platforms |
| 2469 | |
| 2470 | =over 4 |
| 2471 | |
| 2472 | =item NeXTSTEP/OPENSTEP |
| 2473 | |
| 2474 | NeXTSTEP was a proprietary operating system bundled with NeXT's |
| 2475 | workstations in the early to mid 90s; OPENSTEP was an API specification |
| 2476 | that provided a NeXTSTEP-like environment on a non-NeXTSTEP system. Both |
| 2477 | are now long dead, so support for building Perl on them has been removed. |
| 2478 | |
| 2479 | =back |
| 2480 | |
| 2481 | =head2 Platform-Specific Notes |
| 2482 | |
| 2483 | =over 4 |
| 2484 | |
| 2485 | =item EBCDIC |
| 2486 | |
| 2487 | Special handling is required of the perl interpreter on EBCDIC platforms |
| 2488 | to get C<qr/[i-j]/> to match only C<"i"> and C<"j">, since there are 7 |
| 2489 | characters between the |
| 2490 | code points for C<"i"> and C<"j">. This special handling had only been |
| 2491 | invoked when both ends of the range are literals. Now it is also |
| 2492 | invoked if any of the C<\N{...}> forms for specifying a character by |
| 2493 | name or Unicode code point is used instead of a literal. See |
| 2494 | L<perlrecharclass/Character Ranges>. |
| 2495 | |
| 2496 | =item HP-UX |
| 2497 | |
| 2498 | The archname now distinguishes use64bitint from use64bitall. |
| 2499 | |
| 2500 | =item Android |
| 2501 | |
| 2502 | Build support has been improved for cross-compiling in general and for |
| 2503 | Android in particular. |
| 2504 | |
| 2505 | =item VMS |
| 2506 | |
| 2507 | =over 4 |
| 2508 | |
| 2509 | =item * |
| 2510 | |
| 2511 | When spawning a subprocess without waiting, the return value is now |
| 2512 | the correct PID. |
| 2513 | |
| 2514 | =item * |
| 2515 | |
| 2516 | Fix a prototype so linking doesn't fail under the VMS C++ compiler. |
| 2517 | |
| 2518 | =item * |
| 2519 | |
| 2520 | C<finite>, C<finitel>, and C<isfinite> detection has been added to |
| 2521 | C<configure.com>, environment handling has had some minor changes, and |
| 2522 | a fix for legacy feature checking status. |
| 2523 | |
| 2524 | =back |
| 2525 | |
| 2526 | =item Win32 |
| 2527 | |
| 2528 | =over 4 |
| 2529 | |
| 2530 | =item * |
| 2531 | |
| 2532 | F<miniperl.exe> is now built with C<-fno-strict-aliasing>, allowing 64-bit |
| 2533 | builds to complete on GCC 4.8. |
| 2534 | L<[perl #123976]|https://rt.perl.org/Ticket/Display.html?id=123976> |
| 2535 | |
| 2536 | =item * |
| 2537 | |
| 2538 | C<nmake minitest> now works on Win32. Due to dependency issues you |
| 2539 | need to build C<nmake test-prep> first, and a small number of the |
| 2540 | tests fail. |
| 2541 | L<[perl #123394]|https://rt.perl.org/Ticket/Display.html?id=123394> |
| 2542 | |
| 2543 | =item * |
| 2544 | |
| 2545 | Perl can now be built in C++ mode on Windows by setting the makefile macro |
| 2546 | C<USE_CPLUSPLUS> to the value "define". |
| 2547 | |
| 2548 | =item * |
| 2549 | |
| 2550 | The list form of piped open has been implemented for Win32. Note: unlike |
| 2551 | C<system LIST> this does not fall back to the shell. |
| 2552 | L<[perl #121159]|https://rt.perl.org/Ticket/Display.html?id=121159> |
| 2553 | |
| 2554 | =item * |
| 2555 | |
| 2556 | New C<DebugSymbols> and C<DebugFull> configuration options added to |
| 2557 | Windows makefiles. |
| 2558 | |
| 2559 | =item * |
| 2560 | |
| 2561 | Previously, compiling XS modules (including CPAN ones) using Visual C++ for |
| 2562 | Win64 resulted in around a dozen warnings per file from F<hv_func.h>. These |
| 2563 | warnings have been silenced. |
| 2564 | |
| 2565 | =item * |
| 2566 | |
| 2567 | Support for building without PerlIO has been removed from the Windows |
| 2568 | makefiles. Non-PerlIO builds were all but deprecated in Perl 5.18.0 and are |
| 2569 | already not supported by F<Configure> on POSIX systems. |
| 2570 | |
| 2571 | =item * |
| 2572 | |
| 2573 | Between 2 and 6 milliseconds and seven I/O calls have been saved per attempt |
| 2574 | to open a perl module for each path in C<@INC>. |
| 2575 | |
| 2576 | =item * |
| 2577 | |
| 2578 | Intel C builds are now always built with C99 mode on. |
| 2579 | |
| 2580 | =item * |
| 2581 | |
| 2582 | C<%I64d> is now being used instead of C<%lld> for MinGW. |
| 2583 | |
| 2584 | =item * |
| 2585 | |
| 2586 | In the experimental C<:win32> layer, a crash in C<open> was fixed. Also |
| 2587 | opening F</dev/null> (which works under Win32 Perl's default C<:unix> |
| 2588 | layer) was implemented for C<:win32>. |
| 2589 | L<[perl #122224]|https://rt.perl.org/Ticket/Display.html?id=122224> |
| 2590 | |
| 2591 | =item * |
| 2592 | |
| 2593 | A new makefile option, C<USE_LONG_DOUBLE>, has been added to the Windows |
| 2594 | dmake makefile for gcc builds only. Set this to "define" if you want perl to |
| 2595 | use long doubles to give more accuracy and range for floating point numbers. |
| 2596 | |
| 2597 | =back |
| 2598 | |
| 2599 | =item OpenBSD |
| 2600 | |
| 2601 | On OpenBSD, Perl will now default to using the system C<malloc> due to the |
| 2602 | security features it provides. Perl's own malloc wrapper has been in use |
| 2603 | since v5.14 due to performance reasons, but the OpenBSD project believes |
| 2604 | the tradeoff is worth it and would prefer that users who need the speed |
| 2605 | specifically ask for it. |
| 2606 | |
| 2607 | L<[perl #122000]|https://rt.perl.org/Ticket/Display.html?id=122000>. |
| 2608 | |
| 2609 | =item Solaris |
| 2610 | |
| 2611 | =over 4 |
| 2612 | |
| 2613 | =item * |
| 2614 | |
| 2615 | We now look for the Sun Studio compiler in both F</opt/solstudio*> and |
| 2616 | F</opt/solarisstudio*>. |
| 2617 | |
| 2618 | =item * |
| 2619 | |
| 2620 | Builds on Solaris 10 with C<-Dusedtrace> would fail early since make |
| 2621 | didn't follow implied dependencies to build C<perldtrace.h>. Added an |
| 2622 | explicit dependency to C<depend>. |
| 2623 | L<[perl #120120]|https://rt.perl.org/Ticket/Display.html?id=120120> |
| 2624 | |
| 2625 | =item * |
| 2626 | |
| 2627 | C99 options have been cleaned up; hints look for C<solstudio> |
| 2628 | as well as C<SUNWspro>; and support for native C<setenv> has been added. |
| 2629 | |
| 2630 | =back |
| 2631 | |
| 2632 | =back |
| 2633 | |
| 2634 | =head1 Internal Changes |
| 2635 | |
| 2636 | =over 4 |
| 2637 | |
| 2638 | =item * |
| 2639 | |
| 2640 | Experimental support has been added to allow ops in the optree to locate |
| 2641 | their parent, if any. This is enabled by the non-default build option |
| 2642 | C<-DPERL_OP_PARENT>. It is envisaged that this will eventually become |
| 2643 | enabled by default, so XS code which directly accesses the C<op_sibling> |
| 2644 | field of ops should be updated to be future-proofed. |
| 2645 | |
| 2646 | On C<PERL_OP_PARENT> builds, the C<op_sibling> field has been renamed |
| 2647 | C<op_sibparent> and a new flag, C<op_moresib>, added. On the last op in a |
| 2648 | sibling chain, C<op_moresib> is false and C<op_sibparent> points to the |
| 2649 | parent (if any) rather than being C<NULL>. |
| 2650 | |
| 2651 | To make existing code work transparently whether using C<PERL_OP_PARENT> |
| 2652 | or not, a number of new macros and functions have been added that should |
| 2653 | be used, rather than directly manipulating C<op_sibling>. |
| 2654 | |
| 2655 | For the case of just reading C<op_sibling> to determine the next sibling, |
| 2656 | two new macros have been added. A simple scan through a sibling chain |
| 2657 | like this: |
| 2658 | |
| 2659 | for (; kid->op_sibling; kid = kid->op_sibling) { ... } |
| 2660 | |
| 2661 | should now be written as: |
| 2662 | |
| 2663 | for (; OpHAS_SIBLING(kid); kid = OpSIBLING(kid)) { ... } |
| 2664 | |
| 2665 | For altering optrees, a general-purpose function C<op_sibling_splice()> |
| 2666 | has been added, which allows for manipulation of a chain of sibling ops. |
| 2667 | By analogy with the Perl function C<splice()>, it allows you to cut out |
| 2668 | zero or more ops from a sibling chain and replace them with zero or more |
| 2669 | new ops. It transparently handles all the updating of sibling, parent, |
| 2670 | op_last pointers etc. |
| 2671 | |
| 2672 | If you need to manipulate ops at a lower level, then three new macros, |
| 2673 | C<OpMORESIB_set>, C<OpLASTSIB_set> and C<OpMAYBESIB_set> are intended to |
| 2674 | be a low-level portable way to set C<op_sibling> / C<op_sibparent> while |
| 2675 | also updating C<op_moresib>. The first sets the sibling pointer to a new |
| 2676 | sibling, the second makes the op the last sibling, and the third |
| 2677 | conditionally does the first or second action. Note that unlike |
| 2678 | C<op_sibling_splice()> these macros won't maintain consistency in the |
| 2679 | parent at the same time (I<e.g.> by updating C<op_first> and C<op_last> where |
| 2680 | appropriate). |
| 2681 | |
| 2682 | A C-level C<Perl_op_parent()> function and a Perl-level C<B::OP::parent()> |
| 2683 | method have been added. The C function only exists under |
| 2684 | C<PERL_OP_PARENT> builds (using it is build-time error on vanilla |
| 2685 | perls). C<B::OP::parent()> exists always, but on a vanilla build it |
| 2686 | always returns C<NULL>. Under C<PERL_OP_PARENT>, they return the parent |
| 2687 | of the current op, if any. The variable C<$B::OP::does_parent> allows you |
| 2688 | to determine whether C<B> supports retrieving an op's parent. |
| 2689 | |
| 2690 | C<PERL_OP_PARENT> was introduced in 5.21.2, but the interface was |
| 2691 | changed considerably in 5.21.11. If you updated your code before the |
| 2692 | 5.21.11 changes, it may require further revision. The main changes after |
| 2693 | 5.21.2 were: |
| 2694 | |
| 2695 | =over 4 |
| 2696 | |
| 2697 | =item * |
| 2698 | |
| 2699 | The C<OP_SIBLING> and C<OP_HAS_SIBLING> macros have been renamed |
| 2700 | C<OpSIBLING> and C<OpHAS_SIBLING> for consistency with other |
| 2701 | op-manipulating macros. |
| 2702 | |
| 2703 | =item * |
| 2704 | |
| 2705 | The C<op_lastsib> field has been renamed C<op_moresib>, and its meaning |
| 2706 | inverted. |
| 2707 | |
| 2708 | =item * |
| 2709 | |
| 2710 | The macro C<OpSIBLING_set> has been removed, and has been superseded by |
| 2711 | C<OpMORESIB_set> I<et al>. |
| 2712 | |
| 2713 | =item * |
| 2714 | |
| 2715 | The C<op_sibling_splice()> function now accepts a null C<parent> argument |
| 2716 | where the splicing doesn't affect the first or last ops in the sibling |
| 2717 | chain |
| 2718 | |
| 2719 | =back |
| 2720 | |
| 2721 | =item * |
| 2722 | |
| 2723 | Macros have been created to allow XS code to better manipulate the POSIX locale |
| 2724 | category C<LC_NUMERIC>. See L<perlapi/Locale-related functions and macros>. |
| 2725 | |
| 2726 | =item * |
| 2727 | |
| 2728 | The previous C<atoi> I<et al> replacement function, C<grok_atou>, has now been |
| 2729 | superseded by C<grok_atoUV>. See L<perlclib> for details. |
| 2730 | |
| 2731 | =item * |
| 2732 | |
| 2733 | A new function, C<Perl_sv_get_backrefs()>, has been added which allows you |
| 2734 | retrieve the weak references, if any, which point at an SV. |
| 2735 | |
| 2736 | =item * |
| 2737 | |
| 2738 | The C<screaminstr()> function has been removed. Although marked as |
| 2739 | public API, it was undocumented and had no usage in CPAN modules. Calling |
| 2740 | it has been fatal since 5.17.0. |
| 2741 | |
| 2742 | =item * |
| 2743 | |
| 2744 | The C<newDEFSVOP()>, C<block_start()>, C<block_end()> and C<intro_my()> |
| 2745 | functions have been added to the API. |
| 2746 | |
| 2747 | =item * |
| 2748 | |
| 2749 | The internal C<convert> function in F<op.c> has been renamed |
| 2750 | C<op_convert_list> and added to the API. |
| 2751 | |
| 2752 | =item * |
| 2753 | |
| 2754 | The C<sv_magic()> function no longer forbids "ext" magic on read-only |
| 2755 | values. After all, perl can't know whether the custom magic will modify |
| 2756 | the SV or not. |
| 2757 | L<[perl #123103]|https://rt.perl.org/Ticket/Display.html?id=123103>. |
| 2758 | |
| 2759 | =item * |
| 2760 | |
| 2761 | Accessing L<perlapi/CvPADLIST> on an XSUB is now forbidden. |
| 2762 | |
| 2763 | The C<CvPADLIST> field has been reused for a different internal purpose |
| 2764 | for XSUBs. So in particular, you can no longer rely on it being NULL as a |
| 2765 | test of whether a CV is an XSUB. Use C<CvISXSUB()> instead. |
| 2766 | |
| 2767 | =item * |
| 2768 | |
| 2769 | SVs of type C<SVt_NV> are now sometimes bodiless when the build |
| 2770 | configuration and platform allow it: specifically, when C<< sizeof(NV) <= |
| 2771 | sizeof(IV) >>. "Bodiless" means that the NV value is stored directly in |
| 2772 | the head of an SV, without requiring a separate body to be allocated. This |
| 2773 | trick has already been used for IVs since 5.9.2 (though in the case of |
| 2774 | IVs, it is always used, regardless of platform and build configuration). |
| 2775 | |
| 2776 | =item * |
| 2777 | |
| 2778 | The C<$DB::single>, C<$DB::signal> and C<$DB::trace> variables now have set- and |
| 2779 | get-magic that stores their values as IVs, and those IVs are used when |
| 2780 | testing their values in C<pp_dbstate()>. This prevents perl from |
| 2781 | recursing infinitely if an overloaded object is assigned to any of those |
| 2782 | variables. |
| 2783 | L<[perl #122445]|https://rt.perl.org/Ticket/Display.html?id=122445>. |
| 2784 | |
| 2785 | =item * |
| 2786 | |
| 2787 | C<Perl_tmps_grow()>, which is marked as public API but is undocumented, has |
| 2788 | been removed from the public API. This change does not affect XS code that |
| 2789 | uses the C<EXTEND_MORTAL> macro to pre-extend the mortal stack. |
| 2790 | |
| 2791 | =item * |
| 2792 | |
| 2793 | Perl's internals no longer sets or uses the C<SVs_PADMY> flag. |
| 2794 | C<SvPADMY()> now returns a true value for anything not marked C<PADTMP> |
| 2795 | and C<SVs_PADMY> is now defined as 0. |
| 2796 | |
| 2797 | =item * |
| 2798 | |
| 2799 | The macros C<SETsv> and C<SETsvUN> have been removed. They were no longer used |
| 2800 | in the core since commit 6f1401dc2a five years ago, and have not been |
| 2801 | found present on CPAN. |
| 2802 | |
| 2803 | =item * |
| 2804 | |
| 2805 | The C<< SvFAKE >> bit (unused on HVs) got informally reserved by |
| 2806 | David Mitchell for future work on vtables. |
| 2807 | |
| 2808 | =item * |
| 2809 | |
| 2810 | The C<sv_catpvn_flags()> function accepts C<SV_CATBYTES> and C<SV_CATUTF8> |
| 2811 | flags, which specify whether the appended string is bytes or UTF-8, |
| 2812 | respectively. (These flags have in fact been present since 5.16.0, but |
| 2813 | were formerly not regarded as part of the API.) |
| 2814 | |
| 2815 | =item * |
| 2816 | |
| 2817 | A new opcode class, C<< METHOP >>, has been introduced. It holds |
| 2818 | information used at runtime to improve the performance |
| 2819 | of class/object method calls. |
| 2820 | |
| 2821 | C<< OP_METHOD >> and C<< OP_METHOD_NAMED >> have changed from being |
| 2822 | C<< UNOP/SVOP >> to being C<< METHOP >>. |
| 2823 | |
| 2824 | =item * |
| 2825 | |
| 2826 | C<cv_name()> is a new API function that can be passed a CV or GV. It |
| 2827 | returns an SV containing the name of the subroutine, for use in |
| 2828 | diagnostics. |
| 2829 | |
| 2830 | L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735> |
| 2831 | L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> |
| 2832 | |
| 2833 | =item * |
| 2834 | |
| 2835 | C<cv_set_call_checker_flags()> is a new API function that works like |
| 2836 | C<cv_set_call_checker()>, except that it allows the caller to specify |
| 2837 | whether the call checker requires a full GV for reporting the subroutine's |
| 2838 | name, or whether it could be passed a CV instead. Whatever value is |
| 2839 | passed will be acceptable to C<cv_name()>. C<cv_set_call_checker()> |
| 2840 | guarantees there will be a GV, but it may have to create one on the fly, |
| 2841 | which is inefficient. |
| 2842 | L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735> |
| 2843 | |
| 2844 | =item * |
| 2845 | |
| 2846 | C<CvGV> (which is not part of the API) is now a more complex macro, which may |
| 2847 | call a function and reify a GV. For those cases where it has been used as a |
| 2848 | boolean, C<CvHASGV> has been added, which will return true for CVs that |
| 2849 | notionally have GVs, but without reifying the GV. C<CvGV> also returns a GV |
| 2850 | now for lexical subs. |
| 2851 | L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> |
| 2852 | |
| 2853 | =item * |
| 2854 | |
| 2855 | The L<perlapi/sync_locale> function has been added to the public API. |
| 2856 | Changing the program's locale should be avoided by XS code. Nevertheless, |
| 2857 | certain non-Perl libraries called from XS need to do so, such as C<Gtk>. |
| 2858 | When this happens, Perl needs to be told that the locale has |
| 2859 | changed. Use this function to do so, before returning to Perl. |
| 2860 | |
| 2861 | =item * |
| 2862 | |
| 2863 | The defines and labels for the flags in the C<op_private> field of OPs are now |
| 2864 | auto-generated from data in F<regen/op_private>. The noticeable effect of this |
| 2865 | is that some of the flag output of C<Concise> might differ slightly, and the |
| 2866 | flag output of S<C<perl -Dx>> may differ considerably (they both use the same set |
| 2867 | of labels now). Also, debugging builds now have a new assertion in |
| 2868 | C<op_free()> to ensure that the op doesn't have any unrecognized flags set in |
| 2869 | C<op_private>. |
| 2870 | |
| 2871 | =item * |
| 2872 | |
| 2873 | The deprecated variable C<PL_sv_objcount> has been removed. |
| 2874 | |
| 2875 | =item * |
| 2876 | |
| 2877 | Perl now tries to keep the locale category C<LC_NUMERIC> set to "C" |
| 2878 | except around operations that need it to be set to the program's |
| 2879 | underlying locale. This protects the many XS modules that cannot cope |
| 2880 | with the decimal radix character not being a dot. Prior to this |
| 2881 | release, Perl initialized this category to "C", but a call to |
| 2882 | C<POSIX::setlocale()> would change it. Now such a call will change the |
| 2883 | underlying locale of the C<LC_NUMERIC> category for the program, but the |
| 2884 | locale exposed to XS code will remain "C". There are new macros |
| 2885 | to manipulate the LC_NUMERIC locale, including |
| 2886 | C<STORE_LC_NUMERIC_SET_TO_NEEDED> and |
| 2887 | C<STORE_LC_NUMERIC_FORCE_TO_UNDERLYING>. |
| 2888 | See L<perlapi/Locale-related functions and macros>. |
| 2889 | |
| 2890 | =item * |
| 2891 | |
| 2892 | A new macro L<C<isUTF8_CHAR>|perlapi/isUTF8_CHAR> has been written which |
| 2893 | efficiently determines if the string given by its parameters begins |
| 2894 | with a well-formed UTF-8 encoded character. |
| 2895 | |
| 2896 | =item * |
| 2897 | |
| 2898 | The following private API functions had their context parameter removed: |
| 2899 | C<Perl_cast_ulong>, C<Perl_cast_i32>, C<Perl_cast_iv>, C<Perl_cast_uv>, |
| 2900 | C<Perl_cv_const_sv>, C<Perl_mg_find>, C<Perl_mg_findext>, C<Perl_mg_magical>, |
| 2901 | C<Perl_mini_mktime>, C<Perl_my_dirfd>, C<Perl_sv_backoff>, C<Perl_utf8_hop>. |
| 2902 | |
| 2903 | Note that the prefix-less versions of those functions that are part of the |
| 2904 | public API, such as C<cast_i32()>, remain unaffected. |
| 2905 | |
| 2906 | =item * |
| 2907 | |
| 2908 | The C<PADNAME> and C<PADNAMELIST> types are now separate types, and no |
| 2909 | longer simply aliases for SV and AV. |
| 2910 | L<[perl #123223]|https://rt.perl.org/Ticket/Display.html?id=123223>. |
| 2911 | |
| 2912 | =item * |
| 2913 | |
| 2914 | Pad names are now always UTF-8. The C<PadnameUTF8> macro always returns |
| 2915 | true. Previously, this was effectively the case already, but any support |
| 2916 | for two different internal representations of pad names has now been |
| 2917 | removed. |
| 2918 | |
| 2919 | =item * |
| 2920 | |
| 2921 | A new op class, C<UNOP_AUX>, has been added. This is a subclass of |
| 2922 | C<UNOP> with an C<op_aux> field added, which points to an array of unions |
| 2923 | of UV, SV* etc. It is intended for where an op needs to store more data |
| 2924 | than a simple C<op_sv> or whatever. Currently the only op of this type is |
| 2925 | C<OP_MULTIDEREF> (see next item). |
| 2926 | |
| 2927 | =item * |
| 2928 | |
| 2929 | A new op has been added, C<OP_MULTIDEREF>, which performs one or more |
| 2930 | nested array and hash lookups where the key is a constant or simple |
| 2931 | variable. For example the expression C<$a[0]{$k}[$i]>, which previously |
| 2932 | involved ten C<rv2Xv>, C<Xelem>, C<gvsv> and C<const> ops is now performed |
| 2933 | by a single C<multideref> op. It can also handle C<local>, C<exists> and |
| 2934 | C<delete>. A non-simple index expression, such as C<[$i+1]> is still done |
| 2935 | using C<aelem>/C<helem>, and single-level array lookup with a small constant |
| 2936 | index is still done using C<aelemfast>. |
| 2937 | |
| 2938 | =back |
| 2939 | |
| 2940 | =head1 Selected Bug Fixes |
| 2941 | |
| 2942 | =over 4 |
| 2943 | |
| 2944 | =item * |
| 2945 | |
| 2946 | C<close> now sets C<$!> |
| 2947 | |
| 2948 | When an I/O error occurs, the fact that there has been an error is recorded |
| 2949 | in the handle. C<close> returns false for such a handle. Previously, the |
| 2950 | value of C<$!> would be untouched by C<close>, so the common convention of |
| 2951 | writing S<C<close $fh or die $!>> did not work reliably. Now the handle |
| 2952 | records the value of C<$!>, too, and C<close> restores it. |
| 2953 | |
| 2954 | =item * |
| 2955 | |
| 2956 | C<no re> now can turn off everything that C<use re> enables |
| 2957 | |
| 2958 | Previously, running C<no re> would turn off only a few things. Now it |
| 2959 | can turn off all the enabled things. For example, the only way to |
| 2960 | stop debugging, once enabled, was to exit the enclosing block; that is |
| 2961 | now fixed. |
| 2962 | |
| 2963 | =item * |
| 2964 | |
| 2965 | C<pack("D", $x)> and C<pack("F", $x)> now zero the padding on x86 long |
| 2966 | double builds. Under some build options on GCC 4.8 and later, they used |
| 2967 | to either overwrite the zero-initialized padding, or bypass the |
| 2968 | initialized buffer entirely. This caused F<op/pack.t> to fail. |
| 2969 | L<[perl #123971]|https://rt.perl.org/Ticket/Display.html?id=123971> |
| 2970 | |
| 2971 | =item * |
| 2972 | |
| 2973 | Extending an array cloned from a parent thread could result in "Modification of |
| 2974 | a read-only value attempted" errors when attempting to modify the new elements. |
| 2975 | L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127> |
| 2976 | |
| 2977 | =item * |
| 2978 | |
| 2979 | An assertion failure and subsequent crash with C<< *x=<y> >> has been fixed. |
| 2980 | L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790> |
| 2981 | |
| 2982 | =item * |
| 2983 | |
| 2984 | A possible crashing/looping bug related to compiling lexical subs has been |
| 2985 | fixed. |
| 2986 | L<[perl #124099]|https://rt.perl.org/Ticket/Display.html?id=124099> |
| 2987 | |
| 2988 | =item * |
| 2989 | |
| 2990 | UTF-8 now works correctly in function names, in unquoted HERE-document |
| 2991 | terminators, and in variable names used as array indexes. |
| 2992 | L<[perl #124113]|https://rt.perl.org/Ticket/Display.html?id=124113> |
| 2993 | |
| 2994 | =item * |
| 2995 | |
| 2996 | Repeated global pattern matches in scalar context on large tainted strings were |
| 2997 | exponentially slow depending on the current match position in the string. |
| 2998 | L<[perl #123202]|https://rt.perl.org/Ticket/Display.html?id=123202> |
| 2999 | |
| 3000 | =item * |
| 3001 | |
| 3002 | Various crashes due to the parser getting confused by syntax errors have been |
| 3003 | fixed. |
| 3004 | L<[perl #123801]|https://rt.perl.org/Ticket/Display.html?id=123801> |
| 3005 | L<[perl #123802]|https://rt.perl.org/Ticket/Display.html?id=123802> |
| 3006 | L<[perl #123955]|https://rt.perl.org/Ticket/Display.html?id=123955> |
| 3007 | L<[perl #123995]|https://rt.perl.org/Ticket/Display.html?id=123995> |
| 3008 | |
| 3009 | =item * |
| 3010 | |
| 3011 | C<split> in the scope of lexical C<$_> has been fixed not to fail assertions. |
| 3012 | L<[perl #123763]|https://rt.perl.org/Ticket/Display.html?id=123763> |
| 3013 | |
| 3014 | =item * |
| 3015 | |
| 3016 | C<my $x : attr> syntax inside various list operators no longer fails |
| 3017 | assertions. |
| 3018 | L<[perl #123817]|https://rt.perl.org/Ticket/Display.html?id=123817> |
| 3019 | |
| 3020 | =item * |
| 3021 | |
| 3022 | An C<@> sign in quotes followed by a non-ASCII digit (which is not a valid |
| 3023 | identifier) would cause the parser to crash, instead of simply trying the |
| 3024 | C<@> as literal. This has been fixed. |
| 3025 | L<[perl #123963]|https://rt.perl.org/Ticket/Display.html?id=123963> |
| 3026 | |
| 3027 | =item * |
| 3028 | |
| 3029 | C<*bar::=*foo::=*glob_with_hash> has been crashing since Perl 5.14, but no |
| 3030 | longer does. |
| 3031 | L<[perl #123847]|https://rt.perl.org/Ticket/Display.html?id=123847> |
| 3032 | |
| 3033 | =item * |
| 3034 | |
| 3035 | C<foreach> in scalar context was not pushing an item on to the stack, resulting |
| 3036 | in bugs. (S<C<print 4, scalar do { foreach(@x){} } + 1>> would print 5.) |
| 3037 | It has been fixed to return C<undef>. |
| 3038 | L<[perl #124004]|https://rt.perl.org/Ticket/Display.html?id=124004> |
| 3039 | |
| 3040 | =item * |
| 3041 | |
| 3042 | Several cases of data used to store environment variable contents in core C |
| 3043 | code being potentially overwritten before being used have been fixed. |
| 3044 | L<[perl #123748]|https://rt.perl.org/Ticket/Display.html?id=123748> |
| 3045 | |
| 3046 | =item * |
| 3047 | |
| 3048 | Some patterns starting with C</.*..../> matched against long strings have |
| 3049 | been slow since v5.8, and some of the form C</.*..../i> have been slow |
| 3050 | since v5.18. They are now all fast again. |
| 3051 | L<[perl #123743]|https://rt.perl.org/Ticket/Display.html?id=123743>. |
| 3052 | |
| 3053 | =item * |
| 3054 | |
| 3055 | The original visible value of C<$/> is now preserved when it is set to |
| 3056 | an invalid value. Previously if you set C<$/> to a reference to an |
| 3057 | array, for example, perl would produce a runtime error and not set |
| 3058 | C<PL_rs>, but Perl code that checked C<$/> would see the array |
| 3059 | reference. |
| 3060 | L<[perl #123218]|https://rt.perl.org/Ticket/Display.html?id=123218>. |
| 3061 | |
| 3062 | =item * |
| 3063 | |
| 3064 | In a regular expression pattern, a POSIX class, like C<[:ascii:]>, must |
| 3065 | be inside a bracketed character class, like C<qr/[[:ascii:]]/>. A |
| 3066 | warning is issued when something looking like a POSIX class is not |
| 3067 | inside a bracketed class. That warning wasn't getting generated when |
| 3068 | the POSIX class was negated: C<[:^ascii:]>. This is now fixed. |
| 3069 | |
| 3070 | =item * |
| 3071 | |
| 3072 | Perl 5.14.0 introduced a bug whereby S<C<eval { LABEL: }>> would crash. This |
| 3073 | has been fixed. |
| 3074 | L<[perl #123652]|https://rt.perl.org/Ticket/Display.html?id=123652>. |
| 3075 | |
| 3076 | =item * |
| 3077 | |
| 3078 | Various crashes due to the parser getting confused by syntax errors have |
| 3079 | been fixed. |
| 3080 | L<[perl #123617]|https://rt.perl.org/Ticket/Display.html?id=123617>. |
| 3081 | L<[perl #123737]|https://rt.perl.org/Ticket/Display.html?id=123737>. |
| 3082 | L<[perl #123753]|https://rt.perl.org/Ticket/Display.html?id=123753>. |
| 3083 | L<[perl #123677]|https://rt.perl.org/Ticket/Display.html?id=123677>. |
| 3084 | |
| 3085 | =item * |
| 3086 | |
| 3087 | Code like C</$a[/> used to read the next line of input and treat it as |
| 3088 | though it came immediately after the opening bracket. Some invalid code |
| 3089 | consequently would parse and run, but some code caused crashes, so this is |
| 3090 | now disallowed. |
| 3091 | L<[perl #123712]|https://rt.perl.org/Ticket/Display.html?id=123712>. |
| 3092 | |
| 3093 | =item * |
| 3094 | |
| 3095 | Fix argument underflow for C<pack>. |
| 3096 | L<[perl #123874]|https://rt.perl.org/Ticket/Display.html?id=123874>. |
| 3097 | |
| 3098 | =item * |
| 3099 | |
| 3100 | Fix handling of non-strict C<\x{}>. Now C<\x{}> is equivalent to C<\x{0}> |
| 3101 | instead of faulting. |
| 3102 | |
| 3103 | =item * |
| 3104 | |
| 3105 | C<stat -t> is now no longer treated as stackable, just like C<-t stat>. |
| 3106 | L<[perl #123816]|https://rt.perl.org/Ticket/Display.html?id=123816>. |
| 3107 | |
| 3108 | =item * |
| 3109 | |
| 3110 | The following no longer causes a SEGV: C<qr{x+(y(?0))*}>. |
| 3111 | |
| 3112 | =item * |
| 3113 | |
| 3114 | Fixed infinite loop in parsing backrefs in regexp patterns. |
| 3115 | |
| 3116 | =item * |
| 3117 | |
| 3118 | Several minor bug fixes in behavior of Infinity and NaN, including |
| 3119 | warnings when stringifying Infinity-like or NaN-like strings. For example, |
| 3120 | "NaNcy" doesn't numify to NaN anymore. |
| 3121 | |
| 3122 | =item * |
| 3123 | |
| 3124 | A bug in regular expression patterns that could lead to segfaults and |
| 3125 | other crashes has been fixed. This occurred only in patterns compiled |
| 3126 | with C</i> while taking into account the current POSIX locale (which usually |
| 3127 | means they have to be compiled within the scope of C<S<use locale>>), |
| 3128 | and there must be a string of at least 128 consecutive bytes to match. |
| 3129 | L<[perl #123539]|https://rt.perl.org/Ticket/Display.html?id=123539>. |
| 3130 | |
| 3131 | =item * |
| 3132 | |
| 3133 | C<s///g> now works on very long strings (where there are more than 2 |
| 3134 | billion iterations) instead of dying with 'Substitution loop'. |
| 3135 | L<[perl #103260]|https://rt.perl.org/Ticket/Display.html?id=103260>. |
| 3136 | L<[perl #123071]|https://rt.perl.org/Ticket/Display.html?id=123071>. |
| 3137 | |
| 3138 | =item * |
| 3139 | |
| 3140 | C<gmtime> no longer crashes with not-a-number values. |
| 3141 | L<[perl #123495]|https://rt.perl.org/Ticket/Display.html?id=123495>. |
| 3142 | |
| 3143 | =item * |
| 3144 | |
| 3145 | C<\()> (a reference to an empty list), and C<y///> with lexical C<$_> in |
| 3146 | scope, could both do a bad write past the end of the stack. They have |
| 3147 | both been fixed to extend the stack first. |
| 3148 | |
| 3149 | =item * |
| 3150 | |
| 3151 | C<prototype()> with no arguments used to read the previous item on the |
| 3152 | stack, so S<C<print "foo", prototype()>> would print foo's prototype. |
| 3153 | It has been fixed to infer C<$_> instead. |
| 3154 | L<[perl #123514]|https://rt.perl.org/Ticket/Display.html?id=123514>. |
| 3155 | |
| 3156 | =item * |
| 3157 | |
| 3158 | Some cases of lexical state subs declared inside predeclared subs could |
| 3159 | crash, for example when evalling a string including the name of an outer |
| 3160 | variable, but no longer do. |
| 3161 | |
| 3162 | =item * |
| 3163 | |
| 3164 | Some cases of nested lexical state subs inside anonymous subs could cause |
| 3165 | 'Bizarre copy' errors or possibly even crashes. |
| 3166 | |
| 3167 | =item * |
| 3168 | |
| 3169 | When trying to emit warnings, perl's default debugger (F<perl5db.pl>) was |
| 3170 | sometimes giving 'Undefined subroutine &DB::db_warn called' instead. This |
| 3171 | bug, which started to occur in Perl 5.18, has been fixed. |
| 3172 | L<[perl #123553]|https://rt.perl.org/Ticket/Display.html?id=123553>. |
| 3173 | |
| 3174 | =item * |
| 3175 | |
| 3176 | Certain syntax errors in substitutions, such as C<< s/${<>{})// >>, would |
| 3177 | crash, and had done so since Perl 5.10. (In some cases the crash did not |
| 3178 | start happening till 5.16.) The crash has, of course, been fixed. |
| 3179 | L<[perl #123542]|https://rt.perl.org/Ticket/Display.html?id=123542>. |
| 3180 | |
| 3181 | =item * |
| 3182 | |
| 3183 | Fix a couple of string grow size calculation overflows; in particular, |
| 3184 | a repeat expression like S<C<33 x ~3>> could cause a large buffer |
| 3185 | overflow since the new output buffer size was not correctly handled by |
| 3186 | C<SvGROW()>. An expression like this now properly produces a memory wrap |
| 3187 | panic. |
| 3188 | L<[perl #123554]|https://rt.perl.org/Ticket/Display.html?id=123554>. |
| 3189 | |
| 3190 | =item * |
| 3191 | |
| 3192 | C<< formline("@...", "a"); >> would crash. The C<FF_CHECKNL> case in |
| 3193 | C<pp_formline()> didn't set the pointer used to mark the chop position, |
| 3194 | which led to the C<FF_MORE> case crashing with a segmentation fault. |
| 3195 | This has been fixed. |
| 3196 | L<[perl #123538]|https://rt.perl.org/Ticket/Display.html?id=123538>. |
| 3197 | |
| 3198 | =item * |
| 3199 | |
| 3200 | A possible buffer overrun and crash when parsing a literal pattern during |
| 3201 | regular expression compilation has been fixed. |
| 3202 | L<[perl #123604]|https://rt.perl.org/Ticket/Display.html?id=123604>. |
| 3203 | |
| 3204 | =item * |
| 3205 | |
| 3206 | C<fchmod()> and C<futimes()> now set C<$!> when they fail due to being |
| 3207 | passed a closed file handle. |
| 3208 | L<[perl #122703]|https://rt.perl.org/Ticket/Display.html?id=122703>. |
| 3209 | |
| 3210 | =item * |
| 3211 | |
| 3212 | C<op_free()> and C<scalarvoid()> no longer crash due to a stack overflow |
| 3213 | when freeing a deeply recursive op tree. |
| 3214 | L<[perl #108276]|https://rt.perl.org/Ticket/Display.html?id=108276>. |
| 3215 | |
| 3216 | =item * |
| 3217 | |
| 3218 | In Perl 5.20.0, C<$^N> accidentally had the internal UTF-8 flag turned off |
| 3219 | if accessed from a code block within a regular expression, effectively |
| 3220 | UTF-8-encoding the value. This has been fixed. |
| 3221 | L<[perl #123135]|https://rt.perl.org/Ticket/Display.html?id=123135>. |
| 3222 | |
| 3223 | =item * |
| 3224 | |
| 3225 | A failed C<semctl> call no longer overwrites existing items on the stack, |
| 3226 | which means that C<(semctl(-1,0,0,0))[0]> no longer gives an |
| 3227 | "uninitialized" warning. |
| 3228 | |
| 3229 | =item * |
| 3230 | |
| 3231 | C<else{foo()}> with no space before C<foo> is now better at assigning the |
| 3232 | right line number to that statement. |
| 3233 | L<[perl #122695]|https://rt.perl.org/Ticket/Display.html?id=122695>. |
| 3234 | |
| 3235 | =item * |
| 3236 | |
| 3237 | Sometimes the assignment in C<@array = split> gets optimised so that C<split> |
| 3238 | itself writes directly to the array. This caused a bug, preventing this |
| 3239 | assignment from being used in lvalue context. So |
| 3240 | C<(@a=split//,"foo")=bar()> was an error. (This bug probably goes back to |
| 3241 | Perl 3, when the optimisation was added.) It has now been fixed. |
| 3242 | L<[perl #123057]|https://rt.perl.org/Ticket/Display.html?id=123057>. |
| 3243 | |
| 3244 | =item * |
| 3245 | |
| 3246 | When an argument list fails the checks specified by a subroutine |
| 3247 | signature (which is still an experimental feature), the resulting error |
| 3248 | messages now give the file and line number of the caller, not of the |
| 3249 | called subroutine. |
| 3250 | L<[perl #121374]|https://rt.perl.org/Ticket/Display.html?id=121374>. |
| 3251 | |
| 3252 | =item * |
| 3253 | |
| 3254 | The flip-flop operators (C<..> and C<...> in scalar context) used to maintain |
| 3255 | a separate state for each recursion level (the number of times the |
| 3256 | enclosing sub was called recursively), contrary to the documentation. Now |
| 3257 | each closure has one internal state for each flip-flop. |
| 3258 | L<[perl #122829]|https://rt.perl.org/Ticket/Display.html?id=122829>. |
| 3259 | |
| 3260 | =item * |
| 3261 | |
| 3262 | The flip-flop operator (C<..> in scalar context) would return the same |
| 3263 | scalar each time, unless the containing subroutine was called recursively. |
| 3264 | Now it always returns a new scalar. |
| 3265 | L<[perl #122829]|https://rt.perl.org/Ticket/Display.html?id=122829>. |
| 3266 | |
| 3267 | =item * |
| 3268 | |
| 3269 | C<use>, C<no>, statement labels, special blocks (C<BEGIN>) and pod are now |
| 3270 | permitted as the first thing in a C<map> or C<grep> block, the block after |
| 3271 | C<print> or C<say> (or other functions) returning a handle, and within |
| 3272 | C<${...}>, C<@{...}>, etc. |
| 3273 | L<[perl #122782]|https://rt.perl.org/Ticket/Display.html?id=122782>. |
| 3274 | |
| 3275 | =item * |
| 3276 | |
| 3277 | The repetition operator C<x> now propagates lvalue context to its left-hand |
| 3278 | argument when used in contexts like C<foreach>. That allows |
| 3279 | S<C<for(($#that_array)x2) { ... }>> to work as expected if the loop modifies |
| 3280 | C<$_>. |
| 3281 | |
| 3282 | =item * |
| 3283 | |
| 3284 | C<(...) x ...> in scalar context used to corrupt the stack if one operand |
| 3285 | was an object with "x" overloading, causing erratic behavior. |
| 3286 | L<[perl #121827]|https://rt.perl.org/Ticket/Display.html?id=121827>. |
| 3287 | |
| 3288 | =item * |
| 3289 | |
| 3290 | Assignment to a lexical scalar is often optimised away; for example in |
| 3291 | C<my $x; $x = $y + $z>, the assign operator is optimised away and the add |
| 3292 | operator writes its result directly to C<$x>. Various bugs related to |
| 3293 | this optimisation have been fixed. Certain operators on the right-hand |
| 3294 | side would sometimes fail to assign the value at all or assign the wrong |
| 3295 | value, or would call STORE twice or not at all on tied variables. The |
| 3296 | operators affected were C<$foo++>, C<$foo-->, and C<-$foo> under C<use |
| 3297 | integer>, C<chomp>, C<chr> and C<setpgrp>. |
| 3298 | |
| 3299 | =item * |
| 3300 | |
| 3301 | List assignments were sometimes buggy if the same scalar ended up on both |
| 3302 | sides of the assignment due to use of C<tied>, C<values> or C<each>. The |
| 3303 | result would be the wrong value getting assigned. |
| 3304 | |
| 3305 | =item * |
| 3306 | |
| 3307 | C<setpgrp($nonzero)> (with one argument) was accidentally changed in 5.16 |
| 3308 | to mean C<setpgrp(0)>. This has been fixed. |
| 3309 | |
| 3310 | =item * |
| 3311 | |
| 3312 | C<__SUB__> could return the wrong value or even corrupt memory under the |
| 3313 | debugger (the C<-d> switch) and in subs containing C<eval $string>. |
| 3314 | |
| 3315 | =item * |
| 3316 | |
| 3317 | When S<C<sub () { $var }>> becomes inlinable, it now returns a different |
| 3318 | scalar each time, just as a non-inlinable sub would, though Perl still |
| 3319 | optimises the copy away in cases where it would make no observable |
| 3320 | difference. |
| 3321 | |
| 3322 | =item * |
| 3323 | |
| 3324 | S<C<my sub f () { $var }>> and S<C<sub () : attr { $var }>> are no longer |
| 3325 | eligible for inlining. The former would crash; the latter would just |
| 3326 | throw the attributes away. An exception is made for the little-known |
| 3327 | C<:method> attribute, which does nothing much. |
| 3328 | |
| 3329 | =item * |
| 3330 | |
| 3331 | Inlining of subs with an empty prototype is now more consistent than |
| 3332 | before. Previously, a sub with multiple statements, of which all but the last |
| 3333 | were optimised away, would be inlinable only if it were an anonymous sub |
| 3334 | containing a string C<eval> or C<state> declaration or closing over an |
| 3335 | outer lexical variable (or any anonymous sub under the debugger). Now any |
| 3336 | sub that gets folded to a single constant after statements have been |
| 3337 | optimised away is eligible for inlining. This applies to things like C<sub |
| 3338 | () { jabber() if DEBUG; 42 }>. |
| 3339 | |
| 3340 | Some subroutines with an explicit C<return> were being made inlinable, |
| 3341 | contrary to the documentation, Now C<return> always prevents inlining. |
| 3342 | |
| 3343 | =item * |
| 3344 | |
| 3345 | On some systems, such as VMS, C<crypt> can return a non-ASCII string. If a |
| 3346 | scalar assigned to had contained a UTF-8 string previously, then C<crypt> |
| 3347 | would not turn off the UTF-8 flag, thus corrupting the return value. This |
| 3348 | would happen with S<C<$lexical = crypt ...>>. |
| 3349 | |
| 3350 | =item * |
| 3351 | |
| 3352 | C<crypt> no longer calls C<FETCH> twice on a tied first argument. |
| 3353 | |
| 3354 | =item * |
| 3355 | |
| 3356 | An unterminated here-doc on the last line of a quote-like operator |
| 3357 | (C<qq[${ <<END }]>, C</(?{ <<END })/>) no longer causes a double free. It |
| 3358 | started doing so in 5.18. |
| 3359 | |
| 3360 | =item * |
| 3361 | |
| 3362 | C<index()> and C<rindex()> no longer crash when used on strings over 2GB in |
| 3363 | size. |
| 3364 | L<[perl #121562]|https://rt.perl.org/Ticket/Display.html?id=121562>. |
| 3365 | |
| 3366 | =item * |
| 3367 | |
| 3368 | A small, previously intentional, memory leak in |
| 3369 | C<PERL_SYS_INIT>/C<PERL_SYS_INIT3> on Win32 builds was fixed. This might |
| 3370 | affect embedders who repeatedly create and destroy perl engines within |
| 3371 | the same process. |
| 3372 | |
| 3373 | =item * |
| 3374 | |
| 3375 | C<POSIX::localeconv()> now returns the data for the program's underlying |
| 3376 | locale even when called from outside the scope of S<C<use locale>>. |
| 3377 | |
| 3378 | =item * |
| 3379 | |
| 3380 | C<POSIX::localeconv()> now works properly on platforms which don't have |
| 3381 | C<LC_NUMERIC> and/or C<LC_MONETARY>, or for which Perl has been compiled |
| 3382 | to disregard either or both of these locale categories. In such |
| 3383 | circumstances, there are now no entries for the corresponding values in |
| 3384 | the hash returned by C<localeconv()>. |
| 3385 | |
| 3386 | =item * |
| 3387 | |
| 3388 | C<POSIX::localeconv()> now marks appropriately the values it returns as |
| 3389 | UTF-8 or not. Previously they were always returned as bytes, even if |
| 3390 | they were supposed to be encoded as UTF-8. |
| 3391 | |
| 3392 | =item * |
| 3393 | |
| 3394 | On Microsoft Windows, within the scope of C<S<use locale>>, the following |
| 3395 | POSIX character classes gave results for many locales that did not |
| 3396 | conform to the POSIX standard: |
| 3397 | C<[[:alnum:]]>, |
| 3398 | C<[[:alpha:]]>, |
| 3399 | C<[[:blank:]]>, |
| 3400 | C<[[:digit:]]>, |
| 3401 | C<[[:graph:]]>, |
| 3402 | C<[[:lower:]]>, |
| 3403 | C<[[:print:]]>, |
| 3404 | C<[[:punct:]]>, |
| 3405 | C<[[:upper:]]>, |
| 3406 | C<[[:word:]]>, |
| 3407 | and |
| 3408 | C<[[:xdigit:]]>. |
| 3409 | This was because the underlying Microsoft implementation does not |
| 3410 | follow the standard. Perl now takes special precautions to correct for |
| 3411 | this. |
| 3412 | |
| 3413 | =item * |
| 3414 | |
| 3415 | Many issues have been detected by L<Coverity|http://www.coverity.com/> and |
| 3416 | fixed. |
| 3417 | |
| 3418 | =item * |
| 3419 | |
| 3420 | C<system()> and friends should now work properly on more Android builds. |
| 3421 | |
| 3422 | Due to an oversight, the value specified through C<-Dtargetsh> to F<Configure> |
| 3423 | would end up being ignored by some of the build process. This caused perls |
| 3424 | cross-compiled for Android to end up with defective versions of C<system()>, |
| 3425 | C<exec()> and backticks: the commands would end up looking for C</bin/sh> |
| 3426 | instead of C</system/bin/sh>, and so would fail for the vast majority |
| 3427 | of devices, leaving C<$!> as C<ENOENT>. |
| 3428 | |
| 3429 | =item * |
| 3430 | |
| 3431 | C<qr(...\(...\)...)>, |
| 3432 | C<qr[...\[...\]...]>, |
| 3433 | and |
| 3434 | C<qr{...\{...\}...}> |
| 3435 | now work. Previously it was impossible to escape these three |
| 3436 | left-characters with a backslash within a regular expression pattern |
| 3437 | where otherwise they would be considered metacharacters, and the pattern |
| 3438 | opening delimiter was the character, and the closing delimiter was its |
| 3439 | mirror character. |
| 3440 | |
| 3441 | =item * |
| 3442 | |
| 3443 | C<< s///e >> on tainted UTF-8 strings corrupted C<< pos() >>. This bug, |
| 3444 | introduced in 5.20, is now fixed. |
| 3445 | L<[perl #122148]|https://rt.perl.org/Ticket/Display.html?id=122148>. |
| 3446 | |
| 3447 | =item * |
| 3448 | |
| 3449 | A non-word boundary in a regular expression (C<< \B >>) did not always |
| 3450 | match the end of the string; in particular C<< q{} =~ /\B/ >> did not |
| 3451 | match. This bug, introduced in perl 5.14, is now fixed. |
| 3452 | L<[perl #122090]|https://rt.perl.org/Ticket/Display.html?id=122090>. |
| 3453 | |
| 3454 | =item * |
| 3455 | |
| 3456 | C<< " P" =~ /(?=.*P)P/ >> should match, but did not. This is now fixed. |
| 3457 | L<[perl #122171]|https://rt.perl.org/Ticket/Display.html?id=122171>. |
| 3458 | |
| 3459 | =item * |
| 3460 | |
| 3461 | Failing to compile C<use Foo> in an C<eval> could leave a spurious |
| 3462 | C<BEGIN> subroutine definition, which would produce a "Subroutine |
| 3463 | BEGIN redefined" warning on the next use of C<use>, or other C<BEGIN> |
| 3464 | block. |
| 3465 | L<[perl #122107]|https://rt.perl.org/Ticket/Display.html?id=122107>. |
| 3466 | |
| 3467 | =item * |
| 3468 | |
| 3469 | C<method { BLOCK } ARGS> syntax now correctly parses the arguments if they |
| 3470 | begin with an opening brace. |
| 3471 | L<[perl #46947]|https://rt.perl.org/Ticket/Display.html?id=46947>. |
| 3472 | |
| 3473 | =item * |
| 3474 | |
| 3475 | External libraries and Perl may have different ideas of what the locale is. |
| 3476 | This is problematic when parsing version strings if the locale's numeric |
| 3477 | separator has been changed. Version parsing has been patched to ensure |
| 3478 | it handles the locales correctly. |
| 3479 | L<[perl #121930]|https://rt.perl.org/Ticket/Display.html?id=121930>. |
| 3480 | |
| 3481 | =item * |
| 3482 | |
| 3483 | A bug has been fixed where zero-length assertions and code blocks inside of a |
| 3484 | regex could cause C<pos> to see an incorrect value. |
| 3485 | L<[perl #122460]|https://rt.perl.org/Ticket/Display.html?id=122460>. |
| 3486 | |
| 3487 | =item * |
| 3488 | |
| 3489 | Dereferencing of constants now works correctly for typeglob constants. Previously |
| 3490 | the glob was stringified and its name looked up. Now the glob itself is used. |
| 3491 | L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> |
| 3492 | |
| 3493 | =item * |
| 3494 | |
| 3495 | When parsing a sigil (C<$> C<@> C<%> C<&)> followed by braces, |
| 3496 | the parser no |
| 3497 | longer tries to guess whether it is a block or a hash constructor (causing a |
| 3498 | syntax error when it guesses the latter), since it can only be a block. |
| 3499 | |
| 3500 | =item * |
| 3501 | |
| 3502 | S<C<undef $reference>> now frees the referent immediately, instead of hanging on |
| 3503 | to it until the next statement. |
| 3504 | L<[perl #122556]|https://rt.perl.org/Ticket/Display.html?id=122556> |
| 3505 | |
| 3506 | =item * |
| 3507 | |
| 3508 | Various cases where the name of a sub is used (autoload, overloading, error |
| 3509 | messages) used to crash for lexical subs, but have been fixed. |
| 3510 | |
| 3511 | =item * |
| 3512 | |
| 3513 | Bareword lookup now tries to avoid vivifying packages if it turns out the |
| 3514 | bareword is not going to be a subroutine name. |
| 3515 | |
| 3516 | =item * |
| 3517 | |
| 3518 | Compilation of anonymous constants (I<e.g.>, C<sub () { 3 }>) no longer deletes |
| 3519 | any subroutine named C<__ANON__> in the current package. Not only was |
| 3520 | C<*__ANON__{CODE}> cleared, but there was a memory leak, too. This bug goes |
| 3521 | back to Perl 5.8.0. |
| 3522 | |
| 3523 | =item * |
| 3524 | |
| 3525 | Stub declarations like C<sub f;> and C<sub f ();> no longer wipe out constants |
| 3526 | of the same name declared by C<use constant>. This bug was introduced in Perl |
| 3527 | 5.10.0. |
| 3528 | |
| 3529 | =item * |
| 3530 | |
| 3531 | C<qr/[\N{named sequence}]/> now works properly in many instances. |
| 3532 | |
| 3533 | Some names |
| 3534 | known to C<\N{...}> refer to a sequence of multiple characters, instead of the |
| 3535 | usual single character. Bracketed character classes generally only match |
| 3536 | single characters, but now special handling has been added so that they can |
| 3537 | match named sequences, but not if the class is inverted or the sequence is |
| 3538 | specified as the beginning or end of a range. In these cases, the only |
| 3539 | behavior change from before is a slight rewording of the fatal error message |
| 3540 | given when this class is part of a C<?[...])> construct. When the C<[...]> |
| 3541 | stands alone, the same non-fatal warning as before is raised, and only the |
| 3542 | first character in the sequence is used, again just as before. |
| 3543 | |
| 3544 | =item * |
| 3545 | |
| 3546 | Tainted constants evaluated at compile time no longer cause unrelated |
| 3547 | statements to become tainted. |
| 3548 | L<[perl #122669]|https://rt.perl.org/Ticket/Display.html?id=122669> |
| 3549 | |
| 3550 | =item * |
| 3551 | |
| 3552 | S<C<open $$fh, ...>>, which vivifies a handle with a name like |
| 3553 | C<"main::_GEN_0">, was not giving the handle the right reference count, so |
| 3554 | a double free could happen. |
| 3555 | |
| 3556 | =item * |
| 3557 | |
| 3558 | When deciding that a bareword was a method name, the parser would get confused |
| 3559 | if an C<our> sub with the same name existed, and look up the method in the |
| 3560 | package of the C<our> sub, instead of the package of the invocant. |
| 3561 | |
| 3562 | =item * |
| 3563 | |
| 3564 | The parser no longer gets confused by C<\U=> within a double-quoted string. It |
| 3565 | used to produce a syntax error, but now compiles it correctly. |
| 3566 | L<[perl #80368]|https://rt.perl.org/Ticket/Display.html?id=80368> |
| 3567 | |
| 3568 | =item * |
| 3569 | |
| 3570 | It has always been the intention for the C<-B> and C<-T> file test operators to |
| 3571 | treat UTF-8 encoded files as text. (L<perlfunc|perlfunc/-X FILEHANDLE> has |
| 3572 | been updated to say this.) Previously, it was possible for some files to be |
| 3573 | considered UTF-8 that actually weren't valid UTF-8. This is now fixed. The |
| 3574 | operators now work on EBCDIC platforms as well. |
| 3575 | |
| 3576 | =item * |
| 3577 | |
| 3578 | Under some conditions warning messages raised during regular expression pattern |
| 3579 | compilation were being output more than once. This has now been fixed. |
| 3580 | |
| 3581 | =item * |
| 3582 | |
| 3583 | Perl 5.20.0 introduced a regression in which a UTF-8 encoded regular |
| 3584 | expression pattern that contains a single ASCII lowercase letter did not |
| 3585 | match its uppercase counterpart. That has been fixed in both 5.20.1 and |
| 3586 | 5.22.0. |
| 3587 | L<[perl #122655]|https://rt.perl.org/Ticket/Display.html?id=122655> |
| 3588 | |
| 3589 | =item * |
| 3590 | |
| 3591 | Constant folding could incorrectly suppress warnings if lexical warnings |
| 3592 | (C<use warnings> or C<no warnings>) were not in effect and C<$^W> were |
| 3593 | false at compile time and true at run time. |
| 3594 | |
| 3595 | =item * |
| 3596 | |
| 3597 | Loading Unicode tables during a regular expression match could cause assertion |
| 3598 | failures under debugging builds if the previous match used the very same |
| 3599 | regular expression. |
| 3600 | L<[perl #122747]|https://rt.perl.org/Ticket/Display.html?id=122747> |
| 3601 | |
| 3602 | =item * |
| 3603 | |
| 3604 | Thread cloning used to work incorrectly for lexical subs, possibly causing |
| 3605 | crashes or double frees on exit. |
| 3606 | |
| 3607 | =item * |
| 3608 | |
| 3609 | Since Perl 5.14.0, deleting C<$SomePackage::{__ANON__}> and then undefining an |
| 3610 | anonymous subroutine could corrupt things internally, resulting in |
| 3611 | L<Devel::Peek> crashing or L<B.pm|B> giving nonsensical data. This has been |
| 3612 | fixed. |
| 3613 | |
| 3614 | =item * |
| 3615 | |
| 3616 | S<C<(caller $n)[3]>> now reports names of lexical subs, instead of |
| 3617 | treating them as C<"(unknown)">. |
| 3618 | |
| 3619 | =item * |
| 3620 | |
| 3621 | C<sort subname LIST> now supports using a lexical sub as the comparison |
| 3622 | routine. |
| 3623 | |
| 3624 | =item * |
| 3625 | |
| 3626 | Aliasing (I<e.g.>, via S<C<*x = *y>>) could confuse list assignments that mention the |
| 3627 | two names for the same variable on either side, causing wrong values to be |
| 3628 | assigned. |
| 3629 | L<[perl #15667]|https://rt.perl.org/Ticket/Display.html?id=15667> |
| 3630 | |
| 3631 | =item * |
| 3632 | |
| 3633 | Long here-doc terminators could cause a bad read on short lines of input. This |
| 3634 | has been fixed. It is doubtful that any crash could have occurred. This bug |
| 3635 | goes back to when here-docs were introduced in Perl 3.000 twenty-five years |
| 3636 | ago. |
| 3637 | |
| 3638 | =item * |
| 3639 | |
| 3640 | An optimization in C<split> to treat S<C<split /^/>> like S<C<split /^/m>> had the |
| 3641 | unfortunate side-effect of also treating S<C<split /\A/>> like S<C<split /^/m>>, |
| 3642 | which it should not. This has been fixed. (Note, however, that S<C<split /^x/>> |
| 3643 | does not behave like S<C<split /^x/m>>, which is also considered to be a bug and |
| 3644 | will be fixed in a future version.) |
| 3645 | L<[perl #122761]|https://rt.perl.org/Ticket/Display.html?id=122761> |
| 3646 | |
| 3647 | =item * |
| 3648 | |
| 3649 | The little-known S<C<my Class $var>> syntax (see L<fields> and L<attributes>) |
| 3650 | could get confused in the scope of C<use utf8> if C<Class> were a constant |
| 3651 | whose value contained Latin-1 characters. |
| 3652 | |
| 3653 | =item * |
| 3654 | |
| 3655 | Locking and unlocking values via L<Hash::Util> or C<Internals::SvREADONLY> |
| 3656 | no longer has any effect on values that were read-only to begin with. |
| 3657 | Previously, unlocking such values could result in crashes, hangs or |
| 3658 | other erratic behavior. |
| 3659 | |
| 3660 | =item * |
| 3661 | |
| 3662 | Some unterminated C<(?(...)...)> constructs in regular expressions would |
| 3663 | either crash or give erroneous error messages. C</(?(1)/> is one such |
| 3664 | example. |
| 3665 | |
| 3666 | =item * |
| 3667 | |
| 3668 | S<C<pack "w", $tied>> no longer calls FETCH twice. |
| 3669 | |
| 3670 | =item * |
| 3671 | |
| 3672 | List assignments like S<C<($x, $z) = (1, $y)>> now work correctly if C<$x> and |
| 3673 | C<$y> have been aliased by C<foreach>. |
| 3674 | |
| 3675 | =item * |
| 3676 | |
| 3677 | Some patterns including code blocks with syntax errors, such as |
| 3678 | S<C</ (?{(^{})/>>, would hang or fail assertions on debugging builds. Now |
| 3679 | they produce errors. |
| 3680 | |
| 3681 | =item * |
| 3682 | |
| 3683 | An assertion failure when parsing C<sort> with debugging enabled has been |
| 3684 | fixed. |
| 3685 | L<[perl #122771]|https://rt.perl.org/Ticket/Display.html?id=122771>. |
| 3686 | |
| 3687 | =item * |
| 3688 | |
| 3689 | S<C<*a = *b; @a = split //, $b[1]>> could do a bad read and produce junk |
| 3690 | results. |
| 3691 | |
| 3692 | =item * |
| 3693 | |
| 3694 | In S<C<() = @array = split>>, the S<C<() =>> at the beginning no longer confuses |
| 3695 | the optimizer into assuming a limit of 1. |
| 3696 | |
| 3697 | =item * |
| 3698 | |
| 3699 | Fatal warnings no longer prevent the output of syntax errors. |
| 3700 | L<[perl #122966]|https://rt.perl.org/Ticket/Display.html?id=122966>. |
| 3701 | |
| 3702 | =item * |
| 3703 | |
| 3704 | Fixed a NaN double-to-long-double conversion error on VMS. For quiet NaNs |
| 3705 | (and only on Itanium, not Alpha) negative infinity instead of NaN was |
| 3706 | produced. |
| 3707 | |
| 3708 | =item * |
| 3709 | |
| 3710 | Fixed the issue that caused C<< make distclean >> to incorrectly leave some |
| 3711 | files behind. |
| 3712 | L<[perl #122820]|https://rt.perl.org/Ticket/Display.html?id=122820>. |
| 3713 | |
| 3714 | =item * |
| 3715 | |
| 3716 | AIX now sets the length in C<< getsockopt >> correctly. |
| 3717 | L<[perl #120835]|https://rt.perl.org/Ticket/Display.html?id=120835>. |
| 3718 | L<[cpan #91183]|https://rt.cpan.org/Ticket/Display.html?id=91183>. |
| 3719 | L<[cpan #85570]|https://rt.cpan.org/Ticket/Display.html?id=85570>. |
| 3720 | |
| 3721 | =item * |
| 3722 | |
| 3723 | The optimization phase of a regexp compilation could run "forever" and |
| 3724 | exhaust all memory under certain circumstances; now fixed. |
| 3725 | L<[perl #122283]|https://rt.perl.org/Ticket/Display.html?id=122283>. |
| 3726 | |
| 3727 | =item * |
| 3728 | |
| 3729 | The test script F<< t/op/crypt.t >> now uses the SHA-256 algorithm if the |
| 3730 | default one is disabled, rather than giving failures. |
| 3731 | L<[perl #121591]|https://rt.perl.org/Ticket/Display.html?id=121591>. |
| 3732 | |
| 3733 | =item * |
| 3734 | |
| 3735 | Fixed an off-by-one error when setting the size of a shared array. |
| 3736 | L<[perl #122950]|https://rt.perl.org/Ticket/Display.html?id=122950>. |
| 3737 | |
| 3738 | =item * |
| 3739 | |
| 3740 | Fixed a bug that could cause perl to enter an infinite loop during |
| 3741 | compilation. In particular, a C<while(1)> within a sublist, I<e.g.> |
| 3742 | |
| 3743 | sub foo { () = ($a, my $b, ($c, do { while(1) {} })) } |
| 3744 | |
| 3745 | The bug was introduced in 5.20.0 |
| 3746 | L<[perl #122995]|https://rt.perl.org/Ticket/Display.html?id=122995>. |
| 3747 | |
| 3748 | =item * |
| 3749 | |
| 3750 | On Win32, if a variable was C<local>-ized in a pseudo-process that later |
| 3751 | forked, restoring the original value in the child pseudo-process caused |
| 3752 | memory corruption and a crash in the child pseudo-process (and therefore the |
| 3753 | OS process). |
| 3754 | L<[perl #40565]|https://rt.perl.org/Ticket/Display.html?id=40565>. |
| 3755 | |
| 3756 | =item * |
| 3757 | |
| 3758 | Calling C<write> on a format with a C<^**> field could produce a panic |
| 3759 | in C<sv_chop()> if there were insufficient arguments or if the variable |
| 3760 | used to fill the field was empty. |
| 3761 | L<[perl #123245]|https://rt.perl.org/Ticket/Display.html?id=123245>. |
| 3762 | |
| 3763 | =item * |
| 3764 | |
| 3765 | Non-ASCII lexical sub names now appear without trailing junk when they |
| 3766 | appear in error messages. |
| 3767 | |
| 3768 | =item * |
| 3769 | |
| 3770 | The C<\@> subroutine prototype no longer flattens parenthesized arrays |
| 3771 | (taking a reference to each element), but takes a reference to the array |
| 3772 | itself. |
| 3773 | L<[perl #47363]|https://rt.perl.org/Ticket/Display.html?id=47363>. |
| 3774 | |
| 3775 | =item * |
| 3776 | |
| 3777 | A block containing nothing except a C-style C<for> loop could corrupt the |
| 3778 | stack, causing lists outside the block to lose elements or have elements |
| 3779 | overwritten. This could happen with C<map { for(...){...} } ...> and with |
| 3780 | lists containing C<do { for(...){...} }>. |
| 3781 | L<[perl #123286]|https://rt.perl.org/Ticket/Display.html?id=123286>. |
| 3782 | |
| 3783 | =item * |
| 3784 | |
| 3785 | C<scalar()> now propagates lvalue context, so that |
| 3786 | S<C<for(scalar($#foo)) { ... }>> can modify C<$#foo> through C<$_>. |
| 3787 | |
| 3788 | =item * |
| 3789 | |
| 3790 | C<qr/@array(?{block})/> no longer dies with "Bizarre copy of ARRAY". |
| 3791 | L<[perl #123344]|https://rt.perl.org/Ticket/Display.html?id=123344>. |
| 3792 | |
| 3793 | =item * |
| 3794 | |
| 3795 | S<C<eval '$variable'>> in nested named subroutines would sometimes look up a |
| 3796 | global variable even with a lexical variable in scope. |
| 3797 | |
| 3798 | =item * |
| 3799 | |
| 3800 | In perl 5.20.0, C<sort CORE::fake> where 'fake' is anything other than a |
| 3801 | keyword, started chopping off the last 6 characters and treating the result |
| 3802 | as a sort sub name. The previous behavior of treating C<CORE::fake> as a |
| 3803 | sort sub name has been restored. |
| 3804 | L<[perl #123410]|https://rt.perl.org/Ticket/Display.html?id=123410>. |
| 3805 | |
| 3806 | =item * |
| 3807 | |
| 3808 | Outside of C<use utf8>, a single-character Latin-1 lexical variable is |
| 3809 | disallowed. The error message for it, "Can't use global C<$foo>...", was |
| 3810 | giving garbage instead of the variable name. |
| 3811 | |
| 3812 | =item * |
| 3813 | |
| 3814 | C<readline> on a nonexistent handle was causing C<${^LAST_FH}> to produce a |
| 3815 | reference to an undefined scalar (or fail an assertion). Now |
| 3816 | C<${^LAST_FH}> ends up undefined. |
| 3817 | |
| 3818 | =item * |
| 3819 | |
| 3820 | C<(...) x ...> in void context now applies scalar context to the left-hand |
| 3821 | argument, instead of the context the current sub was called in. |
| 3822 | L<[perl #123020]|https://rt.perl.org/Ticket/Display.html?id=123020>. |
| 3823 | |
| 3824 | =back |
| 3825 | |
| 3826 | =head1 Known Problems |
| 3827 | |
| 3828 | =over 4 |
| 3829 | |
| 3830 | =item * |
| 3831 | |
| 3832 | C<pack>-ing a NaN on a perl compiled with Visual C 6 does not behave properly, |
| 3833 | leading to a test failure in F<t/op/infnan.t>. |
| 3834 | L<[perl 125203]|https://rt.perl.org/Ticket/Display.html?id=125203> |
| 3835 | |
| 3836 | =item * |
| 3837 | |
| 3838 | A goal is for Perl to be able to be recompiled to work reasonably well on any |
| 3839 | Unicode version. In Perl 5.22, though, the earliest such version is Unicode |
| 3840 | 5.1 (current is 7.0). |
| 3841 | |
| 3842 | =item * |
| 3843 | |
| 3844 | EBCDIC platforms |
| 3845 | |
| 3846 | =over 4 |
| 3847 | |
| 3848 | =item * |
| 3849 | |
| 3850 | The C<cmp> (and hence C<sort>) operators do not necessarily give the |
| 3851 | correct results when both operands are UTF-EBCDIC encoded strings and |
| 3852 | there is a mixture of ASCII and/or control characters, along with other |
| 3853 | characters. |
| 3854 | |
| 3855 | =item * |
| 3856 | |
| 3857 | Ranges containing C<\N{...}> in the C<tr///> (and C<y///>) |
| 3858 | transliteration operators are treated differently than the equivalent |
| 3859 | ranges in regular expression patterns. They should, but don't, cause |
| 3860 | the values in the ranges to all be treated as Unicode code points, and |
| 3861 | not native ones. (L<perlre/Version 8 Regular Expressions> gives |
| 3862 | details as to how it should work.) |
| 3863 | |
| 3864 | =item * |
| 3865 | |
| 3866 | Encode and encoding are mostly broken. |
| 3867 | |
| 3868 | =item * |
| 3869 | |
| 3870 | Many CPAN modules that are shipped with core show failing tests. |
| 3871 | |
| 3872 | =item * |
| 3873 | |
| 3874 | C<pack>/C<unpack> with C<"U0"> format may not work properly. |
| 3875 | |
| 3876 | =back |
| 3877 | |
| 3878 | =item * |
| 3879 | |
| 3880 | The following modules are known to have test failures with this version of |
| 3881 | Perl. In many cases, patches have been submitted, so there will hopefully be |
| 3882 | new releases soon: |
| 3883 | |
| 3884 | =over |
| 3885 | |
| 3886 | =item * |
| 3887 | |
| 3888 | L<B::Generate> version 1.50 |
| 3889 | |
| 3890 | =item * |
| 3891 | |
| 3892 | L<B::Utils> version 0.25 |
| 3893 | |
| 3894 | =item * |
| 3895 | |
| 3896 | L<Coro> version 6.42 |
| 3897 | |
| 3898 | =item * |
| 3899 | |
| 3900 | L<Dancer> version 1.3130 |
| 3901 | |
| 3902 | =item * |
| 3903 | |
| 3904 | L<Data::Alias> version 1.18 |
| 3905 | |
| 3906 | =item * |
| 3907 | |
| 3908 | L<Data::Dump::Streamer> version 2.38 |
| 3909 | |
| 3910 | =item * |
| 3911 | |
| 3912 | L<Data::Util> version 0.63 |
| 3913 | |
| 3914 | =item * |
| 3915 | |
| 3916 | L<Devel::Spy> version 0.07 |
| 3917 | |
| 3918 | =item * |
| 3919 | |
| 3920 | L<invoker> version 0.34 |
| 3921 | |
| 3922 | =item * |
| 3923 | |
| 3924 | L<Lexical::Var> version 0.009 |
| 3925 | |
| 3926 | =item * |
| 3927 | |
| 3928 | L<LWP::ConsoleLogger> version 0.000018 |
| 3929 | |
| 3930 | =item * |
| 3931 | |
| 3932 | L<Mason> version 2.22 |
| 3933 | |
| 3934 | =item * |
| 3935 | |
| 3936 | L<NgxQueue> version 0.02 |
| 3937 | |
| 3938 | =item * |
| 3939 | |
| 3940 | L<Padre> version 1.00 |
| 3941 | |
| 3942 | =item * |
| 3943 | |
| 3944 | L<Parse::Keyword> 0.08 |
| 3945 | |
| 3946 | =back |
| 3947 | |
| 3948 | =back |
| 3949 | |
| 3950 | =head1 Obituary |
| 3951 | |
| 3952 | Brian McCauley died on May 8, 2015. He was a frequent poster to Usenet, Perl |
| 3953 | Monks, and other Perl forums, and made several CPAN contributions under the |
| 3954 | nick NOBULL, including to the Perl FAQ. He attended almost every |
| 3955 | YAPC::Europe, and indeed, helped organise YAPC::Europe 2006 and the QA |
| 3956 | Hackathon 2009. His wit and his delight in intricate systems were |
| 3957 | particularly apparent in his love of board games; many Perl mongers will |
| 3958 | have fond memories of playing Fluxx and other games with Brian. He will be |
| 3959 | missed. |
| 3960 | |
| 3961 | =head1 Acknowledgements |
| 3962 | |
| 3963 | Perl 5.22.0 represents approximately 12 months of development since Perl 5.20.0 |
| 3964 | and contains approximately 590,000 lines of changes across 2,400 files from 94 |
| 3965 | authors. |
| 3966 | |
| 3967 | Excluding auto-generated files, documentation and release tools, there were |
| 3968 | approximately 370,000 lines of changes to 1,500 .pm, .t, .c and .h files. |
| 3969 | |
| 3970 | Perl continues to flourish into its third decade thanks to a vibrant community |
| 3971 | of users and developers. The following people are known to have contributed the |
| 3972 | improvements that became Perl 5.22.0: |
| 3973 | |
| 3974 | Aaron Crane, Abhijit Menon-Sen, Abigail, Alberto Simões, Alex Solovey, Alex |
| 3975 | Vandiver, Alexandr Ciornii, Alexandre (Midnite) Jousset, Andreas König, |
| 3976 | Andreas Voegele, Andrew Fresh, Andy Dougherty, Anthony Heading, Aristotle |
| 3977 | Pagaltzis, brian d foy, Brian Fraser, Chad Granum, Chris 'BinGOs' Williams, |
| 3978 | Craig A. Berry, Dagfinn Ilmari Mannsåker, Daniel Dragan, Darin McBride, Dave |
| 3979 | Rolsky, David Golden, David Mitchell, David Wheeler, Dmitri Tikhonov, Doug |
| 3980 | Bell, E. Choroba, Ed J, Eric Herman, Father Chrysostomos, George Greer, Glenn |
| 3981 | D. Golden, Graham Knop, H.Merijn Brand, Herbert Breunung, Hugo van der Sanden, |
| 3982 | James E Keenan, James McCoy, James Raspass, Jan Dubois, Jarkko Hietaniemi, |
| 3983 | Jasmine Ngan, Jerry D. Hedden, Jim Cromie, John Goodyear, kafka, Karen |
| 3984 | Etheridge, Karl Williamson, Kent Fredric, kmx, Lajos Veres, Leon Timmermans, |
| 3985 | Lukas Mai, Mathieu Arnold, Matthew Horsfall, Max Maischein, Michael Bunk, |
| 3986 | Nicholas Clark, Niels Thykier, Niko Tyni, Norman Koch, Olivier Mengué, Peter |
| 3987 | John Acklam, Peter Martini, Petr Písař, Philippe Bruhat (BooK), Pierre |
| 3988 | Bogossian, Rafael Garcia-Suarez, Randy Stauner, Reini Urban, Ricardo Signes, |
| 3989 | Rob Hoelz, Rostislav Skudnov, Sawyer X, Shirakata Kentaro, Shlomi Fish, |
| 3990 | Sisyphus, Slaven Rezic, Smylers, Steffen Müller, Steve Hay, Sullivan Beck, |
| 3991 | syber, Tadeusz Sośnierz, Thomas Sibley, Todd Rinaldo, Tony Cook, Vincent Pit, |
| 3992 | Vladimir Marek, Yaroslav Kuzmin, Yves Orton, Ævar Arnfjörð Bjarmason. |
| 3993 | |
| 3994 | The list above is almost certainly incomplete as it is automatically generated |
| 3995 | from version control history. In particular, it does not include the names of |
| 3996 | the (very much appreciated) contributors who reported issues to the Perl bug |
| 3997 | tracker. |
| 3998 | |
| 3999 | Many of the changes included in this version originated in the CPAN modules |
| 4000 | included in Perl's core. We're grateful to the entire CPAN community for |
| 4001 | helping Perl to flourish. |
| 4002 | |
| 4003 | For a more complete list of all of Perl's historical contributors, please see |
| 4004 | the F<AUTHORS> file in the Perl source distribution. |
| 4005 | |
| 4006 | =head1 Reporting Bugs |
| 4007 | |
| 4008 | If you find what you think is a bug, you might check the articles recently |
| 4009 | posted to the comp.lang.perl.misc newsgroup and the perl bug database at |
| 4010 | L<https://rt.perl.org/>. There may also be information at |
| 4011 | L<http://www.perl.org/>, the Perl Home Page. |
| 4012 | |
| 4013 | If you believe you have an unreported bug, please run the L<perlbug> program |
| 4014 | included with your release. Be sure to trim your bug down to a tiny but |
| 4015 | sufficient test case. Your bug report, along with the output of C<perl -V>, |
| 4016 | will be sent off to perlbug@perl.org to be analysed by the Perl porting team. |
| 4017 | |
| 4018 | If the bug you are reporting has security implications, which make it |
| 4019 | inappropriate to send to a publicly archived mailing list, then please send it |
| 4020 | to perl5-security-report@perl.org. This points to a closed subscription |
| 4021 | unarchived mailing list, which includes all the core committers, who will be |
| 4022 | able to help assess the impact of issues, figure out a resolution, and help |
| 4023 | co-ordinate the release of patches to mitigate or fix the problem across all |
| 4024 | platforms on which Perl is supported. Please only use this address for |
| 4025 | security issues in the Perl core, not for modules independently distributed on |
| 4026 | CPAN. |
| 4027 | |
| 4028 | =head1 SEE ALSO |
| 4029 | |
| 4030 | The F<Changes> file for an explanation of how to view exhaustive details on |
| 4031 | what changed. |
| 4032 | |
| 4033 | The F<INSTALL> file for how to build Perl. |
| 4034 | |
| 4035 | The F<README> file for general stuff. |
| 4036 | |
| 4037 | The F<Artistic> and F<Copying> files for copyright information. |
| 4038 | |
| 4039 | =cut |