1=encoding utf8 2 3=head1 NAME 4 5perl5180delta - what is new for perl v5.18.0 6 7=head1 DESCRIPTION 8 9This document describes differences between the v5.16.0 release and the v5.18.0 10release. 11 12If you are upgrading from an earlier release such as v5.14.0, first read 13L<perl5160delta>, which describes differences between v5.14.0 and v5.16.0. 14 15=head1 Core Enhancements 16 17=head2 New mechanism for experimental features 18 19Newly-added experimental features will now require this incantation: 20 21 no warnings "experimental::feature_name"; 22 use feature "feature_name"; # would warn without the prev line 23 24There is a new warnings category, called "experimental", containing 25warnings that the L<feature> pragma emits when enabling experimental 26features. 27 28Newly-added experimental features will also be given special warning IDs, 29which consist of "experimental::" followed by the name of the feature. (The 30plan is to extend this mechanism eventually to all warnings, to allow them 31to be enabled or disabled individually, and not just by category.) 32 33By saying 34 35 no warnings "experimental::feature_name"; 36 37you are taking responsibility for any breakage that future changes to, or 38removal of, the feature may cause. 39 40Since some features (like C<~~> or C<my $_>) now emit experimental warnings, 41and you may want to disable them in code that is also run on perls that do not 42recognize these warning categories, consider using the C<if> pragma like this: 43 44 no if $] >= 5.018, warnings => "experimental::feature_name"; 45 46Existing experimental features may begin emitting these warnings, too. Please 47consult L<perlexperiment> for information on which features are considered 48experimental. 49 50=head2 Hash overhaul 51 52Changes to the implementation of hashes in perl v5.18.0 will be one of the most 53visible changes to the behavior of existing code. 54 55By default, two distinct hash variables with identical keys and values may now 56provide their contents in a different order where it was previously identical. 57 58When encountering these changes, the key to cleaning up from them is to accept 59that B<hashes are unordered collections> and to act accordingly. 60 61=head3 Hash randomization 62 63The seed used by Perl's hash function is now random. This means that the 64order which keys/values will be returned from functions like C<keys()>, 65C<values()>, and C<each()> will differ from run to run. 66 67This change was introduced to make Perl's hashes more robust to algorithmic 68complexity attacks, and also because we discovered that it exposes hash 69ordering dependency bugs and makes them easier to track down. 70 71Toolchain maintainers might want to invest in additional infrastructure to 72test for things like this. Running tests several times in a row and then 73comparing results will make it easier to spot hash order dependencies in 74code. Authors are strongly encouraged not to expose the key order of 75Perl's hashes to insecure audiences. 76 77Further, every hash has its own iteration order, which should make it much 78more difficult to determine what the current hash seed is. 79 80=head3 New hash functions 81 82Perl v5.18 includes support for multiple hash functions, and changed 83the default (to ONE_AT_A_TIME_HARD), you can choose a different 84algorithm by defining a symbol at compile time. For a current list, 85consult the F<INSTALL> document. Note that as of Perl v5.18 we can 86only recommend use of the default or SIPHASH. All the others are 87known to have security issues and are for research purposes only. 88 89=head3 PERL_HASH_SEED environment variable now takes a hex value 90 91C<PERL_HASH_SEED> no longer accepts an integer as a parameter; 92instead the value is expected to be a binary value encoded in a hex 93string, such as "0xf5867c55039dc724". This is to make the 94infrastructure support hash seeds of arbitrary lengths, which might 95exceed that of an integer. (SipHash uses a 16 byte seed.) 96 97=head3 PERL_PERTURB_KEYS environment variable added 98 99The C<PERL_PERTURB_KEYS> environment variable allows one to control the level of 100randomization applied to C<keys> and friends. 101 102When C<PERL_PERTURB_KEYS> is 0, perl will not randomize the key order at all. The 103chance that C<keys> changes due to an insert will be the same as in previous 104perls, basically only when the bucket size is changed. 105 106When C<PERL_PERTURB_KEYS> is 1, perl will randomize keys in a non-repeatable 107way. The chance that C<keys> changes due to an insert will be very high. This 108is the most secure and default mode. 109 110When C<PERL_PERTURB_KEYS> is 2, perl will randomize keys in a repeatable way. 111Repeated runs of the same program should produce the same output every time. 112 113C<PERL_HASH_SEED> implies a non-default C<PERL_PERTURB_KEYS> setting. Setting 114C<PERL_HASH_SEED=0> (exactly one 0) implies C<PERL_PERTURB_KEYS=0> (hash key 115randomization disabled); setting C<PERL_HASH_SEED> to any other value implies 116C<PERL_PERTURB_KEYS=2> (deterministic and repeatable hash key randomization). 117Specifying C<PERL_PERTURB_KEYS> explicitly to a different level overrides this 118behavior. 119 120=head3 Hash::Util::hash_seed() now returns a string 121 122Hash::Util::hash_seed() now returns a string instead of an integer. This 123is to make the infrastructure support hash seeds of arbitrary lengths 124which might exceed that of an integer. (SipHash uses a 16 byte seed.) 125 126=head3 Output of PERL_HASH_SEED_DEBUG has been changed 127 128The environment variable PERL_HASH_SEED_DEBUG now makes perl show both the 129hash function perl was built with, I<and> the seed, in hex, in use for that 130process. Code parsing this output, should it exist, must change to accommodate 131the new format. Example of the new format: 132 133 $ PERL_HASH_SEED_DEBUG=1 ./perl -e1 134 HASH_FUNCTION = MURMUR3 HASH_SEED = 0x1476bb9f 135 136=head2 Upgrade to Unicode 6.2 137 138Perl now supports Unicode 6.2. A list of changes from Unicode 1396.1 is at L<http://www.unicode.org/versions/Unicode6.2.0>. 140 141=head2 Character name aliases may now include non-Latin1-range characters 142 143It is possible to define your own names for characters for use in 144C<\N{...}>, C<charnames::vianame()>, etc. These names can now 145consist of characters from the whole Unicode range. This allows for 146names to be in your native language, and not just English. Certain 147restrictions apply to the characters that may be used (you can't define 148a name that has punctuation in it, for example). See L<charnames/CUSTOM 149ALIASES>. 150 151=head2 New DTrace probes 152 153The following new DTrace probes have been added: 154 155=over 4 156 157=item * 158 159C<op-entry> 160 161=item * 162 163C<loading-file> 164 165=item * 166 167C<loaded-file> 168 169=back 170 171=head2 C<${^LAST_FH}> 172 173This new variable provides access to the filehandle that was last read. 174This is the handle used by C<$.> and by C<tell> and C<eof> without 175arguments. 176 177=head2 Regular Expression Set Operations 178 179This is an B<experimental> feature to allow matching against the union, 180intersection, etc., of sets of code points, similar to 181L<Unicode::Regex::Set>. It can also be used to extend C</x> processing 182to [bracketed] character classes, and as a replacement of user-defined 183properties, allowing more complex expressions than they do. See 184L<perlrecharclass/Extended Bracketed Character Classes>. 185 186=head2 Lexical subroutines 187 188This new feature is still considered B<experimental>. To enable it: 189 190 use 5.018; 191 no warnings "experimental::lexical_subs"; 192 use feature "lexical_subs"; 193 194You can now declare subroutines with C<state sub foo>, C<my sub foo>, and 195C<our sub foo>. (C<state sub> requires that the "state" feature be 196enabled, unless you write it as C<CORE::state sub foo>.) 197 198C<state sub> creates a subroutine visible within the lexical scope in which 199it is declared. The subroutine is shared between calls to the outer sub. 200 201C<my sub> declares a lexical subroutine that is created each time the 202enclosing block is entered. C<state sub> is generally slightly faster than 203C<my sub>. 204 205C<our sub> declares a lexical alias to the package subroutine of the same 206name. 207 208For more information, see L<perlsub/Lexical Subroutines>. 209 210=head2 Computed Labels 211 212The loop controls C<next>, C<last> and C<redo>, and the special C<dump> 213operator, now allow arbitrary expressions to be used to compute labels at run 214time. Previously, any argument that was not a constant was treated as the 215empty string. 216 217=head2 More CORE:: subs 218 219Several more built-in functions have been added as subroutines to the 220CORE:: namespace - namely, those non-overridable keywords that can be 221implemented without custom parsers: C<defined>, C<delete>, C<exists>, 222C<glob>, C<pos>, C<prototype>, C<scalar>, C<split>, C<study>, and C<undef>. 223 224As some of these have prototypes, C<prototype('CORE::...')> has been 225changed to not make a distinction between overridable and non-overridable 226keywords. This is to make C<prototype('CORE::pos')> consistent with 227C<prototype(&CORE::pos)>. 228 229=head2 C<kill> with negative signal names 230 231C<kill> has always allowed a negative signal number, which kills the 232process group instead of a single process. It has also allowed signal 233names. But it did not behave consistently, because negative signal names 234were treated as 0. Now negative signals names like C<-INT> are supported 235and treated the same way as -2 [perl #112990]. 236 237=head1 Security 238 239=head2 See also: hash overhaul 240 241Some of the changes in the L<hash overhaul|/"Hash overhaul"> were made to 242enhance security. Please read that section. 243 244=head2 C<Storable> security warning in documentation 245 246The documentation for C<Storable> now includes a section which warns readers 247of the danger of accepting Storable documents from untrusted sources. The 248short version is that deserializing certain types of data can lead to loading 249modules and other code execution. This is documented behavior and wanted 250behavior, but this opens an attack vector for malicious entities. 251 252=head2 C<Locale::Maketext> allowed code injection via a malicious template 253 254If users could provide a translation string to Locale::Maketext, this could be 255used to invoke arbitrary Perl subroutines available in the current process. 256 257This has been fixed, but it is still possible to invoke any method provided by 258C<Locale::Maketext> itself or a subclass that you are using. One of these 259methods in turn will invoke the Perl core's C<sprintf> subroutine. 260 261In summary, allowing users to provide translation strings without auditing 262them is a bad idea. 263 264This vulnerability is documented in CVE-2012-6329. 265 266=head2 Avoid calling memset with a negative count 267 268Poorly written perl code that allows an attacker to specify the count to perl's 269C<x> string repeat operator can already cause a memory exhaustion 270denial-of-service attack. A flaw in versions of perl before v5.15.5 can escalate 271that into a heap buffer overrun; coupled with versions of glibc before 2.16, it 272possibly allows the execution of arbitrary code. 273 274The flaw addressed to this commit has been assigned identifier CVE-2012-5195 275and was researched by Tim Brown. 276 277=head1 Incompatible Changes 278 279=head2 See also: hash overhaul 280 281Some of the changes in the L<hash overhaul|/"Hash overhaul"> are not fully 282compatible with previous versions of perl. Please read that section. 283 284=head2 An unknown character name in C<\N{...}> is now a syntax error 285 286Previously, it warned, and the Unicode REPLACEMENT CHARACTER was 287substituted. Unicode now recommends that this situation be a syntax 288error. Also, the previous behavior led to some confusing warnings and 289behaviors, and since the REPLACEMENT CHARACTER has no use other than as 290a stand-in for some unknown character, any code that has this problem is 291buggy. 292 293=head2 Formerly deprecated characters in C<\N{}> character name aliases are now errors 294 295Since v5.12.0, it has been deprecated to use certain characters in 296user-defined C<\N{...}> character names. These now cause a syntax 297error. For example, it is now an error to begin a name with a digit, 298such as in 299 300 my $undraftable = "\N{4F}"; # Syntax error! 301 302or to have commas anywhere in the name. See L<charnames/CUSTOM ALIASES>. 303 304=head2 C<\N{BELL}> now refers to U+1F514 instead of U+0007 305 306Unicode 6.0 reused the name "BELL" for a different code point than it 307traditionally had meant. Since Perl v5.14, use of this name still 308referred to U+0007, but would raise a deprecation warning. Now, "BELL" 309refers to U+1F514, and the name for U+0007 is "ALERT". All the 310functions in L<charnames> have been correspondingly updated. 311 312=head2 New Restrictions in Multi-Character Case-Insensitive Matching in Regular Expression Bracketed Character Classes 313 314Unicode has now withdrawn their previous recommendation for regular 315expressions to automatically handle cases where a single character can 316match multiple characters case-insensitively, for example, the letter 317LATIN SMALL LETTER SHARP S and the sequence C<ss>. This is because 318it turns out to be impracticable to do this correctly in all 319circumstances. Because Perl has tried to do this as best it can, it 320will continue to do so. (We are considering an option to turn it off.) 321However, a new restriction is being added on such matches when they 322occur in [bracketed] character classes. People were specifying 323things such as C</[\0-\xff]/i>, and being surprised that it matches the 324two character sequence C<ss> (since LATIN SMALL LETTER SHARP S occurs in 325this range). This behavior is also inconsistent with using a 326property instead of a range: C<\p{Block=Latin1}> also includes LATIN 327SMALL LETTER SHARP S, but C</[\p{Block=Latin1}]/i> does not match C<ss>. 328The new rule is that for there to be a multi-character case-insensitive 329match within a bracketed character class, the character must be 330explicitly listed, and not as an end point of a range. This more 331closely obeys the Principle of Least Astonishment. See 332L<perlrecharclass/Bracketed Character Classes>. Note that a bug [perl 333#89774], now fixed as part of this change, prevented the previous 334behavior from working fully. 335 336=head2 Explicit rules for variable names and identifiers 337 338Due to an oversight, single character variable names in v5.16 were 339completely unrestricted. This opened the door to several kinds of 340insanity. As of v5.18, these now follow the rules of other identifiers, 341in addition to accepting characters that match the C<\p{POSIX_Punct}> 342property. 343 344There is no longer any difference in the parsing of identifiers 345specified by using braces versus without braces. For instance, perl 346used to allow C<${foo:bar}> (with a single colon) but not C<$foo:bar>. 347Now that both are handled by a single code path, they are both treated 348the same way: both are forbidden. Note that this change is about the 349range of permissible literal identifiers, not other expressions. 350 351=head2 Vertical tabs are now whitespace 352 353No one could recall why C<\s> didn't match C<\cK>, the vertical tab. 354Now it does. Given the extreme rarity of that character, very little 355breakage is expected. That said, here's what it means: 356 357C<\s> in a regex now matches a vertical tab in all circumstances. 358 359Literal vertical tabs in a regex literal are ignored when the C</x> 360modifier is used. 361 362Leading vertical tabs, alone or mixed with other whitespace, are now 363ignored when interpreting a string as a number. For example: 364 365 $dec = " \cK \t 123"; 366 $hex = " \cK \t 0xF"; 367 368 say 0 + $dec; # was 0 with warning, now 123 369 say int $dec; # was 0, now 123 370 say oct $hex; # was 0, now 15 371 372=head2 C</(?{})/> and C</(??{})/> have been heavily reworked 373 374The implementation of this feature has been almost completely rewritten. 375Although its main intent is to fix bugs, some behaviors, especially 376related to the scope of lexical variables, will have changed. This is 377described more fully in the L</Selected Bug Fixes> section. 378 379=head2 Stricter parsing of substitution replacement 380 381It is no longer possible to abuse the way the parser parses C<s///e> like 382this: 383 384 %_=(_,"Just another "); 385 $_="Perl hacker,\n"; 386 s//_}->{_/e;print 387 388=head2 C<given> now aliases the global C<$_> 389 390Instead of assigning to an implicit lexical C<$_>, C<given> now makes the 391global C<$_> an alias for its argument, just like C<foreach>. However, it 392still uses lexical C<$_> if there is lexical C<$_> in scope (again, just like 393C<foreach>) [perl #114020]. 394 395=head2 The smartmatch family of features are now experimental 396 397Smart match, added in v5.10.0 and significantly revised in v5.10.1, has been 398a regular point of complaint. Although there are a number of ways in which 399it is useful, it has also proven problematic and confusing for both users and 400implementors of Perl. There have been a number of proposals on how to best 401address the problem. It is clear that smartmatch is almost certainly either 402going to change or go away in the future. Relying on its current behavior 403is not recommended. 404 405Warnings will now be issued when the parser sees C<~~>, C<given>, or C<when>. 406To disable these warnings, you can add this line to the appropriate scope: 407 408 no if $] >= 5.018, warnings => "experimental::smartmatch"; 409 410Consider, though, replacing the use of these features, as they may change 411behavior again before becoming stable. 412 413=head2 Lexical C<$_> is now experimental 414 415Since it was introduced in Perl v5.10, it has caused much confusion with no 416obvious solution: 417 418=over 419 420=item * 421 422Various modules (e.g., List::Util) expect callback routines to use the 423global C<$_>. C<use List::Util 'first'; my $_; first { $_ == 1 } @list> 424does not work as one would expect. 425 426=item * 427 428A C<my $_> declaration earlier in the same file can cause confusing closure 429warnings. 430 431=item * 432 433The "_" subroutine prototype character allows called subroutines to access 434your lexical C<$_>, so it is not really private after all. 435 436=item * 437 438Nevertheless, subroutines with a "(@)" prototype and methods cannot access 439the caller's lexical C<$_>, unless they are written in XS. 440 441=item * 442 443But even XS routines cannot access a lexical C<$_> declared, not in the 444calling subroutine, but in an outer scope, iff that subroutine happened not 445to mention C<$_> or use any operators that default to C<$_>. 446 447=back 448 449It is our hope that lexical C<$_> can be rehabilitated, but this may 450cause changes in its behavior. Please use it with caution until it 451becomes stable. 452 453=head2 readline() with C<$/ = \N> now reads N characters, not N bytes 454 455Previously, when reading from a stream with I/O layers such as 456C<encoding>, the readline() function, otherwise known as the C<< <> >> 457operator, would read I<N> bytes from the top-most layer. [perl #79960] 458 459Now, I<N> characters are read instead. 460 461There is no change in behaviour when reading from streams with no 462extra layers, since bytes map exactly to characters. 463 464=head2 Overridden C<glob> is now passed one argument 465 466C<glob> overrides used to be passed a magical undocumented second argument 467that identified the caller. Nothing on CPAN was using this, and it got in 468the way of a bug fix, so it was removed. If you really need to identify 469the caller, see L<Devel::Callsite> on CPAN. 470 471=head2 Here doc parsing 472 473The body of a here document inside a quote-like operator now always begins 474on the line after the "<<foo" marker. Previously, it was documented to 475begin on the line following the containing quote-like operator, but that 476was only sometimes the case [perl #114040]. 477 478=head2 Alphanumeric operators must now be separated from the closing 479delimiter of regular expressions 480 481You may no longer write something like: 482 483 m/a/and 1 484 485Instead you must write 486 487 m/a/ and 1 488 489with whitespace separating the operator from the closing delimiter of 490the regular expression. Not having whitespace has resulted in a 491deprecation warning since Perl v5.14.0. 492 493=head2 qw(...) can no longer be used as parentheses 494 495C<qw> lists used to fool the parser into thinking they were always 496surrounded by parentheses. This permitted some surprising constructions 497such as C<foreach $x qw(a b c) {...}>, which should really be written 498C<foreach $x (qw(a b c)) {...}>. These would sometimes get the lexer into 499the wrong state, so they didn't fully work, and the similar C<foreach qw(a 500b c) {...}> that one might expect to be permitted never worked at all. 501 502This side effect of C<qw> has now been abolished. It has been deprecated 503since Perl v5.13.11. It is now necessary to use real parentheses 504everywhere that the grammar calls for them. 505 506=head2 Interaction of lexical and default warnings 507 508Turning on any lexical warnings used first to disable all default warnings 509if lexical warnings were not already enabled: 510 511 $*; # deprecation warning 512 use warnings "void"; 513 $#; # void warning; no deprecation warning 514 515Now, the C<debugging>, C<deprecated>, C<glob>, C<inplace> and C<malloc> warnings 516categories are left on when turning on lexical warnings (unless they are 517turned off by C<no warnings>, of course). 518 519This may cause deprecation warnings to occur in code that used to be free 520of warnings. 521 522Those are the only categories consisting only of default warnings. Default 523warnings in other categories are still disabled by C<< use warnings "category" >>, 524as we do not yet have the infrastructure for controlling 525individual warnings. 526 527=head2 C<state sub> and C<our sub> 528 529Due to an accident of history, C<state sub> and C<our sub> were equivalent 530to a plain C<sub>, so one could even create an anonymous sub with 531C<our sub { ... }>. These are now disallowed outside of the "lexical_subs" 532feature. Under the "lexical_subs" feature they have new meanings described 533in L<perlsub/Lexical Subroutines>. 534 535=head2 Defined values stored in environment are forced to byte strings 536 537A value stored in an environment variable has always been stringified when 538inherited by child processes. 539 540In this release, when assigning to C<%ENV>, values are immediately stringified, 541and converted to be only a byte string. 542 543First, it is forced to be only a string. Then if the string is utf8 and the 544equivalent of C<utf8::downgrade()> works, that result is used; otherwise, the 545equivalent of C<utf8::encode()> is used, and a warning is issued about wide 546characters (L</Diagnostics>). 547 548=head2 C<require> dies for unreadable files 549 550When C<require> encounters an unreadable file, it now dies. It used to 551ignore the file and continue searching the directories in C<@INC> 552[perl #113422]. 553 554=head2 C<gv_fetchmeth_*> and SUPER 555 556The various C<gv_fetchmeth_*> XS functions used to treat a package whose 557named ended with C<::SUPER> specially. A method lookup on the C<Foo::SUPER> 558package would be treated as a C<SUPER> method lookup on the C<Foo> package. This 559is no longer the case. To do a C<SUPER> lookup, pass the C<Foo> stash and the 560C<GV_SUPER> flag. 561 562=head2 C<split>'s first argument is more consistently interpreted 563 564After some changes earlier in v5.17, C<split>'s behavior has been 565simplified: if the PATTERN argument evaluates to a string 566containing one space, it is treated the way that a I<literal> string 567containing one space once was. 568 569=head1 Deprecations 570 571=head2 Module removals 572 573The following modules will be removed from the core distribution in a future 574release, and will at that time need to be installed from CPAN. Distributions 575on CPAN which require these modules will need to list them as prerequisites. 576 577The core versions of these modules will now issue C<"deprecated">-category 578warnings to alert you to this fact. To silence these deprecation warnings, 579install the modules in question from CPAN. 580 581Note that these are (with rare exceptions) fine modules that you are encouraged 582to continue to use. Their disinclusion from core primarily hinges on their 583necessity to bootstrapping a fully functional, CPAN-capable Perl installation, 584not usually on concerns over their design. 585 586=over 587 588=item L<encoding> 589 590The use of this pragma is now strongly discouraged. It conflates the encoding 591of source text with the encoding of I/O data, reinterprets escape sequences in 592source text (a questionable choice), and introduces the UTF-8 bug to all runtime 593handling of character strings. It is broken as designed and beyond repair. 594 595For using non-ASCII literal characters in source text, please refer to L<utf8>. 596For dealing with textual I/O data, please refer to L<Encode> and L<open>. 597 598=item L<Archive::Extract> 599 600=item L<B::Lint> 601 602=item L<B::Lint::Debug> 603 604=item L<CPANPLUS> and all included C<CPANPLUS::*> modules 605 606=item L<Devel::InnerPackage> 607 608=item L<Log::Message> 609 610=item L<Log::Message::Config> 611 612=item L<Log::Message::Handlers> 613 614=item L<Log::Message::Item> 615 616=item L<Log::Message::Simple> 617 618=item L<Module::Pluggable> 619 620=item L<Module::Pluggable::Object> 621 622=item L<Object::Accessor> 623 624=item L<Pod::LaTeX> 625 626=item L<Term::UI> 627 628=item L<Term::UI::History> 629 630=back 631 632=head2 Deprecated Utilities 633 634The following utilities will be removed from the core distribution in a 635future release as their associated modules have been deprecated. They 636will remain available with the applicable CPAN distribution. 637 638=over 639 640=item L<cpanp> 641 642=item C<cpanp-run-perl> 643 644=item L<cpan2dist> 645 646These items are part of the C<CPANPLUS> distribution. 647 648=item L<pod2latex> 649 650This item is part of the C<Pod::LaTeX> distribution. 651 652=back 653 654=head2 PL_sv_objcount 655 656This interpreter-global variable used to track the total number of 657Perl objects in the interpreter. It is no longer maintained and will 658be removed altogether in Perl v5.20. 659 660=head2 Five additional characters should be escaped in patterns with C</x> 661 662When a regular expression pattern is compiled with C</x>, Perl treats 6 663characters as white space to ignore, such as SPACE and TAB. However, 664Unicode recommends 11 characters be treated thusly. We will conform 665with this in a future Perl version. In the meantime, use of any of the 666missing characters will raise a deprecation warning, unless turned off. 667The five characters are: 668 669 U+0085 NEXT LINE 670 U+200E LEFT-TO-RIGHT MARK 671 U+200F RIGHT-TO-LEFT MARK 672 U+2028 LINE SEPARATOR 673 U+2029 PARAGRAPH SEPARATOR 674 675=head2 User-defined charnames with surprising whitespace 676 677A user-defined character name with trailing or multiple spaces in a row is 678likely a typo. This now generates a warning when defined, on the assumption 679that uses of it will be unlikely to include the excess whitespace. 680 681=head2 Various XS-callable functions are now deprecated 682 683All the functions used to classify characters will be removed from a 684future version of Perl, and should not be used. With participating C 685compilers (e.g., gcc), compiling any file that uses any of these will 686generate a warning. These were not intended for public use; there are 687equivalent, faster, macros for most of them. 688 689See L<perlapi/Character classes>. The complete list is: 690 691C<is_uni_alnum>, C<is_uni_alnumc>, C<is_uni_alnumc_lc>, 692C<is_uni_alnum_lc>, C<is_uni_alpha>, C<is_uni_alpha_lc>, 693C<is_uni_ascii>, C<is_uni_ascii_lc>, C<is_uni_blank>, 694C<is_uni_blank_lc>, C<is_uni_cntrl>, C<is_uni_cntrl_lc>, 695C<is_uni_digit>, C<is_uni_digit_lc>, C<is_uni_graph>, 696C<is_uni_graph_lc>, C<is_uni_idfirst>, C<is_uni_idfirst_lc>, 697C<is_uni_lower>, C<is_uni_lower_lc>, C<is_uni_print>, 698C<is_uni_print_lc>, C<is_uni_punct>, C<is_uni_punct_lc>, 699C<is_uni_space>, C<is_uni_space_lc>, C<is_uni_upper>, 700C<is_uni_upper_lc>, C<is_uni_xdigit>, C<is_uni_xdigit_lc>, 701C<is_utf8_alnum>, C<is_utf8_alnumc>, C<is_utf8_alpha>, 702C<is_utf8_ascii>, C<is_utf8_blank>, C<is_utf8_char>, 703C<is_utf8_cntrl>, C<is_utf8_digit>, C<is_utf8_graph>, 704C<is_utf8_idcont>, C<is_utf8_idfirst>, C<is_utf8_lower>, 705C<is_utf8_mark>, C<is_utf8_perl_space>, C<is_utf8_perl_word>, 706C<is_utf8_posix_digit>, C<is_utf8_print>, C<is_utf8_punct>, 707C<is_utf8_space>, C<is_utf8_upper>, C<is_utf8_xdigit>, 708C<is_utf8_xidcont>, C<is_utf8_xidfirst>. 709 710In addition these three functions that have never worked properly are 711deprecated: 712C<to_uni_lower_lc>, C<to_uni_title_lc>, and C<to_uni_upper_lc>. 713 714=head2 Certain rare uses of backslashes within regexes are now deprecated 715 716There are three pairs of characters that Perl recognizes as 717metacharacters in regular expression patterns: C<{}>, C<[]>, and C<()>. 718These can be used as well to delimit patterns, as in: 719 720 m{foo} 721 s(foo)(bar) 722 723Since they are metacharacters, they have special meaning to regular 724expression patterns, and it turns out that you can't turn off that 725special meaning by the normal means of preceding them with a backslash, 726if you use them, paired, within a pattern delimited by them. For 727example, in 728 729 m{foo\{1,3\}} 730 731the backslashes do not change the behavior, and this matches 732S<C<"f o">> followed by one to three more occurrences of C<"o">. 733 734Usages like this, where they are interpreted as metacharacters, are 735exceedingly rare; we think there are none, for example, in all of CPAN. 736Hence, this deprecation should affect very little code. It does give 737notice, however, that any such code needs to change, which will in turn 738allow us to change the behavior in future Perl versions so that the 739backslashes do have an effect, and without fear that we are silently 740breaking any existing code. 741 742=head2 Splitting the tokens C<(?> and C<(*> in regular expressions 743 744A deprecation warning is now raised if the C<(> and C<?> are separated 745by white space or comments in C<(?...)> regular expression constructs. 746Similarly, if the C<(> and C<*> are separated in C<(*VERB...)> 747constructs. 748 749=head2 Pre-PerlIO IO implementations 750 751In theory, you can currently build perl without PerlIO. Instead, you'd use a 752wrapper around stdio or sfio. In practice, this isn't very useful. It's not 753well tested, and without any support for IO layers or (thus) Unicode, it's not 754much of a perl. Building without PerlIO will most likely be removed in the 755next version of perl. 756 757PerlIO supports a C<stdio> layer if stdio use is desired. Similarly a 758sfio layer could be produced in the future, if needed. 759 760=head1 Future Deprecations 761 762=over 763 764=item * 765 766Platforms without support infrastructure 767 768Both Windows CE and z/OS have been historically under-maintained, and are 769currently neither successfully building nor regularly being smoke tested. 770Efforts are underway to change this situation, but it should not be taken for 771granted that the platforms are safe and supported. If they do not become 772buildable and regularly smoked, support for them may be actively removed in 773future releases. If you have an interest in these platforms and you can lend 774your time, expertise, or hardware to help support these platforms, please let 775the perl development effort know by emailing C<perl5-porters@perl.org>. 776 777Some platforms that appear otherwise entirely dead are also on the short list 778for removal between now and v5.20.0: 779 780=over 781 782=item DG/UX 783 784=item NeXT 785 786=back 787 788We also think it likely that current versions of Perl will no longer 789build AmigaOS, DJGPP, NetWare (natively), OS/2 and Plan 9. If you 790are using Perl on such a platform and have an interest in ensuring 791Perl's future on them, please contact us. 792 793We believe that Perl has long been unable to build on mixed endian 794architectures (such as PDP-11s), and intend to remove any remaining 795support code. Similarly, code supporting the long unmaintained GNU 796dld will be removed soon if no-one makes themselves known as an 797active user. 798 799=item * 800 801Swapping of $< and $> 802 803Perl has supported the idiom of swapping $< and $> (and likewise $( and 804$)) to temporarily drop permissions since 5.0, like this: 805 806 ($<, $>) = ($>, $<); 807 808However, this idiom modifies the real user/group id, which can have 809undesirable side-effects, is no longer useful on any platform perl 810supports and complicates the implementation of these variables and list 811assignment in general. 812 813As an alternative, assignment only to C<< $> >> is recommended: 814 815 local $> = $<; 816 817See also: L<Setuid Demystified|http://www.cs.berkeley.edu/~daw/papers/setuid-usenix02.pdf>. 818 819=item * 820 821C<microperl>, long broken and of unclear present purpose, will be removed. 822 823=item * 824 825Revamping C<< "\Q" >> semantics in double-quotish strings when combined with 826other escapes. 827 828There are several bugs and inconsistencies involving combinations 829of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair. 830These need to be fixed, and doing so will necessarily change current 831behavior. The changes have not yet been settled. 832 833=item * 834 835Use of C<$x>, where C<x> stands for any actual (non-printing) C0 control 836character will be disallowed in a future Perl version. Use C<${x}> 837instead (where again C<x> stands for a control character), 838or better, C<$^A> , where C<^> is a caret (CIRCUMFLEX ACCENT), 839and C<A> stands for any of the characters listed at the end of 840L<perlebcdic/OPERATOR DIFFERENCES>. 841 842=back 843 844=head1 Performance Enhancements 845 846=over 4 847 848=item * 849 850Lists of lexical variable declarations (C<my($x, $y)>) are now optimised 851down to a single op and are hence faster than before. 852 853=item * 854 855A new C preprocessor define C<NO_TAINT_SUPPORT> was added that, if set, 856disables Perl's taint support altogether. Using the -T or -t command 857line flags will cause a fatal error. Beware that both core tests as 858well as many a CPAN distribution's tests will fail with this change. On 859the upside, it provides a small performance benefit due to reduced 860branching. 861 862B<Do not enable this unless you know exactly what you are getting yourself 863into.> 864 865=item * 866 867C<pack> with constant arguments is now constant folded in most cases 868[perl #113470]. 869 870=item * 871 872Speed up in regular expression matching against Unicode properties. The 873largest gain is for C<\X>, the Unicode "extended grapheme cluster." The 874gain for it is about 35% - 40%. Bracketed character classes, e.g., 875C<[0-9\x{100}]> containing code points above 255 are also now faster. 876 877=item * 878 879On platforms supporting it, several former macros are now implemented as static 880inline functions. This should speed things up slightly on non-GCC platforms. 881 882=item * 883 884The optimisation of hashes in boolean context has been extended to 885affect C<scalar(%hash)>, C<%hash ? ... : ...>, and C<sub { %hash || ... }>. 886 887=item * 888 889Filetest operators manage the stack in a fractionally more efficient manner. 890 891=item * 892 893Globs used in a numeric context are now numified directly in most cases, 894rather than being numified via stringification. 895 896=item * 897 898The C<x> repetition operator is now folded to a single constant at compile 899time if called in scalar context with constant operands and no parentheses 900around the left operand. 901 902=back 903 904=head1 Modules and Pragmata 905 906=head2 New Modules and Pragmata 907 908=over 4 909 910=item * 911 912L<Config::Perl::V> version 0.16 has been added as a dual-lifed module. 913It provides structured data retrieval of C<perl -V> output including 914information only known to the C<perl> binary and not available via L<Config>. 915 916=back 917 918=head2 Updated Modules and Pragmata 919 920For a complete list of updates, run: 921 922 $ corelist --diff 5.16.0 5.18.0 923 924You can substitute your favorite version in place of C<5.16.0>, too. 925 926=over 927 928=item * 929 930L<Archive::Extract> has been upgraded to 0.68. 931 932Work around an edge case on Linux with Busybox's unzip. 933 934=item * 935 936L<Archive::Tar> has been upgraded to 1.90. 937 938ptar now supports the -T option as well as dashless options 939[rt.cpan.org #75473], [rt.cpan.org #75475]. 940 941Auto-encode filenames marked as UTF-8 [rt.cpan.org #75474]. 942 943Don't use C<tell> on L<IO::Zlib> handles [rt.cpan.org #64339]. 944 945Don't try to C<chown> on symlinks. 946 947=item * 948 949L<autodie> has been upgraded to 2.13. 950 951C<autodie> now plays nicely with the 'open' pragma. 952 953=item * 954 955L<B> has been upgraded to 1.42. 956 957The C<stashoff> method of COPs has been added. This provides access to an 958internal field added in perl 5.16 under threaded builds [perl #113034]. 959 960C<B::COP::stashpv> now supports UTF-8 package names and embedded NULs. 961 962All C<CVf_*> and C<GVf_*> 963and more SV-related flag values are now provided as constants in the C<B::> 964namespace and available for export. The default export list has not changed. 965 966This makes the module work with the new pad API. 967 968=item * 969 970L<B::Concise> has been upgraded to 0.95. 971 972The C<-nobanner> option has been fixed, and C<format>s can now be dumped. 973When passed a sub name to dump, it will check also to see whether it 974is the name of a format. If a sub and a format share the same name, 975it will dump both. 976 977This adds support for the new C<OpMAYBE_TRUEBOOL> and C<OPpTRUEBOOL> flags. 978 979=item * 980 981L<B::Debug> has been upgraded to 1.18. 982 983This adds support (experimentally) for C<B::PADLIST>, which was 984added in Perl 5.17.4. 985 986=item * 987 988L<B::Deparse> has been upgraded to 1.20. 989 990Avoid warning when run under C<perl -w>. 991 992It now deparses 993loop controls with the correct precedence, and multiple statements in a 994C<format> line are also now deparsed correctly. 995 996This release suppresses trailing semicolons in formats. 997 998This release adds stub deparsing for lexical subroutines. 999 1000It no longer dies when deparsing C<sort> without arguments. It now 1001correctly omits the comma for C<system $prog @args> and C<exec $prog 1002@args>. 1003 1004=item * 1005 1006L<bignum>, L<bigint> and L<bigrat> have been upgraded to 0.33. 1007 1008The overrides for C<hex> and C<oct> have been rewritten, eliminating 1009several problems, and making one incompatible change: 1010 1011=over 1012 1013=item * 1014 1015Formerly, whichever of C<use bigint> or C<use bigrat> was compiled later 1016would take precedence over the other, causing C<hex> and C<oct> not to 1017respect the other pragma when in scope. 1018 1019=item * 1020 1021Using any of these three pragmata would cause C<hex> and C<oct> anywhere 1022else in the program to evaluate their arguments in list context and prevent 1023them from inferring $_ when called without arguments. 1024 1025=item * 1026 1027Using any of these three pragmata would make C<oct("1234")> return 1234 1028(for any number not beginning with 0) anywhere in the program. Now "1234" 1029is translated from octal to decimal, whether within the pragma's scope or 1030not. 1031 1032=item * 1033 1034The global overrides that facilitate lexical use of C<hex> and C<oct> now 1035respect any existing overrides that were in place before the new overrides 1036were installed, falling back to them outside of the scope of C<use bignum>. 1037 1038=item * 1039 1040C<use bignum "hex">, C<use bignum "oct"> and similar invocations for bigint 1041and bigrat now export a C<hex> or C<oct> function, instead of providing a 1042global override. 1043 1044=back 1045 1046=item * 1047 1048L<Carp> has been upgraded to 1.29. 1049 1050Carp is no longer confused when C<caller> returns undef for a package that 1051has been deleted. 1052 1053The C<longmess()> and C<shortmess()> functions are now documented. 1054 1055=item * 1056 1057L<CGI> has been upgraded to 3.63. 1058 1059Unrecognized HTML escape sequences are now handled better, problematic 1060trailing newlines are no longer inserted after E<lt>formE<gt> tags 1061by C<startform()> or C<start_form()>, and bogus "Insecure Dependency" 1062warnings appearing with some versions of perl are now worked around. 1063 1064=item * 1065 1066L<Class::Struct> has been upgraded to 0.64. 1067 1068The constructor now respects overridden accessor methods [perl #29230]. 1069 1070=item * 1071 1072L<Compress::Raw::Bzip2> has been upgraded to 2.060. 1073 1074The misuse of Perl's "magic" API has been fixed. 1075 1076=item * 1077 1078L<Compress::Raw::Zlib> has been upgraded to 2.060. 1079 1080Upgrade bundled zlib to version 1.2.7. 1081 1082Fix build failures on Irix, Solaris, and Win32, and also when building as C++ 1083[rt.cpan.org #69985], [rt.cpan.org #77030], [rt.cpan.org #75222]. 1084 1085The misuse of Perl's "magic" API has been fixed. 1086 1087C<compress()>, C<uncompress()>, C<memGzip()> and C<memGunzip()> have 1088been speeded up by making parameter validation more efficient. 1089 1090=item * 1091 1092L<CPAN::Meta::Requirements> has been upgraded to 2.122. 1093 1094Treat undef requirements to C<from_string_hash> as 0 (with a warning). 1095 1096Added C<requirements_for_module> method. 1097 1098=item * 1099 1100L<CPANPLUS> has been upgraded to 0.9135. 1101 1102Allow adding F<blib/script> to PATH. 1103 1104Save the history between invocations of the shell. 1105 1106Handle multiple C<makemakerargs> and C<makeflags> arguments better. 1107 1108This resolves issues with the SQLite source engine. 1109 1110=item * 1111 1112L<Data::Dumper> has been upgraded to 2.145. 1113 1114It has been optimized to only build a seen-scalar hash as necessary, 1115thereby speeding up serialization drastically. 1116 1117Additional tests were added in order to improve statement, branch, condition 1118and subroutine coverage. On the basis of the coverage analysis, some of the 1119internals of Dumper.pm were refactored. Almost all methods are now 1120documented. 1121 1122=item * 1123 1124L<DB_File> has been upgraded to 1.827. 1125 1126The main Perl module no longer uses the C<"@_"> construct. 1127 1128=item * 1129 1130L<Devel::Peek> has been upgraded to 1.11. 1131 1132This fixes compilation with C++ compilers and makes the module work with 1133the new pad API. 1134 1135=item * 1136 1137L<Digest::MD5> has been upgraded to 2.52. 1138 1139Fix C<Digest::Perl::MD5> OO fallback [rt.cpan.org #66634]. 1140 1141=item * 1142 1143L<Digest::SHA> has been upgraded to 5.84. 1144 1145This fixes a double-free bug, which might have caused vulnerabilities 1146in some cases. 1147 1148=item * 1149 1150L<DynaLoader> has been upgraded to 1.18. 1151 1152This is due to a minor code change in the XS for the VMS implementation. 1153 1154This fixes warnings about using C<CODE> sections without an C<OUTPUT> 1155section. 1156 1157=item * 1158 1159L<Encode> has been upgraded to 2.49. 1160 1161The Mac alias x-mac-ce has been added, and various bugs have been fixed 1162in Encode::Unicode, Encode::UTF7 and Encode::GSM0338. 1163 1164=item * 1165 1166L<Env> has been upgraded to 1.04. 1167 1168Its SPLICE implementation no longer misbehaves in list context. 1169 1170=item * 1171 1172L<ExtUtils::CBuilder> has been upgraded to 0.280210. 1173 1174Manifest files are now correctly embedded for those versions of VC++ which 1175make use of them. [perl #111782, #111798]. 1176 1177A list of symbols to export can now be passed to C<link()> when on 1178Windows, as on other OSes [perl #115100]. 1179 1180=item * 1181 1182L<ExtUtils::ParseXS> has been upgraded to 3.18. 1183 1184The generated C code now avoids unnecessarily incrementing 1185C<PL_amagic_generation> on Perl versions where it's done automatically 1186(or on current Perl where the variable no longer exists). 1187 1188This avoids a bogus warning for initialised XSUB non-parameters [perl 1189#112776]. 1190 1191=item * 1192 1193L<File::Copy> has been upgraded to 2.26. 1194 1195C<copy()> no longer zeros files when copying into the same directory, 1196and also now fails (as it has long been documented to do) when attempting 1197to copy a file over itself. 1198 1199=item * 1200 1201L<File::DosGlob> has been upgraded to 1.10. 1202 1203The internal cache of file names that it keeps for each caller is now 1204freed when that caller is freed. This means 1205C<< use File::DosGlob 'glob'; eval 'scalar <*>' >> no longer leaks memory. 1206 1207=item * 1208 1209L<File::Fetch> has been upgraded to 0.38. 1210 1211Added the 'file_default' option for URLs that do not have a file 1212component. 1213 1214Use C<File::HomeDir> when available, and provide C<PERL5_CPANPLUS_HOME> to 1215override the autodetection. 1216 1217Always re-fetch F<CHECKSUMS> if C<fetchdir> is set. 1218 1219=item * 1220 1221L<File::Find> has been upgraded to 1.23. 1222 1223This fixes inconsistent unixy path handling on VMS. 1224 1225Individual files may now appear in list of directories to be searched 1226[perl #59750]. 1227 1228=item * 1229 1230L<File::Glob> has been upgraded to 1.20. 1231 1232File::Glob has had exactly the same fix as File::DosGlob. Since it is 1233what Perl's own C<glob> operator itself uses (except on VMS), this means 1234C<< eval 'scalar <*>' >> no longer leaks. 1235 1236A space-separated list of patterns return long lists of results no longer 1237results in memory corruption or crashes. This bug was introduced in 1238Perl 5.16.0. [perl #114984] 1239 1240=item * 1241 1242L<File::Spec::Unix> has been upgraded to 3.40. 1243 1244C<abs2rel> could produce incorrect results when given two relative paths or 1245the root directory twice [perl #111510]. 1246 1247=item * 1248 1249L<File::stat> has been upgraded to 1.07. 1250 1251C<File::stat> ignores the L<filetest> pragma, and warns when used in 1252combination therewith. But it was not warning for C<-r>. This has been 1253fixed [perl #111640]. 1254 1255C<-p> now works, and does not return false for pipes [perl #111638]. 1256 1257Previously C<File::stat>'s overloaded C<-x> and C<-X> operators did not give 1258the correct results for directories or executable files when running as 1259root. They had been treating executable permissions for root just like for 1260any other user, performing group membership tests I<etc> for files not owned 1261by root. They now follow the correct Unix behaviour - for a directory they 1262are always true, and for a file if any of the three execute permission bits 1263are set then they report that root can execute the file. Perl's builtin 1264C<-x> and C<-X> operators have always been correct. 1265 1266=item * 1267 1268L<File::Temp> has been upgraded to 0.23 1269 1270Fixes various bugs involving directory removal. Defers unlinking tempfiles if 1271the initial unlink fails, which fixes problems on NFS. 1272 1273=item * 1274 1275L<GDBM_File> has been upgraded to 1.15. 1276 1277The undocumented optional fifth parameter to C<TIEHASH> has been 1278removed. This was intended to provide control of the callback used by 1279C<gdbm*> functions in case of fatal errors (such as filesystem problems), 1280but did not work (and could never have worked). No code on CPAN even 1281attempted to use it. The callback is now always the previous default, 1282C<croak>. Problems on some platforms with how the C<C> C<croak> function 1283is called have also been resolved. 1284 1285=item * 1286 1287L<Hash::Util> has been upgraded to 0.15. 1288 1289C<hash_unlocked> and C<hashref_unlocked> now returns true if the hash is 1290unlocked, instead of always returning false [perl #112126]. 1291 1292C<hash_unlocked>, C<hashref_unlocked>, C<lock_hash_recurse> and 1293C<unlock_hash_recurse> are now exportable [perl #112126]. 1294 1295Two new functions, C<hash_locked> and C<hashref_locked>, have been added. 1296Oddly enough, these two functions were already exported, even though they 1297did not exist [perl #112126]. 1298 1299=item * 1300 1301L<HTTP::Tiny> has been upgraded to 0.025. 1302 1303Add SSL verification features [github #6], [github #9]. 1304 1305Include the final URL in the response hashref. 1306 1307Add C<local_address> option. 1308 1309This improves SSL support. 1310 1311=item * 1312 1313L<IO> has been upgraded to 1.28. 1314 1315C<sync()> can now be called on read-only file handles [perl #64772]. 1316 1317L<IO::Socket> tries harder to cache or otherwise fetch socket 1318information. 1319 1320=item * 1321 1322L<IPC::Cmd> has been upgraded to 0.80. 1323 1324Use C<POSIX::_exit> instead of C<exit> in C<run_forked> [rt.cpan.org #76901]. 1325 1326=item * 1327 1328L<IPC::Open3> has been upgraded to 1.13. 1329 1330The C<open3()> function no longer uses C<POSIX::close()> to close file 1331descriptors since that breaks the ref-counting of file descriptors done by 1332PerlIO in cases where the file descriptors are shared by PerlIO streams, 1333leading to attempts to close the file descriptors a second time when 1334any such PerlIO streams are closed later on. 1335 1336=item * 1337 1338L<Locale::Codes> has been upgraded to 3.25. 1339 1340It includes some new codes. 1341 1342=item * 1343 1344L<Memoize> has been upgraded to 1.03. 1345 1346Fix the C<MERGE> cache option. 1347 1348=item * 1349 1350L<Module::Build> has been upgraded to 0.4003. 1351 1352Fixed bug where modules without C<$VERSION> might have a version of '0' listed 1353in 'provides' metadata, which will be rejected by PAUSE. 1354 1355Fixed bug in PodParser to allow numerals in module names. 1356 1357Fixed bug where giving arguments twice led to them becoming arrays, resulting 1358in install paths like F<ARRAY(0xdeadbeef)/lib/Foo.pm>. 1359 1360A minor bug fix allows markup to be used around the leading "Name" in 1361a POD "abstract" line, and some documentation improvements have been made. 1362 1363=item * 1364 1365L<Module::CoreList> has been upgraded to 2.90 1366 1367Version information is now stored as a delta, which greatly reduces the 1368size of the F<CoreList.pm> file. 1369 1370This restores compatibility with older versions of perl and cleans up 1371the corelist data for various modules. 1372 1373=item * 1374 1375L<Module::Load::Conditional> has been upgraded to 0.54. 1376 1377Fix use of C<requires> on perls installed to a path with spaces. 1378 1379Various enhancements include the new use of Module::Metadata. 1380 1381=item * 1382 1383L<Module::Metadata> has been upgraded to 1.000011. 1384 1385The creation of a Module::Metadata object for a typical module file has 1386been sped up by about 40%, and some spurious warnings about C<$VERSION>s 1387have been suppressed. 1388 1389=item * 1390 1391L<Module::Pluggable> has been upgraded to 4.7. 1392 1393Amongst other changes, triggers are now allowed on events, which gives 1394a powerful way to modify behaviour. 1395 1396=item * 1397 1398L<Net::Ping> has been upgraded to 2.41. 1399 1400This fixes some test failures on Windows. 1401 1402=item * 1403 1404L<Opcode> has been upgraded to 1.25. 1405 1406Reflect the removal of the boolkeys opcode and the addition of the 1407clonecv, introcv and padcv opcodes. 1408 1409=item * 1410 1411L<overload> has been upgraded to 1.22. 1412 1413C<no overload> now warns for invalid arguments, just like C<use overload>. 1414 1415=item * 1416 1417L<PerlIO::encoding> has been upgraded to 0.16. 1418 1419This is the module implementing the ":encoding(...)" I/O layer. It no 1420longer corrupts memory or crashes when the encoding back-end reallocates 1421the buffer or gives it a typeglob or shared hash key scalar. 1422 1423=item * 1424 1425L<PerlIO::scalar> has been upgraded to 0.16. 1426 1427The buffer scalar supplied may now only contain code points 0xFF or 1428lower. [perl #109828] 1429 1430=item * 1431 1432L<Perl::OSType> has been upgraded to 1.003. 1433 1434This fixes a bug detecting the VOS operating system. 1435 1436=item * 1437 1438L<Pod::Html> has been upgraded to 1.18. 1439 1440The option C<--libpods> has been reinstated. It is deprecated, and its use 1441does nothing other than issue a warning that it is no longer supported. 1442 1443Since the HTML files generated by pod2html claim to have a UTF-8 charset, 1444actually write the files out using UTF-8 [perl #111446]. 1445 1446=item * 1447 1448L<Pod::Simple> has been upgraded to 3.28. 1449 1450Numerous improvements have been made, mostly to Pod::Simple::XHTML, 1451which also has a compatibility change: the C<codes_in_verbatim> option 1452is now disabled by default. See F<cpan/Pod-Simple/ChangeLog> for the 1453full details. 1454 1455=item * 1456 1457L<re> has been upgraded to 0.23 1458 1459Single character [class]es like C</[s]/> or C</[s]/i> are now optimized 1460as if they did not have the brackets, i.e. C</s/> or C</s/i>. 1461 1462See note about C<op_comp> in the L</Internal Changes> section below. 1463 1464=item * 1465 1466L<Safe> has been upgraded to 2.35. 1467 1468Fix interactions with C<Devel::Cover>. 1469 1470Don't eval code under C<no strict>. 1471 1472=item * 1473 1474L<Scalar::Util> has been upgraded to version 1.27. 1475 1476Fix an overloading issue with C<sum>. 1477 1478C<first> and C<reduce> now check the callback first (so C<&first(1)> is 1479disallowed). 1480 1481Fix C<tainted> on magical values [rt.cpan.org #55763]. 1482 1483Fix C<sum> on previously magical values [rt.cpan.org #61118]. 1484 1485Fix reading past the end of a fixed buffer [rt.cpan.org #72700]. 1486 1487=item * 1488 1489L<Search::Dict> has been upgraded to 1.07. 1490 1491No longer require C<stat> on filehandles. 1492 1493Use C<fc> for casefolding. 1494 1495=item * 1496 1497L<Socket> has been upgraded to 2.009. 1498 1499Constants and functions required for IP multicast source group membership 1500have been added. 1501 1502C<unpack_sockaddr_in()> and C<unpack_sockaddr_in6()> now return just the IP 1503address in scalar context, and C<inet_ntop()> now guards against incorrect 1504length scalars being passed in. 1505 1506This fixes an uninitialized memory read. 1507 1508=item * 1509 1510L<Storable> has been upgraded to 2.41. 1511 1512Modifying C<$_[0]> within C<STORABLE_freeze> no longer results in crashes 1513[perl #112358]. 1514 1515An object whose class implements C<STORABLE_attach> is now thawed only once 1516when there are multiple references to it in the structure being thawed 1517[perl #111918]. 1518 1519Restricted hashes were not always thawed correctly [perl #73972]. 1520 1521Storable would croak when freezing a blessed REF object with a 1522C<STORABLE_freeze()> method [perl #113880]. 1523 1524It can now freeze and thaw vstrings correctly. This causes a slight 1525incompatible change in the storage format, so the format version has 1526increased to 2.9. 1527 1528This contains various bugfixes, including compatibility fixes for older 1529versions of Perl and vstring handling. 1530 1531=item * 1532 1533L<Sys::Syslog> has been upgraded to 0.32. 1534 1535This contains several bug fixes relating to C<getservbyname()>, 1536C<setlogsock()>and log levels in C<syslog()>, together with fixes for 1537Windows, Haiku-OS and GNU/kFreeBSD. See F<cpan/Sys-Syslog/Changes> 1538for the full details. 1539 1540=item * 1541 1542L<Term::ANSIColor> has been upgraded to 4.02. 1543 1544Add support for italics. 1545 1546Improve error handling. 1547 1548=item * 1549 1550L<Term::ReadLine> has been upgraded to 1.10. This fixes the 1551use of the B<cpan> and B<cpanp> shells on Windows in the event that the current 1552drive happens to contain a F<\dev\tty> file. 1553 1554=item * 1555 1556L<Test::Harness> has been upgraded to 3.26. 1557 1558Fix glob semantics on Win32 [rt.cpan.org #49732]. 1559 1560Don't use C<Win32::GetShortPathName> when calling perl [rt.cpan.org #47890]. 1561 1562Ignore -T when reading shebang [rt.cpan.org #64404]. 1563 1564Handle the case where we don't know the wait status of the test more 1565gracefully. 1566 1567Make the test summary 'ok' line overridable so that it can be changed to a 1568plugin to make the output of prove idempotent. 1569 1570Don't run world-writable files. 1571 1572=item * 1573 1574L<Text::Tabs> and L<Text::Wrap> have been upgraded to 15752012.0818. Support for Unicode combining characters has been added to them 1576both. 1577 1578=item * 1579 1580L<threads::shared> has been upgraded to 1.31. 1581 1582This adds the option to warn about or ignore attempts to clone structures 1583that can't be cloned, as opposed to just unconditionally dying in 1584that case. 1585 1586This adds support for dual-valued values as created by 1587L<Scalar::Util::dualvar|Scalar::Util/"dualvar NUM, STRING">. 1588 1589=item * 1590 1591L<Tie::StdHandle> has been upgraded to 4.3. 1592 1593C<READ> now respects the offset argument to C<read> [perl #112826]. 1594 1595=item * 1596 1597L<Time::Local> has been upgraded to 1.2300. 1598 1599Seconds values greater than 59 but less than 60 no longer cause 1600C<timegm()> and C<timelocal()> to croak. 1601 1602=item * 1603 1604L<Unicode::UCD> has been upgraded to 0.53. 1605 1606This adds a function L<all_casefolds()|Unicode::UCD/all_casefolds()> 1607that returns all the casefolds. 1608 1609=item * 1610 1611L<Win32> has been upgraded to 0.47. 1612 1613New APIs have been added for getting and setting the current code page. 1614 1615=back 1616 1617 1618=head2 Removed Modules and Pragmata 1619 1620=over 1621 1622=item * 1623 1624L<Version::Requirements> has been removed from the core distribution. It is 1625available under a different name: L<CPAN::Meta::Requirements>. 1626 1627=back 1628 1629=head1 Documentation 1630 1631=head2 Changes to Existing Documentation 1632 1633=head3 L<perlcheat> 1634 1635=over 4 1636 1637=item * 1638 1639L<perlcheat> has been reorganized, and a few new sections were added. 1640 1641=back 1642 1643=head3 L<perldata> 1644 1645=over 4 1646 1647=item * 1648 1649Now explicitly documents the behaviour of hash initializer lists that 1650contain duplicate keys. 1651 1652=back 1653 1654=head3 L<perldiag> 1655 1656=over 4 1657 1658=item * 1659 1660The explanation of symbolic references being prevented by "strict refs" 1661now doesn't assume that the reader knows what symbolic references are. 1662 1663=back 1664 1665=head3 L<perlfaq> 1666 1667=over 4 1668 1669=item * 1670 1671L<perlfaq> has been synchronized with version 5.0150040 from CPAN. 1672 1673=back 1674 1675=head3 L<perlfunc> 1676 1677=over 4 1678 1679=item * 1680 1681The return value of C<pipe> is now documented. 1682 1683=item * 1684 1685Clarified documentation of C<our>. 1686 1687=back 1688 1689=head3 L<perlop> 1690 1691=over 4 1692 1693=item * 1694 1695Loop control verbs (C<dump>, C<goto>, C<next>, C<last> and C<redo>) have always 1696had the same precedence as assignment operators, but this was not documented 1697until now. 1698 1699=back 1700 1701=head3 Diagnostics 1702 1703The following additions or changes have been made to diagnostic output, 1704including warnings and fatal error messages. For the complete list of 1705diagnostic messages, see L<perldiag>. 1706 1707=head2 New Diagnostics 1708 1709=head3 New Errors 1710 1711=over 4 1712 1713=item * 1714 1715L<Unterminated delimiter for here document|perldiag/"Unterminated delimiter for here document"> 1716 1717This message now occurs when a here document label has an initial quotation 1718mark but the final quotation mark is missing. 1719 1720This replaces a bogus and misleading error message about not finding the label 1721itself [perl #114104]. 1722 1723=item * 1724 1725L<panic: child pseudo-process was never scheduled|perldiag/"panic: child pseudo-process was never scheduled"> 1726 1727This error is thrown when a child pseudo-process in the ithreads implementation 1728on Windows was not scheduled within the time period allowed and therefore was 1729not able to initialize properly [perl #88840]. 1730 1731=item * 1732 1733L<Group name must start with a non-digit word character in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Group name must start with a non-digit word character in regex; marked by <-- HERE in m/%s/"> 1734 1735This error has been added for C<(?&0)>, which is invalid. It used to 1736produce an incomprehensible error message [perl #101666]. 1737 1738=item * 1739 1740L<Can't use an undefined value as a subroutine reference|perldiag/"Can't use an undefined value as %s reference"> 1741 1742Calling an undefined value as a subroutine now produces this error message. 1743It used to, but was accidentally disabled, first in Perl 5.004 for 1744non-magical variables, and then in Perl v5.14 for magical (e.g., tied) 1745variables. It has now been restored. In the mean time, undef was treated 1746as an empty string [perl #113576]. 1747 1748=item * 1749 1750L<Experimental "%s" subs not enabled|perldiag/"Experimental "%s" subs not enabled"> 1751 1752To use lexical subs, you must first enable them: 1753 1754 no warnings 'experimental::lexical_subs'; 1755 use feature 'lexical_subs'; 1756 my sub foo { ... } 1757 1758=back 1759 1760=head3 New Warnings 1761 1762=over 4 1763 1764=item * 1765 1766L<'Strings with code points over 0xFF may not be mapped into in-memory file handles'|perldiag/"Strings with code points over 0xFF may not be mapped into in-memory file handles"> 1767 1768=item * 1769 1770L<'%s' resolved to '\o{%s}%d'|perldiag/"'%s' resolved to '\o{%s}%d'"> 1771 1772=item * 1773 1774L<'Trailing white-space in a charnames alias definition is deprecated'|perldiag/"Trailing white-space in a charnames alias definition is deprecated"> 1775 1776=item * 1777 1778L<'A sequence of multiple spaces in a charnames alias definition is deprecated'|perldiag/"A sequence of multiple spaces in a charnames alias definition is deprecated"> 1779 1780=item * 1781 1782L<'Passing malformed UTF-8 to "%s" is deprecated'|perldiag/"Passing malformed UTF-8 to "%s" is deprecated"> 1783 1784=item * 1785 1786L<Subroutine "&%s" is not available|perldiag/"Subroutine "&%s" is not available"> 1787 1788(W closure) During compilation, an inner named subroutine or eval is 1789attempting to capture an outer lexical subroutine that is not currently 1790available. This can happen for one of two reasons. First, the lexical 1791subroutine may be declared in an outer anonymous subroutine that has not 1792yet been created. (Remember that named subs are created at compile time, 1793while anonymous subs are created at run-time.) For example, 1794 1795 sub { my sub a {...} sub f { \&a } } 1796 1797At the time that f is created, it can't capture the current the "a" sub, 1798since the anonymous subroutine hasn't been created yet. Conversely, the 1799following won't give a warning since the anonymous subroutine has by now 1800been created and is live: 1801 1802 sub { my sub a {...} eval 'sub f { \&a }' }->(); 1803 1804The second situation is caused by an eval accessing a variable that has 1805gone out of scope, for example, 1806 1807 sub f { 1808 my sub a {...} 1809 sub { eval '\&a' } 1810 } 1811 f()->(); 1812 1813Here, when the '\&a' in the eval is being compiled, f() is not currently 1814being executed, so its &a is not available for capture. 1815 1816=item * 1817 1818L<"%s" subroutine &%s masks earlier declaration in same %s|perldiag/"%s" subroutine &%s masks earlier declaration in same %s> 1819 1820(W misc) A "my" or "state" subroutine has been redeclared in the 1821current scope or statement, effectively eliminating all access to 1822the previous instance. This is almost always a typographical error. 1823Note that the earlier subroutine will still exist until the end of 1824the scope or until all closure references to it are destroyed. 1825 1826=item * 1827 1828L<The %s feature is experimental|perldiag/"The %s feature is experimental"> 1829 1830(S experimental) This warning is emitted if you enable an experimental 1831feature via C<use feature>. Simply suppress the warning if you want 1832to use the feature, but know that in doing so you are taking the risk 1833of using an experimental feature which may change or be removed in a 1834future Perl version: 1835 1836 no warnings "experimental::lexical_subs"; 1837 use feature "lexical_subs"; 1838 1839=item * 1840 1841L<sleep(%u) too large|perldiag/"sleep(%u) too large"> 1842 1843(W overflow) You called C<sleep> with a number that was larger than it can 1844reliably handle and C<sleep> probably slept for less time than requested. 1845 1846=item * 1847 1848L<Wide character in setenv|perldiag/"Wide character in %s"> 1849 1850Attempts to put wide characters into environment variables via C<%ENV> now 1851provoke this warning. 1852 1853=item * 1854 1855"L<Invalid negative number (%s) in chr|perldiag/"Invalid negative number (%s) in chr">" 1856 1857C<chr()> now warns when passed a negative value [perl #83048]. 1858 1859=item * 1860 1861"L<Integer overflow in srand|perldiag/"Integer overflow in srand">" 1862 1863C<srand()> now warns when passed a value that doesn't fit in a C<UV> (since the 1864value will be truncated rather than overflowing) [perl #40605]. 1865 1866=item * 1867 1868"L<-i used with no filenames on the command line, reading from STDIN|perldiag/"-i used with no filenames on the command line, reading from STDIN">" 1869 1870Running perl with the C<-i> flag now warns if no input files are provided on 1871the command line [perl #113410]. 1872 1873=back 1874 1875=head2 Changes to Existing Diagnostics 1876 1877=over 4 1878 1879=item * 1880 1881L<$* is no longer supported|perldiag/"$* is no longer supported"> 1882 1883The warning that use of C<$*> and C<$#> is no longer supported is now 1884generated for every location that references them. Previously it would fail 1885to be generated if another variable using the same typeglob was seen first 1886(e.g. C<@*> before C<$*>), and would not be generated for the second and 1887subsequent uses. (It's hard to fix the failure to generate warnings at all 1888without also generating them every time, and warning every time is 1889consistent with the warnings that C<$[> used to generate.) 1890 1891=item * 1892 1893The warnings for C<\b{> and C<\B{> were added. They are a deprecation 1894warning which should be turned off by that category. One should not 1895have to turn off regular regexp warnings as well to get rid of these. 1896 1897=item * 1898 1899L<Constant(%s): Call to &{$^H{%s}} did not return a defined value|perldiag/Constant(%s): Call to &{$^H{%s}} did not return a defined value> 1900 1901Constant overloading that returns C<undef> results in this error message. 1902For numeric constants, it used to say "Constant(undef)". "undef" has been 1903replaced with the number itself. 1904 1905=item * 1906 1907The error produced when a module cannot be loaded now includes a hint that 1908the module may need to be installed: "Can't locate hopping.pm in @INC (you 1909may need to install the hopping module) (@INC contains: ...)" 1910 1911=item * 1912 1913L<vector argument not supported with alpha versions|perldiag/vector argument not supported with alpha versions> 1914 1915This warning was not suppressible, even with C<no warnings>. Now it is 1916suppressible, and has been moved from the "internal" category to the 1917"printf" category. 1918 1919=item * 1920 1921C<< Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ >> 1922 1923This fatal error has been turned into a warning that reads: 1924 1925L<< Quantifier {n,m} with n > m can't match in regex | perldiag/Quantifier {n,m} with n > m can't match in regex >> 1926 1927(W regexp) Minima should be less than or equal to maxima. If you really want 1928your regexp to match something 0 times, just put {0}. 1929 1930=item * 1931 1932The "Runaway prototype" warning that occurs in bizarre cases has been 1933removed as being unhelpful and inconsistent. 1934 1935=item * 1936 1937The "Not a format reference" error has been removed, as the only case in 1938which it could be triggered was a bug. 1939 1940=item * 1941 1942The "Unable to create sub named %s" error has been removed for the same 1943reason. 1944 1945=item * 1946 1947The 'Can't use "my %s" in sort comparison' error has been downgraded to a 1948warning, '"my %s" used in sort comparison' (with 'state' instead of 'my' 1949for state variables). In addition, the heuristics for guessing whether 1950lexical $a or $b has been misused have been improved to generate fewer 1951false positives. Lexical $a and $b are no longer disallowed if they are 1952outside the sort block. Also, a named unary or list operator inside the 1953sort block no longer causes the $a or $b to be ignored [perl #86136]. 1954 1955=back 1956 1957=head1 Utility Changes 1958 1959=head3 L<h2xs> 1960 1961=over 4 1962 1963=item * 1964 1965F<h2xs> no longer produces invalid code for empty defines. [perl #20636] 1966 1967=back 1968 1969=head1 Configuration and Compilation 1970 1971=over 4 1972 1973=item * 1974 1975Added C<useversionedarchname> option to Configure 1976 1977When set, it includes 'api_versionstring' in 'archname'. E.g. 1978x86_64-linux-5.13.6-thread-multi. It is unset by default. 1979 1980This feature was requested by Tim Bunce, who observed that 1981C<INSTALL_BASE> creates a library structure that does not 1982differentiate by perl version. Instead, it places architecture 1983specific files in "$install_base/lib/perl5/$archname". This makes 1984it difficult to use a common C<INSTALL_BASE> library path with 1985multiple versions of perl. 1986 1987By setting C<-Duseversionedarchname>, the $archname will be 1988distinct for architecture I<and> API version, allowing mixed use of 1989C<INSTALL_BASE>. 1990 1991=item * 1992 1993Add a C<PERL_NO_INLINE_FUNCTIONS> option 1994 1995If C<PERL_NO_INLINE_FUNCTIONS> is defined, don't include "inline.h" 1996 1997This permits test code to include the perl headers for definitions without 1998creating a link dependency on the perl library (which may not exist yet). 1999 2000=item * 2001 2002Configure will honour the external C<MAILDOMAIN> environment variable, if set. 2003 2004=item * 2005 2006C<installman> no longer ignores the silent option 2007 2008=item * 2009 2010Both C<META.yml> and C<META.json> files are now included in the distribution. 2011 2012=item * 2013 2014F<Configure> will now correctly detect C<isblank()> when compiling with a C++ 2015compiler. 2016 2017=item * 2018 2019The pager detection in F<Configure> has been improved to allow responses which 2020specify options after the program name, e.g. B</usr/bin/less -R>, if the user 2021accepts the default value. This helps B<perldoc> when handling ANSI escapes 2022[perl #72156]. 2023 2024=back 2025 2026=head1 Testing 2027 2028=over 4 2029 2030=item * 2031 2032The test suite now has a section for tests that require very large amounts 2033of memory. These tests won't run by default; they can be enabled by 2034setting the C<PERL_TEST_MEMORY> environment variable to the number of 2035gibibytes of memory that may be safely used. 2036 2037=back 2038 2039=head1 Platform Support 2040 2041=head2 Discontinued Platforms 2042 2043=over 4 2044 2045=item BeOS 2046 2047BeOS was an operating system for personal computers developed by Be Inc, 2048initially for their BeBox hardware. The OS Haiku was written as an open 2049source replacement for/continuation of BeOS, and its perl port is current and 2050actively maintained. 2051 2052=item UTS Global 2053 2054Support code relating to UTS global has been removed. UTS was a mainframe 2055version of System V created by Amdahl, subsequently sold to UTS Global. The 2056port has not been touched since before Perl v5.8.0, and UTS Global is now 2057defunct. 2058 2059=item VM/ESA 2060 2061Support for VM/ESA has been removed. The port was tested on 2.3.0, which 2062IBM ended service on in March 2002. 2.4.0 ended service in June 2003, and 2063was superseded by Z/VM. The current version of Z/VM is V6.2.0, and scheduled 2064for end of service on 2015/04/30. 2065 2066=item MPE/IX 2067 2068Support for MPE/IX has been removed. 2069 2070=item EPOC 2071 2072Support code relating to EPOC has been removed. EPOC was a family of 2073operating systems developed by Psion for mobile devices. It was the 2074predecessor of Symbian. The port was last updated in April 2002. 2075 2076=item Rhapsody 2077 2078Support for Rhapsody has been removed. 2079 2080=back 2081 2082=head2 Platform-Specific Notes 2083 2084=head3 AIX 2085 2086Configure now always adds C<-qlanglvl=extc99> to the CC flags on AIX when 2087using xlC. This will make it easier to compile a number of XS-based modules 2088that assume C99 [perl #113778]. 2089 2090=head3 clang++ 2091 2092There is now a workaround for a compiler bug that prevented compiling 2093with clang++ since Perl v5.15.7 [perl #112786]. 2094 2095=head3 C++ 2096 2097When compiling the Perl core as C++ (which is only semi-supported), the 2098mathom functions are now compiled as C<extern "C">, to ensure proper 2099binary compatibility. (However, binary compatibility isn't generally 2100guaranteed anyway in the situations where this would matter.) 2101 2102=head3 Darwin 2103 2104Stop hardcoding an alignment on 8 byte boundaries to fix builds using 2105-Dusemorebits. 2106 2107=head3 Haiku 2108 2109Perl should now work out of the box on Haiku R1 Alpha 4. 2110 2111=head3 MidnightBSD 2112 2113C<libc_r> was removed from recent versions of MidnightBSD and older versions 2114work better with C<pthread>. Threading is now enabled using C<pthread> which 2115corrects build errors with threading enabled on 0.4-CURRENT. 2116 2117=head3 Solaris 2118 2119In Configure, avoid running sed commands with flags not supported on Solaris. 2120 2121=head3 VMS 2122 2123=over 2124 2125=item * 2126 2127Where possible, the case of filenames and command-line arguments is now 2128preserved by enabling the CRTL features C<DECC$EFS_CASE_PRESERVE> and 2129C<DECC$ARGV_PARSE_STYLE> at start-up time. The latter only takes effect 2130when extended parse is enabled in the process from which Perl is run. 2131 2132=item * 2133 2134The character set for Extended Filename Syntax (EFS) is now enabled by default 2135on VMS. Among other things, this provides better handling of dots in directory 2136names, multiple dots in filenames, and spaces in filenames. To obtain the old 2137behavior, set the logical name C<DECC$EFS_CHARSET> to C<DISABLE>. 2138 2139=item * 2140 2141Fixed linking on builds configured with C<-Dusemymalloc=y>. 2142 2143=item * 2144 2145Experimental support for building Perl with the HP C++ compiler is available 2146by configuring with C<-Dusecxx>. 2147 2148=item * 2149 2150All C header files from the top-level directory of the distribution are now 2151installed on VMS, providing consistency with a long-standing practice on other 2152platforms. Previously only a subset were installed, which broke non-core 2153extension builds for extensions that depended on the missing include files. 2154 2155=item * 2156 2157Quotes are now removed from the command verb (but not the parameters) for 2158commands spawned via C<system>, backticks, or a piped C<open>. Previously, 2159quotes on the verb were passed through to DCL, which would fail to recognize 2160the command. Also, if the verb is actually a path to an image or command 2161procedure on an ODS-5 volume, quoting it now allows the path to contain spaces. 2162 2163=item * 2164 2165The B<a2p> build has been fixed for the HP C++ compiler on OpenVMS. 2166 2167=back 2168 2169=head3 Win32 2170 2171=over 2172 2173=item * 2174 2175Perl can now be built using Microsoft's Visual C++ 2012 compiler by specifying 2176CCTYPE=MSVC110 (or MSVC110FREE if you are using the free Express edition for 2177Windows Desktop) in F<win32/Makefile>. 2178 2179=item * 2180 2181The option to build without C<USE_SOCKETS_AS_HANDLES> has been removed. 2182 2183=item * 2184 2185Fixed a problem where perl could crash while cleaning up threads (including the 2186main thread) in threaded debugging builds on Win32 and possibly other platforms 2187[perl #114496]. 2188 2189=item * 2190 2191A rare race condition that would lead to L<sleep|perlfunc/sleep> taking more 2192time than requested, and possibly even hanging, has been fixed [perl #33096]. 2193 2194=item * 2195 2196C<link> on Win32 now attempts to set C<$!> to more appropriate values 2197based on the Win32 API error code. [perl #112272] 2198 2199Perl no longer mangles the environment block, e.g. when launching a new 2200sub-process, when the environment contains non-ASCII characters. Known 2201problems still remain, however, when the environment contains characters 2202outside of the current ANSI codepage (e.g. see the item about Unicode in 2203C<%ENV> in L<http://perl5.git.perl.org/perl.git/blob/HEAD:/Porting/todo.pod>). 2204[perl #113536] 2205 2206=item * 2207 2208Building perl with some Windows compilers used to fail due to a problem 2209with miniperl's C<glob> operator (which uses the C<perlglob> program) 2210deleting the PATH environment variable [perl #113798]. 2211 2212=item * 2213 2214A new makefile option, C<USE_64_BIT_INT>, has been added to the Windows 2215makefiles. Set this to "define" when building a 32-bit perl if you want 2216it to use 64-bit integers. 2217 2218Machine code size reductions, already made to the DLLs of XS modules in 2219Perl v5.17.2, have now been extended to the perl DLL itself. 2220 2221Building with VC++ 6.0 was inadvertently broken in Perl v5.17.2 but has 2222now been fixed again. 2223 2224=back 2225 2226=head3 WinCE 2227 2228Building on WinCE is now possible once again, although more work is required 2229to fully restore a clean build. 2230 2231=head1 Internal Changes 2232 2233=over 2234 2235=item * 2236 2237Synonyms for the misleadingly named C<av_len()> have been created: 2238C<av_top_index()> and C<av_tindex>. All three of these return the 2239number of the highest index in the array, not the number of elements it 2240contains. 2241 2242=item * 2243 2244SvUPGRADE() is no longer an expression. Originally this macro (and its 2245underlying function, sv_upgrade()) were documented as boolean, although 2246in reality they always croaked on error and never returned false. In 2005 2247the documentation was updated to specify a void return value, but 2248SvUPGRADE() was left always returning 1 for backwards compatibility. This 2249has now been removed, and SvUPGRADE() is now a statement with no return 2250value. 2251 2252So this is now a syntax error: 2253 2254 if (!SvUPGRADE(sv)) { croak(...); } 2255 2256If you have code like that, simply replace it with 2257 2258 SvUPGRADE(sv); 2259 2260or to avoid compiler warnings with older perls, possibly 2261 2262 (void)SvUPGRADE(sv); 2263 2264=item * 2265 2266Perl has a new copy-on-write mechanism that allows any SvPOK scalar to be 2267upgraded to a copy-on-write scalar. A reference count on the string buffer 2268is stored in the string buffer itself. This feature is B<not enabled by 2269default>. 2270 2271It can be enabled in a perl build by running F<Configure> with 2272B<-Accflags=-DPERL_NEW_COPY_ON_WRITE>, and we would encourage XS authors 2273to try their code with such an enabled perl, and provide feedback. 2274Unfortunately, there is not yet a good guide to updating XS code to cope 2275with COW. Until such a document is available, consult the perl5-porters 2276mailing list. 2277 2278It breaks a few XS modules by allowing copy-on-write scalars to go 2279through code paths that never encountered them before. 2280 2281=item * 2282 2283Copy-on-write no longer uses the SvFAKE and SvREADONLY flags. Hence, 2284SvREADONLY indicates a true read-only SV. 2285 2286Use the SvIsCOW macro (as before) to identify a copy-on-write scalar. 2287 2288=item * 2289 2290C<PL_glob_index> is gone. 2291 2292=item * 2293 2294The private Perl_croak_no_modify has had its context parameter removed. It is 2295now has a void prototype. Users of the public API croak_no_modify remain 2296unaffected. 2297 2298=item * 2299 2300Copy-on-write (shared hash key) scalars are no longer marked read-only. 2301C<SvREADONLY> returns false on such an SV, but C<SvIsCOW> still returns 2302true. 2303 2304=item * 2305 2306A new op type, C<OP_PADRANGE> has been introduced. The perl peephole 2307optimiser will, where possible, substitute a single padrange op for a 2308pushmark followed by one or more pad ops, and possibly also skipping list 2309and nextstate ops. In addition, the op can carry out the tasks associated 2310with the RHS of a C<< my(...) = @_ >> assignment, so those ops may be optimised 2311away too. 2312 2313=item * 2314 2315Case-insensitive matching inside a [bracketed] character class with a 2316multi-character fold no longer excludes one of the possibilities in the 2317circumstances that it used to. [perl #89774]. 2318 2319=item * 2320 2321C<PL_formfeed> has been removed. 2322 2323=item * 2324 2325The regular expression engine no longer reads one byte past the end of the 2326target string. While for all internally well-formed scalars this should 2327never have been a problem, this change facilitates clever tricks with 2328string buffers in CPAN modules. [perl #73542] 2329 2330=item * 2331 2332Inside a BEGIN block, C<PL_compcv> now points to the currently-compiling 2333subroutine, rather than the BEGIN block itself. 2334 2335=item * 2336 2337C<mg_length> has been deprecated. 2338 2339=item * 2340 2341C<sv_len> now always returns a byte count and C<sv_len_utf8> a character 2342count. Previously, C<sv_len> and C<sv_len_utf8> were both buggy and would 2343sometimes returns bytes and sometimes characters. C<sv_len_utf8> no longer 2344assumes that its argument is in UTF-8. Neither of these creates UTF-8 caches 2345for tied or overloaded values or for non-PVs any more. 2346 2347=item * 2348 2349C<sv_mortalcopy> now copies string buffers of shared hash key scalars when 2350called from XS modules [perl #79824]. 2351 2352=item * 2353 2354The new C<RXf_MODIFIES_VARS> flag can be set by custom regular expression 2355engines to indicate that the execution of the regular expression may cause 2356variables to be modified. This lets C<s///> know to skip certain 2357optimisations. Perl's own regular expression engine sets this flag for the 2358special backtracking verbs that set $REGMARK and $REGERROR. 2359 2360=item * 2361 2362The APIs for accessing lexical pads have changed considerably. 2363 2364C<PADLIST>s are now longer C<AV>s, but their own type instead. 2365C<PADLIST>s now contain a C<PAD> and a C<PADNAMELIST> of C<PADNAME>s, 2366rather than C<AV>s for the pad and the list of pad names. C<PAD>s, 2367C<PADNAMELIST>s, and C<PADNAME>s are to be accessed as such through the 2368newly added pad API instead of the plain C<AV> and C<SV> APIs. See 2369L<perlapi> for details. 2370 2371=item * 2372 2373In the regex API, the numbered capture callbacks are passed an index 2374indicating what match variable is being accessed. There are special 2375index values for the C<$`, $&, $&> variables. Previously the same three 2376values were used to retrieve C<${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}> 2377too, but these have now been assigned three separate values. See 2378L<perlreapi/Numbered capture callbacks>. 2379 2380=item * 2381 2382C<PL_sawampersand> was previously a boolean indicating that any of 2383C<$`, $&, $&> had been seen; it now contains three one-bit flags 2384indicating the presence of each of the variables individually. 2385 2386=item * 2387 2388The C<CV *> typemap entry now supports C<&{}> overloading and typeglobs, 2389just like C<&{...}> [perl #96872]. 2390 2391=item * 2392 2393The C<SVf_AMAGIC> flag to indicate overloading is now on the stash, not the 2394object. It is now set automatically whenever a method or @ISA changes, so 2395its meaning has changed, too. It now means "potentially overloaded". When 2396the overload table is calculated, the flag is automatically turned off if 2397there is no overloading, so there should be no noticeable slowdown. 2398 2399The staleness of the overload tables is now checked when overload methods 2400are invoked, rather than during C<bless>. 2401 2402"A" magic is gone. The changes to the handling of the C<SVf_AMAGIC> flag 2403eliminate the need for it. 2404 2405C<PL_amagic_generation> has been removed as no longer necessary. For XS 2406modules, it is now a macro alias to C<PL_na>. 2407 2408The fallback overload setting is now stored in a stash entry separate from 2409overloadedness itself. 2410 2411=item * 2412 2413The character-processing code has been cleaned up in places. The changes 2414should be operationally invisible. 2415 2416=item * 2417 2418The C<study> function was made a no-op in v5.16. It was simply disabled via 2419a C<return> statement; the code was left in place. Now the code supporting 2420what C<study> used to do has been removed. 2421 2422=item * 2423 2424Under threaded perls, there is no longer a separate PV allocated for every 2425COP to store its package name (C<< cop->stashpv >>). Instead, there is an 2426offset (C<< cop->stashoff >>) into the new C<PL_stashpad> array, which 2427holds stash pointers. 2428 2429=item * 2430 2431In the pluggable regex API, the C<regexp_engine> struct has acquired a new 2432field C<op_comp>, which is currently just for perl's internal use, and 2433should be initialized to NULL by other regex plugin modules. 2434 2435=item * 2436 2437A new function C<alloccopstash> has been added to the API, but is considered 2438experimental. See L<perlapi>. 2439 2440=item * 2441 2442Perl used to implement get magic in a way that would sometimes hide bugs in 2443code that could call mg_get() too many times on magical values. This hiding of 2444errors no longer occurs, so long-standing bugs may become visible now. If 2445you see magic-related errors in XS code, check to make sure it, together 2446with the Perl API functions it uses, calls mg_get() only once on SvGMAGICAL() 2447values. 2448 2449=item * 2450 2451OP allocation for CVs now uses a slab allocator. This simplifies 2452memory management for OPs allocated to a CV, so cleaning up after a 2453compilation error is simpler and safer [perl #111462][perl #112312]. 2454 2455=item * 2456 2457C<PERL_DEBUG_READONLY_OPS> has been rewritten to work with the new slab 2458allocator, allowing it to catch more violations than before. 2459 2460=item * 2461 2462The old slab allocator for ops, which was only enabled for C<PERL_IMPLICIT_SYS> 2463and C<PERL_DEBUG_READONLY_OPS>, has been retired. 2464 2465=back 2466 2467=head1 Selected Bug Fixes 2468 2469=over 4 2470 2471=item * 2472 2473Here document terminators no longer require a terminating newline character when 2474they occur at the end of a file. This was already the case at the end of a 2475string eval [perl #65838]. 2476 2477=item * 2478 2479C<-DPERL_GLOBAL_STRUCT> builds now free the global struct B<after> 2480they've finished using it. 2481 2482=item * 2483 2484A trailing '/' on a path in @INC will no longer have an additional '/' 2485appended. 2486 2487=item * 2488 2489The C<:crlf> layer now works when unread data doesn't fit into its own 2490buffer. [perl #112244]. 2491 2492=item * 2493 2494C<ungetc()> now handles UTF-8 encoded data. [perl #116322]. 2495 2496=item * 2497 2498A bug in the core typemap caused any C types that map to the T_BOOL core 2499typemap entry to not be set, updated, or modified when the T_BOOL variable was 2500used in an OUTPUT: section with an exception for RETVAL. T_BOOL in an INPUT: 2501section was not affected. Using a T_BOOL return type for an XSUB (RETVAL) 2502was not affected. A side effect of fixing this bug is, if a T_BOOL is specified 2503in the OUTPUT: section (which previous did nothing to the SV), and a read only 2504SV (literal) is passed to the XSUB, croaks like "Modification of a read-only 2505value attempted" will happen. [perl #115796] 2506 2507=item * 2508 2509On many platforms, providing a directory name as the script name caused perl 2510to do nothing and report success. It should now universally report an error 2511and exit nonzero. [perl #61362] 2512 2513=item * 2514 2515C<sort {undef} ...> under fatal warnings no longer crashes. It had 2516begun crashing in Perl v5.16. 2517 2518=item * 2519 2520Stashes blessed into each other 2521(C<bless \%Foo::, 'Bar'; bless \%Bar::, 'Foo'>) no longer result in double 2522frees. This bug started happening in Perl v5.16. 2523 2524=item * 2525 2526Numerous memory leaks have been fixed, mostly involving fatal warnings and 2527syntax errors. 2528 2529=item * 2530 2531Some failed regular expression matches such as C<'f' =~ /../g> were not 2532resetting C<pos>. Also, "match-once" patterns (C<m?...?g>) failed to reset 2533it, too, when invoked a second time [perl #23180]. 2534 2535=item * 2536 2537Several bugs involving C<local *ISA> and C<local *Foo::> causing stale 2538MRO caches have been fixed. 2539 2540=item * 2541 2542Defining a subroutine when its typeglob has been aliased no longer results 2543in stale method caches. This bug was introduced in Perl v5.10. 2544 2545=item * 2546 2547Localising a typeglob containing a subroutine when the typeglob's package 2548has been deleted from its parent stash no longer produces an error. This 2549bug was introduced in Perl v5.14. 2550 2551=item * 2552 2553Under some circumstances, C<local *method=...> would fail to reset method 2554caches upon scope exit. 2555 2556=item * 2557 2558C</[.foo.]/> is no longer an error, but produces a warning (as before) and 2559is treated as C</[.fo]/> [perl #115818]. 2560 2561=item * 2562 2563C<goto $tied_var> now calls FETCH before deciding what type of goto 2564(subroutine or label) this is. 2565 2566=item * 2567 2568Renaming packages through glob assignment 2569(C<*Foo:: = *Bar::; *Bar:: = *Baz::>) in combination with C<m?...?> and 2570C<reset> no longer makes threaded builds crash. 2571 2572=item * 2573 2574A number of bugs related to assigning a list to hash have been fixed. Many of 2575these involve lists with repeated keys like C<(1, 1, 1, 1)>. 2576 2577=over 4 2578 2579=item * 2580 2581The expression C<scalar(%h = (1, 1, 1, 1))> now returns C<4>, not C<2>. 2582 2583=item * 2584 2585The return value of C<%h = (1, 1, 1)> in list context was wrong. Previously 2586this would return C<(1, undef, 1)>, now it returns C<(1, undef)>. 2587 2588=item * 2589 2590Perl now issues the same warning on C<($s, %h) = (1, {})> as it does for 2591C<(%h) = ({})>, "Reference found where even-sized list expected". 2592 2593=item * 2594 2595A number of additional edge cases in list assignment to hashes were 2596corrected. For more details see commit 23b7025ebc. 2597 2598=back 2599 2600=item * 2601 2602Attributes applied to lexical variables no longer leak memory. 2603[perl #114764] 2604 2605=item * 2606 2607C<dump>, C<goto>, C<last>, C<next>, C<redo> or C<require> followed by a 2608bareword (or version) and then an infix operator is no longer a syntax 2609error. It used to be for those infix operators (like C<+>) that have a 2610different meaning where a term is expected. [perl #105924] 2611 2612=item * 2613 2614C<require a::b . 1> and C<require a::b + 1> no longer produce erroneous 2615ambiguity warnings. [perl #107002] 2616 2617=item * 2618 2619Class method calls are now allowed on any string, and not just strings 2620beginning with an alphanumeric character. [perl #105922] 2621 2622=item * 2623 2624An empty pattern created with C<qr//> used in C<m///> no longer triggers 2625the "empty pattern reuses last pattern" behaviour. [perl #96230] 2626 2627=item * 2628 2629Tying a hash during iteration no longer results in a memory leak. 2630 2631=item * 2632 2633Freeing a tied hash during iteration no longer results in a memory leak. 2634 2635=item * 2636 2637List assignment to a tied array or hash that dies on STORE no longer 2638results in a memory leak. 2639 2640=item * 2641 2642If the hint hash (C<%^H>) is tied, compile-time scope entry (which copies 2643the hint hash) no longer leaks memory if FETCH dies. [perl #107000] 2644 2645=item * 2646 2647Constant folding no longer inappropriately triggers the special 2648C<split " "> behaviour. [perl #94490] 2649 2650=item * 2651 2652C<defined scalar(@array)>, C<defined do { &foo }>, and similar constructs 2653now treat the argument to C<defined> as a simple scalar. [perl #97466] 2654 2655=item * 2656 2657Running a custom debugging that defines no C<*DB::DB> glob or provides a 2658subroutine stub for C<&DB::DB> no longer results in a crash, but an error 2659instead. [perl #114990] 2660 2661=item * 2662 2663C<reset ""> now matches its documentation. C<reset> only resets C<m?...?> 2664patterns when called with no argument. An empty string for an argument now 2665does nothing. (It used to be treated as no argument.) [perl #97958] 2666 2667=item * 2668 2669C<printf> with an argument returning an empty list no longer reads past the 2670end of the stack, resulting in erratic behaviour. [perl #77094] 2671 2672=item * 2673 2674C<--subname> no longer produces erroneous ambiguity warnings. 2675[perl #77240] 2676 2677=item * 2678 2679C<v10> is now allowed as a label or package name. This was inadvertently 2680broken when v-strings were added in Perl v5.6. [perl #56880] 2681 2682=item * 2683 2684C<length>, C<pos>, C<substr> and C<sprintf> could be confused by ties, 2685overloading, references and typeglobs if the stringification of such 2686changed the internal representation to or from UTF-8. [perl #114410] 2687 2688=item * 2689 2690utf8::encode now calls FETCH and STORE on tied variables. utf8::decode now 2691calls STORE (it was already calling FETCH). 2692 2693=item * 2694 2695C<$tied =~ s/$non_utf8/$utf8/> no longer loops infinitely if the tied 2696variable returns a Latin-1 string, shared hash key scalar, or reference or 2697typeglob that stringifies as ASCII or Latin-1. This was a regression from 2698v5.12. 2699 2700=item * 2701 2702C<s///> without /e is now better at detecting when it needs to forego 2703certain optimisations, fixing some buggy cases: 2704 2705=over 2706 2707=item * 2708 2709Match variables in certain constructs (C<&&>, C<||>, C<..> and others) in 2710the replacement part; e.g., C<s/(.)/$l{$a||$1}/g>. [perl #26986] 2711 2712=item * 2713 2714Aliases to match variables in the replacement. 2715 2716=item * 2717 2718C<$REGERROR> or C<$REGMARK> in the replacement. [perl #49190] 2719 2720=item * 2721 2722An empty pattern (C<s//$foo/>) that causes the last-successful pattern to 2723be used, when that pattern contains code blocks that modify the variables 2724in the replacement. 2725 2726=back 2727 2728=item * 2729 2730The taintedness of the replacement string no longer affects the taintedness 2731of the return value of C<s///e>. 2732 2733=item * 2734 2735The C<$|> autoflush variable is created on-the-fly when needed. If this 2736happened (e.g., if it was mentioned in a module or eval) when the 2737currently-selected filehandle was a typeglob with an empty IO slot, it used 2738to crash. [perl #115206] 2739 2740=item * 2741 2742Line numbers at the end of a string eval are no longer off by one. 2743[perl #114658] 2744 2745=item * 2746 2747@INC filters (subroutines returned by subroutines in @INC) that set $_ to a 2748copy-on-write scalar no longer cause the parser to modify that string 2749buffer in place. 2750 2751=item * 2752 2753C<length($object)> no longer returns the undefined value if the object has 2754string overloading that returns undef. [perl #115260] 2755 2756=item * 2757 2758The use of C<PL_stashcache>, the stash name lookup cache for method calls, has 2759been restored, 2760 2761Commit da6b625f78f5f133 in August 2011 inadvertently broke the code that looks 2762up values in C<PL_stashcache>. As it's only a cache, quite correctly everything 2763carried on working without it. 2764 2765=item * 2766 2767The error "Can't localize through a reference" had disappeared in v5.16.0 2768when C<local %$ref> appeared on the last line of an lvalue subroutine. 2769This error disappeared for C<\local %$ref> in perl v5.8.1. It has now 2770been restored. 2771 2772=item * 2773 2774The parsing of here-docs has been improved significantly, fixing several 2775parsing bugs and crashes and one memory leak, and correcting wrong 2776subsequent line numbers under certain conditions. 2777 2778=item * 2779 2780Inside an eval, the error message for an unterminated here-doc no longer 2781has a newline in the middle of it [perl #70836]. 2782 2783=item * 2784 2785A substitution inside a substitution pattern (C<s/${s|||}//>) no longer 2786confuses the parser. 2787 2788=item * 2789 2790It may be an odd place to allow comments, but C<s//"" # hello/e> has 2791always worked, I<unless> there happens to be a null character before the 2792first #. Now it works even in the presence of nulls. 2793 2794=item * 2795 2796An invalid range in C<tr///> or C<y///> no longer results in a memory leak. 2797 2798=item * 2799 2800String eval no longer treats a semicolon-delimited quote-like operator at 2801the very end (C<eval 'q;;'>) as a syntax error. 2802 2803=item * 2804 2805C<< warn {$_ => 1} + 1 >> is no longer a syntax error. The parser used to 2806get confused with certain list operators followed by an anonymous hash and 2807then an infix operator that shares its form with a unary operator. 2808 2809=item * 2810 2811C<(caller $n)[6]> (which gives the text of the eval) used to return the 2812actual parser buffer. Modifying it could result in crashes. Now it always 2813returns a copy. The string returned no longer has "\n;" tacked on to the 2814end. The returned text also includes here-doc bodies, which used to be 2815omitted. 2816 2817=item * 2818 2819The UTF-8 position cache is now reset when accessing magical variables, to 2820avoid the string buffer and the UTF-8 position cache getting out of sync 2821[perl #114410]. 2822 2823=item * 2824 2825Various cases of get magic being called twice for magical UTF-8 2826strings have been fixed. 2827 2828=item * 2829 2830This code (when not in the presence of C<$&> etc) 2831 2832 $_ = 'x' x 1_000_000; 2833 1 while /(.)/; 2834 2835used to skip the buffer copy for performance reasons, but suffered from C<$1> 2836etc changing if the original string changed. That's now been fixed. 2837 2838=item * 2839 2840Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO 2841might attempt to allocate more memory. 2842 2843=item * 2844 2845In a regular expression, if something is quantified with C<{n,m}> where 2846C<S<n E<gt> m>>, it can't possibly match. Previously this was a fatal 2847error, but now is merely a warning (and that something won't match). 2848[perl #82954]. 2849 2850=item * 2851 2852It used to be possible for formats defined in subroutines that have 2853subsequently been undefined and redefined to close over variables in the 2854wrong pad (the newly-defined enclosing sub), resulting in crashes or 2855"Bizarre copy" errors. 2856 2857=item * 2858 2859Redefinition of XSUBs at run time could produce warnings with the wrong 2860line number. 2861 2862=item * 2863 2864The %vd sprintf format does not support version objects for alpha versions. 2865It used to output the format itself (%vd) when passed an alpha version, and 2866also emit an "Invalid conversion in printf" warning. It no longer does, 2867but produces the empty string in the output. It also no longer leaks 2868memory in this case. 2869 2870=item * 2871 2872C<< $obj->SUPER::method >> calls in the main package could fail if the 2873SUPER package had already been accessed by other means. 2874 2875=item * 2876 2877Stash aliasing (C<< *foo:: = *bar:: >>) no longer causes SUPER calls to ignore 2878changes to methods or @ISA or use the wrong package. 2879 2880=item * 2881 2882Method calls on packages whose names end in ::SUPER are no longer treated 2883as SUPER method calls, resulting in failure to find the method. 2884Furthermore, defining subroutines in such packages no longer causes them to 2885be found by SUPER method calls on the containing package [perl #114924]. 2886 2887=item * 2888 2889C<\w> now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D 2890(ZERO WIDTH JOINER). C<\W> no longer matches these. This change is because 2891Unicode corrected their definition of what C<\w> should match. 2892 2893=item * 2894 2895C<dump LABEL> no longer leaks its label. 2896 2897=item * 2898 2899Constant folding no longer changes the behaviour of functions like C<stat()> 2900and C<truncate()> that can take either filenames or handles. 2901C<stat 1 ? foo : bar> nows treats its argument as a file name (since it is an 2902arbitrary expression), rather than the handle "foo". 2903 2904=item * 2905 2906C<truncate FOO, $len> no longer falls back to treating "FOO" as a file name if 2907the filehandle has been deleted. This was broken in Perl v5.16.0. 2908 2909=item * 2910 2911Subroutine redefinitions after sub-to-glob and glob-to-glob assignments no 2912longer cause double frees or panic messages. 2913 2914=item * 2915 2916C<s///> now turns vstrings into plain strings when performing a substitution, 2917even if the resulting string is the same (C<s/a/a/>). 2918 2919=item * 2920 2921Prototype mismatch warnings no longer erroneously treat constant subs as having 2922no prototype when they actually have "". 2923 2924=item * 2925 2926Constant subroutines and forward declarations no longer prevent prototype 2927mismatch warnings from omitting the sub name. 2928 2929=item * 2930 2931C<undef> on a subroutine now clears call checkers. 2932 2933=item * 2934 2935The C<ref> operator started leaking memory on blessed objects in Perl v5.16.0. 2936This has been fixed [perl #114340]. 2937 2938=item * 2939 2940C<use> no longer tries to parse its arguments as a statement, making 2941C<use constant { () };> a syntax error [perl #114222]. 2942 2943=item * 2944 2945On debugging builds, "uninitialized" warnings inside formats no longer cause 2946assertion failures. 2947 2948=item * 2949 2950On debugging builds, subroutines nested inside formats no longer cause 2951assertion failures [perl #78550]. 2952 2953=item * 2954 2955Formats and C<use> statements are now permitted inside formats. 2956 2957=item * 2958 2959C<print $x> and C<sub { print $x }-E<gt>()> now always produce the same output. 2960It was possible for the latter to refuse to close over $x if the variable was 2961not active; e.g., if it was defined outside a currently-running named 2962subroutine. 2963 2964=item * 2965 2966Similarly, C<print $x> and C<print eval '$x'> now produce the same output. 2967This also allows "my $x if 0" variables to be seen in the debugger [perl 2968#114018]. 2969 2970=item * 2971 2972Formats called recursively no longer stomp on their own lexical variables, but 2973each recursive call has its own set of lexicals. 2974 2975=item * 2976 2977Attempting to free an active format or the handle associated with it no longer 2978results in a crash. 2979 2980=item * 2981 2982Format parsing no longer gets confused by braces, semicolons and low-precedence 2983operators. It used to be possible to use braces as format delimiters (instead 2984of C<=> and C<.>), but only sometimes. Semicolons and low-precedence operators 2985in format argument lines no longer confuse the parser into ignoring the line's 2986return value. In format argument lines, braces can now be used for anonymous 2987hashes, instead of being treated always as C<do> blocks. 2988 2989=item * 2990 2991Formats can now be nested inside code blocks in regular expressions and other 2992quoted constructs (C</(?{...})/> and C<qq/${...}/>) [perl #114040]. 2993 2994=item * 2995 2996Formats are no longer created after compilation errors. 2997 2998=item * 2999 3000Under debugging builds, the B<-DA> command line option started crashing in Perl 3001v5.16.0. It has been fixed [perl #114368]. 3002 3003=item * 3004 3005A potential deadlock scenario involving the premature termination of a pseudo- 3006forked child in a Windows build with ithreads enabled has been fixed. This 3007resolves the common problem of the F<t/op/fork.t> test hanging on Windows [perl 3008#88840]. 3009 3010=item * 3011 3012The code which generates errors from C<require()> could potentially read one or 3013two bytes before the start of the filename for filenames less than three bytes 3014long and ending C</\.p?\z/>. This has now been fixed. Note that it could 3015never have happened with module names given to C<use()> or C<require()> anyway. 3016 3017=item * 3018 3019The handling of pathnames of modules given to C<require()> has been made 3020thread-safe on VMS. 3021 3022=item * 3023 3024Non-blocking sockets have been fixed on VMS. 3025 3026=item * 3027 3028Pod can now be nested in code inside a quoted construct outside of a string 3029eval. This used to work only within string evals [perl #114040]. 3030 3031=item * 3032 3033C<goto ''> now looks for an empty label, producing the "goto must have 3034label" error message, instead of exiting the program [perl #111794]. 3035 3036=item * 3037 3038C<goto "\0"> now dies with "Can't find label" instead of "goto must have 3039label". 3040 3041=item * 3042 3043The C function C<hv_store> used to result in crashes when used on C<%^H> 3044[perl #111000]. 3045 3046=item * 3047 3048A call checker attached to a closure prototype via C<cv_set_call_checker> 3049is now copied to closures cloned from it. So C<cv_set_call_checker> now 3050works inside an attribute handler for a closure. 3051 3052=item * 3053 3054Writing to C<$^N> used to have no effect. Now it croaks with "Modification 3055of a read-only value" by default, but that can be overridden by a custom 3056regular expression engine, as with C<$1> [perl #112184]. 3057 3058=item * 3059 3060C<undef> on a control character glob (C<undef *^H>) no longer emits an 3061erroneous warning about ambiguity [perl #112456]. 3062 3063=item * 3064 3065For efficiency's sake, many operators and built-in functions return the 3066same scalar each time. Lvalue subroutines and subroutines in the CORE:: 3067namespace were allowing this implementation detail to leak through. 3068C<print &CORE::uc("a"), &CORE::uc("b")> used to print "BB". The same thing 3069would happen with an lvalue subroutine returning the return value of C<uc>. 3070Now the value is copied in such cases. 3071 3072=item * 3073 3074C<method {}> syntax with an empty block or a block returning an empty list 3075used to crash or use some random value left on the stack as its invocant. 3076Now it produces an error. 3077 3078=item * 3079 3080C<vec> now works with extremely large offsets (E<gt>2 GB) [perl #111730]. 3081 3082=item * 3083 3084Changes to overload settings now take effect immediately, as do changes to 3085inheritance that affect overloading. They used to take effect only after 3086C<bless>. 3087 3088Objects that were created before a class had any overloading used to remain 3089non-overloaded even if the class gained overloading through C<use overload> 3090or @ISA changes, and even after C<bless>. This has been fixed 3091[perl #112708]. 3092 3093=item * 3094 3095Classes with overloading can now inherit fallback values. 3096 3097=item * 3098 3099Overloading was not respecting a fallback value of 0 if there were 3100overloaded objects on both sides of an assignment operator like C<+=> 3101[perl #111856]. 3102 3103=item * 3104 3105C<pos> now croaks with hash and array arguments, instead of producing 3106erroneous warnings. 3107 3108=item * 3109 3110C<while(each %h)> now implies C<while(defined($_ = each %h))>, like 3111C<readline> and C<readdir>. 3112 3113=item * 3114 3115Subs in the CORE:: namespace no longer crash after C<undef *_> when called 3116with no argument list (C<&CORE::time> with no parentheses). 3117 3118=item * 3119 3120C<unpack> no longer produces the "'/' must follow a numeric type in unpack" 3121error when it is the data that are at fault [perl #60204]. 3122 3123=item * 3124 3125C<join> and C<"@array"> now call FETCH only once on a tied C<$"> 3126[perl #8931]. 3127 3128=item * 3129 3130Some subroutine calls generated by compiling core ops affected by a 3131C<CORE::GLOBAL> override had op checking performed twice. The checking 3132is always idempotent for pure Perl code, but the double checking can 3133matter when custom call checkers are involved. 3134 3135=item * 3136 3137A race condition used to exist around fork that could cause a signal sent to 3138the parent to be handled by both parent and child. Signals are now blocked 3139briefly around fork to prevent this from happening [perl #82580]. 3140 3141=item * 3142 3143The implementation of code blocks in regular expressions, such as C<(?{})> 3144and C<(??{})>, has been heavily reworked to eliminate a whole slew of bugs. 3145The main user-visible changes are: 3146 3147=over 4 3148 3149=item * 3150 3151Code blocks within patterns are now parsed in the same pass as the 3152surrounding code; in particular it is no longer necessary to have balanced 3153braces: this now works: 3154 3155 /(?{ $x='{' })/ 3156 3157This means that this error message is no longer generated: 3158 3159 Sequence (?{...}) not terminated or not {}-balanced in regex 3160 3161but a new error may be seen: 3162 3163 Sequence (?{...}) not terminated with ')' 3164 3165In addition, literal code blocks within run-time patterns are only 3166compiled once, at perl compile-time: 3167 3168 for my $p (...) { 3169 # this 'FOO' block of code is compiled once, 3170 # at the same time as the surrounding 'for' loop 3171 /$p{(?{FOO;})/; 3172 } 3173 3174=item * 3175 3176Lexical variables are now sane as regards scope, recursion and closure 3177behavior. In particular, C</A(?{B})C/> behaves (from a closure viewpoint) 3178exactly like C</A/ && do { B } && /C/>, while C<qr/A(?{B})C/> is like 3179C<sub {/A/ && do { B } && /C/}>. So this code now works how you might 3180expect, creating three regexes that match 0, 1, and 2: 3181 3182 for my $i (0..2) { 3183 push @r, qr/^(??{$i})$/; 3184 } 3185 "1" =~ $r[1]; # matches 3186 3187=item * 3188 3189The C<use re 'eval'> pragma is now only required for code blocks defined 3190at runtime; in particular in the following, the text of the C<$r> pattern is 3191still interpolated into the new pattern and recompiled, but the individual 3192compiled code-blocks within C<$r> are reused rather than being recompiled, 3193and C<use re 'eval'> isn't needed any more: 3194 3195 my $r = qr/abc(?{....})def/; 3196 /xyz$r/; 3197 3198=item * 3199 3200Flow control operators no longer crash. Each code block runs in a new 3201dynamic scope, so C<next> etc. will not see 3202any enclosing loops. C<return> returns a value 3203from the code block, not from any enclosing subroutine. 3204 3205=item * 3206 3207Perl normally caches the compilation of run-time patterns, and doesn't 3208recompile if the pattern hasn't changed, but this is now disabled if 3209required for the correct behavior of closures. For example: 3210 3211 my $code = '(??{$x})'; 3212 for my $x (1..3) { 3213 # recompile to see fresh value of $x each time 3214 $x =~ /$code/; 3215 } 3216 3217=item * 3218 3219The C</msix> and C<(?msix)> etc. flags are now propagated into the return 3220value from C<(??{})>; this now works: 3221 3222 "AB" =~ /a(??{'b'})/i; 3223 3224=item * 3225 3226Warnings and errors will appear to come from the surrounding code (or for 3227run-time code blocks, from an eval) rather than from an C<re_eval>: 3228 3229 use re 'eval'; $c = '(?{ warn "foo" })'; /$c/; 3230 /(?{ warn "foo" })/; 3231 3232formerly gave: 3233 3234 foo at (re_eval 1) line 1. 3235 foo at (re_eval 2) line 1. 3236 3237and now gives: 3238 3239 foo at (eval 1) line 1. 3240 foo at /some/prog line 2. 3241 3242=back 3243 3244=item * 3245 3246Perl now can be recompiled to use any Unicode version. In v5.16, it 3247worked on Unicodes 6.0 and 6.1, but there were various bugs if earlier 3248releases were used; the older the release the more problems. 3249 3250=item * 3251 3252C<vec> no longer produces "uninitialized" warnings in lvalue context 3253[perl #9423]. 3254 3255=item * 3256 3257An optimization involving fixed strings in regular expressions could cause 3258a severe performance penalty in edge cases. This has been fixed 3259[perl #76546]. 3260 3261=item * 3262 3263In certain cases, including empty subpatterns within a regular expression (such 3264as C<(?:)> or C<(?:|)>) could disable some optimizations. This has been fixed. 3265 3266=item * 3267 3268The "Can't find an opnumber" message that C<prototype> produces when passed 3269a string like "CORE::nonexistent_keyword" now passes UTF-8 and embedded 3270NULs through unchanged [perl #97478]. 3271 3272=item * 3273 3274C<prototype> now treats magical variables like C<$1> the same way as 3275non-magical variables when checking for the CORE:: prefix, instead of 3276treating them as subroutine names. 3277 3278=item * 3279 3280Under threaded perls, a runtime code block in a regular expression could 3281corrupt the package name stored in the op tree, resulting in bad reads 3282in C<caller>, and possibly crashes [perl #113060]. 3283 3284=item * 3285 3286Referencing a closure prototype (C<\&{$_[1]}> in an attribute handler for a 3287closure) no longer results in a copy of the subroutine (or assertion 3288failures on debugging builds). 3289 3290=item * 3291 3292C<eval '__PACKAGE__'> now returns the right answer on threaded builds if 3293the current package has been assigned over (as in 3294C<*ThisPackage:: = *ThatPackage::>) [perl #78742]. 3295 3296=item * 3297 3298If a package is deleted by code that it calls, it is possible for C<caller> 3299to see a stack frame belonging to that deleted package. C<caller> could 3300crash if the stash's memory address was reused for a scalar and a 3301substitution was performed on the same scalar [perl #113486]. 3302 3303=item * 3304 3305C<UNIVERSAL::can> no longer treats its first argument differently 3306depending on whether it is a string or number internally. 3307 3308=item * 3309 3310C<open> with C<< <& >> for the mode checks to see whether the third argument is 3311a number, in determining whether to treat it as a file descriptor or a handle 3312name. Magical variables like C<$1> were always failing the numeric check and 3313being treated as handle names. 3314 3315=item * 3316 3317C<warn>'s handling of magical variables (C<$1>, ties) has undergone several 3318fixes. C<FETCH> is only called once now on a tied argument or a tied C<$@> 3319[perl #97480]. Tied variables returning objects that stringify as "" are 3320no longer ignored. A tied C<$@> that happened to return a reference the 3321I<previous> time it was used is no longer ignored. 3322 3323=item * 3324 3325C<warn ""> now treats C<$@> with a number in it the same way, regardless of 3326whether it happened via C<$@=3> or C<$@="3">. It used to ignore the 3327former. Now it appends "\t...caught", as it has always done with 3328C<$@="3">. 3329 3330=item * 3331 3332Numeric operators on magical variables (e.g., S<C<$1 + 1>>) used to use 3333floating point operations even where integer operations were more appropriate, 3334resulting in loss of accuracy on 64-bit platforms [perl #109542]. 3335 3336=item * 3337 3338Unary negation no longer treats a string as a number if the string happened 3339to be used as a number at some point. So, if C<$x> contains the string "dogs", 3340C<-$x> returns "-dogs" even if C<$y=0+$x> has happened at some point. 3341 3342=item * 3343 3344In Perl v5.14, C<-'-10'> was fixed to return "10", not "+10". But magical 3345variables (C<$1>, ties) were not fixed till now [perl #57706]. 3346 3347=item * 3348 3349Unary negation now treats strings consistently, regardless of the internal 3350C<UTF8> flag. 3351 3352=item * 3353 3354A regression introduced in Perl v5.16.0 involving 3355C<tr/I<SEARCHLIST>/I<REPLACEMENTLIST>/> has been fixed. Only the first 3356instance is supposed to be meaningful if a character appears more than 3357once in C<I<SEARCHLIST>>. Under some circumstances, the final instance 3358was overriding all earlier ones. [perl #113584] 3359 3360=item * 3361 3362Regular expressions like C<qr/\87/> previously silently inserted a NUL 3363character, thus matching as if it had been written C<qr/\00087/>. Now it 3364matches as if it had been written as C<qr/87/>, with a message that the 3365sequence C<"\8"> is unrecognized. 3366 3367=item * 3368 3369C<__SUB__> now works in special blocks (C<BEGIN>, C<END>, etc.). 3370 3371=item * 3372 3373Thread creation on Windows could theoretically result in a crash if done 3374inside a C<BEGIN> block. It still does not work properly, but it no longer 3375crashes [perl #111610]. 3376 3377=item * 3378 3379C<\&{''}> (with the empty string) now autovivifies a stub like any other 3380sub name, and no longer produces the "Unable to create sub" error 3381[perl #94476]. 3382 3383=item * 3384 3385A regression introduced in v5.14.0 has been fixed, in which some calls 3386to the C<re> module would clobber C<$_> [perl #113750]. 3387 3388=item * 3389 3390C<do FILE> now always either sets or clears C<$@>, even when the file can't be 3391read. This ensures that testing C<$@> first (as recommended by the 3392documentation) always returns the correct result. 3393 3394=item * 3395 3396The array iterator used for the C<each @array> construct is now correctly 3397reset when C<@array> is cleared [perl #75596]. This happens, for example, when 3398the array is globally assigned to, as in C<@array = (...)>, but not when its 3399B<values> are assigned to. In terms of the XS API, it means that C<av_clear()> 3400will now reset the iterator. 3401 3402This mirrors the behaviour of the hash iterator when the hash is cleared. 3403 3404=item * 3405 3406C<< $class->can >>, C<< $class->isa >>, and C<< $class->DOES >> now return 3407correct results, regardless of whether that package referred to by C<$class> 3408exists [perl #47113]. 3409 3410=item * 3411 3412Arriving signals no longer clear C<$@> [perl #45173]. 3413 3414=item * 3415 3416Allow C<my ()> declarations with an empty variable list [perl #113554]. 3417 3418=item * 3419 3420During parsing, subs declared after errors no longer leave stubs 3421[perl #113712]. 3422 3423=item * 3424 3425Closures containing no string evals no longer hang on to their containing 3426subroutines, allowing variables closed over by outer subroutines to be 3427freed when the outer sub is freed, even if the inner sub still exists 3428[perl #89544]. 3429 3430=item * 3431 3432Duplication of in-memory filehandles by opening with a "<&=" or ">&=" mode 3433stopped working properly in v5.16.0. It was causing the new handle to 3434reference a different scalar variable. This has been fixed [perl #113764]. 3435 3436=item * 3437 3438C<qr//> expressions no longer crash with custom regular expression engines 3439that do not set C<offs> at regular expression compilation time 3440[perl #112962]. 3441 3442=item * 3443 3444C<delete local> no longer crashes with certain magical arrays and hashes 3445[perl #112966]. 3446 3447=item * 3448 3449C<local> on elements of certain magical arrays and hashes used not to 3450arrange to have the element deleted on scope exit, even if the element did 3451not exist before C<local>. 3452 3453=item * 3454 3455C<scalar(write)> no longer returns multiple items [perl #73690]. 3456 3457=item * 3458 3459String to floating point conversions no longer misparse certain strings under 3460C<use locale> [perl #109318]. 3461 3462=item * 3463 3464C<@INC> filters that die no longer leak memory [perl #92252]. 3465 3466=item * 3467 3468The implementations of overloaded operations are now called in the correct 3469context. This allows, among other things, being able to properly override 3470C<< <> >> [perl #47119]. 3471 3472=item * 3473 3474Specifying only the C<fallback> key when calling C<use overload> now behaves 3475properly [perl #113010]. 3476 3477=item * 3478 3479C<< sub foo { my $a = 0; while ($a) { ... } } >> and 3480C<< sub foo { while (0) { ... } } >> now return the same thing [perl #73618]. 3481 3482=item * 3483 3484String negation now behaves the same under C<use integer;> as it does 3485without [perl #113012]. 3486 3487=item * 3488 3489C<chr> now returns the Unicode replacement character (U+FFFD) for -1, 3490regardless of the internal representation. -1 used to wrap if the argument 3491was tied or a string internally. 3492 3493=item * 3494 3495Using a C<format> after its enclosing sub was freed could crash as of 3496perl v5.12.0, if the format referenced lexical variables from the outer sub. 3497 3498=item * 3499 3500Using a C<format> after its enclosing sub was undefined could crash as of 3501perl v5.10.0, if the format referenced lexical variables from the outer sub. 3502 3503=item * 3504 3505Using a C<format> defined inside a closure, which format references 3506lexical variables from outside, never really worked unless the C<write> 3507call was directly inside the closure. In v5.10.0 it even started crashing. 3508Now the copy of that closure nearest the top of the call stack is used to 3509find those variables. 3510 3511=item * 3512 3513Formats that close over variables in special blocks no longer crash if a 3514stub exists with the same name as the special block before the special 3515block is compiled. 3516 3517=item * 3518 3519The parser no longer gets confused, treating C<eval foo ()> as a syntax 3520error if preceded by C<print;> [perl #16249]. 3521 3522=item * 3523 3524The return value of C<syscall> is no longer truncated on 64-bit platforms 3525[perl #113980]. 3526 3527=item * 3528 3529Constant folding no longer causes C<print 1 ? FOO : BAR> to print to the 3530FOO handle [perl #78064]. 3531 3532=item * 3533 3534C<do subname> now calls the named subroutine and uses the file name it 3535returns, instead of opening a file named "subname". 3536 3537=item * 3538 3539Subroutines looked up by rv2cv check hooks (registered by XS modules) are 3540now taken into consideration when determining whether C<foo bar> should be 3541the sub call C<foo(bar)> or the method call C<< "bar"->foo >>. 3542 3543=item * 3544 3545C<CORE::foo::bar> is no longer treated specially, allowing global overrides 3546to be called directly via C<CORE::GLOBAL::uc(...)> [perl #113016]. 3547 3548=item * 3549 3550Calling an undefined sub whose typeglob has been undefined now produces the 3551customary "Undefined subroutine called" error, instead of "Not a CODE 3552reference". 3553 3554=item * 3555 3556Two bugs involving @ISA have been fixed. C<*ISA = *glob_without_array> and 3557C<undef *ISA; @{*ISA}> would prevent future modifications to @ISA from 3558updating the internal caches used to look up methods. The 3559*glob_without_array case was a regression from Perl v5.12. 3560 3561=item * 3562 3563Regular expression optimisations sometimes caused C<$> with C</m> to 3564produce failed or incorrect matches [perl #114068]. 3565 3566=item * 3567 3568C<__SUB__> now works in a C<sort> block when the enclosing subroutine is 3569predeclared with C<sub foo;> syntax [perl #113710]. 3570 3571=item * 3572 3573Unicode properties only apply to Unicode code points, which leads to 3574some subtleties when regular expressions are matched against 3575above-Unicode code points. There is a warning generated to draw your 3576attention to this. However, this warning was being generated 3577inappropriately in some cases, such as when a program was being parsed. 3578Non-Unicode matches such as C<\w> and C<[:word:]> should not generate the 3579warning, as their definitions don't limit them to apply to only Unicode 3580code points. Now the message is only generated when matching against 3581C<\p{}> and C<\P{}>. There remains a bug, [perl #114148], for the very 3582few properties in Unicode that match just a single code point. The 3583warning is not generated if they are matched against an above-Unicode 3584code point. 3585 3586=item * 3587 3588Uninitialized warnings mentioning hash elements would only mention the 3589element name if it was not in the first bucket of the hash, due to an 3590off-by-one error. 3591 3592=item * 3593 3594A regular expression optimizer bug could cause multiline "^" to behave 3595incorrectly in the presence of line breaks, such that 3596C<"/\n\n" =~ m#\A(?:^/$)#im> would not match [perl #115242]. 3597 3598=item * 3599 3600Failed C<fork> in list context no longer corrupts the stack. 3601C<@a = (1, 2, fork, 3)> used to gobble up the 2 and assign C<(1, undef, 3)> 3602if the C<fork> call failed. 3603 3604=item * 3605 3606Numerous memory leaks have been fixed, mostly involving tied variables that 3607die, regular expression character classes and code blocks, and syntax 3608errors. 3609 3610=item * 3611 3612Assigning a regular expression (C<${qr//}>) to a variable that happens to 3613hold a floating point number no longer causes assertion failures on 3614debugging builds. 3615 3616=item * 3617 3618Assigning a regular expression to a scalar containing a number no longer 3619causes subsequent numification to produce random numbers. 3620 3621=item * 3622 3623Assigning a regular expression to a magic variable no longer wipes away the 3624magic. This was a regression from v5.10. 3625 3626=item * 3627 3628Assigning a regular expression to a blessed scalar no longer results in 3629crashes. This was also a regression from v5.10. 3630 3631=item * 3632 3633Regular expression can now be assigned to tied hash and array elements with 3634flattening into strings. 3635 3636=item * 3637 3638Numifying a regular expression no longer results in an uninitialized 3639warning. 3640 3641=item * 3642 3643Negative array indices no longer cause EXISTS methods of tied variables to 3644be ignored. This was a regression from v5.12. 3645 3646=item * 3647 3648Negative array indices no longer result in crashes on arrays tied to 3649non-objects. 3650 3651=item * 3652 3653C<$byte_overload .= $utf8> no longer results in doubly-encoded UTF-8 if the 3654left-hand scalar happened to have produced a UTF-8 string the last time 3655overloading was invoked. 3656 3657=item * 3658 3659C<goto &sub> now uses the current value of @_, instead of using the array 3660the subroutine was originally called with. This means 3661C<local @_ = (...); goto &sub> now works [perl #43077]. 3662 3663=item * 3664 3665If a debugger is invoked recursively, it no longer stomps on its own 3666lexical variables. Formerly under recursion all calls would share the same 3667set of lexical variables [perl #115742]. 3668 3669=item * 3670 3671C<*_{ARRAY}> returned from a subroutine no longer spontaneously 3672becomes empty. 3673 3674=item * 3675 3676When using C<say> to print to a tied filehandle, the value of C<$\> is 3677correctly localized, even if it was previously undef. [perl #119927] 3678 3679=back 3680 3681=head1 Known Problems 3682 3683=over 4 3684 3685=item * 3686 3687UTF8-flagged strings in C<%ENV> on HP-UX 11.00 are buggy 3688 3689The interaction of UTF8-flagged strings and C<%ENV> on HP-UX 11.00 is 3690currently dodgy in some not-yet-fully-diagnosed way. Expect test 3691failures in F<t/op/magic.t>, followed by unknown behavior when storing 3692wide characters in the environment. 3693 3694=back 3695 3696=head1 Obituary 3697 3698Hojung Yoon (AMORETTE), 24, of Seoul, South Korea, went to his long rest 3699on May 8, 2013 with llama figurine and autographed TIMTOADY card. He 3700was a brilliant young Perl 5 & 6 hacker and a devoted member of 3701Seoul.pm. He programmed Perl, talked Perl, ate Perl, and loved Perl. We 3702believe that he is still programming in Perl with his broken IBM laptop 3703somewhere. He will be missed. 3704 3705=head1 Acknowledgements 3706 3707Perl v5.18.0 represents approximately 12 months of development since 3708Perl v5.16.0 and contains approximately 400,000 lines of changes across 37092,100 files from 113 authors. 3710 3711Perl continues to flourish into its third decade thanks to a vibrant 3712community of users and developers. The following people are known to 3713have contributed the improvements that became Perl v5.18.0: 3714 3715Aaron Crane, Aaron Trevena, Abhijit Menon-Sen, Adrian M. Enache, Alan 3716Haggai Alavi, Alexandr Ciornii, Andrew Tam, Andy Dougherty, Anton Nikishaev, 3717Aristotle Pagaltzis, Augustina Blair, Bob Ernst, Brad Gilbert, Breno G. de 3718Oliveira, Brian Carlson, Brian Fraser, Charlie Gonzalez, Chip Salzenberg, Chris 3719'BinGOs' Williams, Christian Hansen, Colin Kuskie, Craig A. Berry, Dagfinn 3720Ilmari Mannsåker, Daniel Dragan, Daniel Perrett, Darin McBride, Dave Rolsky, 3721David Golden, David Leadbeater, David Mitchell, David Nicol, Dominic 3722Hargreaves, E. Choroba, Eric Brine, Evan Miller, Father Chrysostomos, Florian 3723Ragwitz, François Perrad, George Greer, Goro Fuji, H.Merijn Brand, Herbert 3724Breunung, Hugo van der Sanden, Igor Zaytsev, James E Keenan, Jan Dubois, 3725Jasmine Ahuja, Jerry D. Hedden, Jess Robinson, Jesse Luehrs, Joaquin Ferrero, 3726Joel Berger, John Goodyear, John Peacock, Karen Etheridge, Karl Williamson, 3727Karthik Rajagopalan, Kent Fredric, Leon Timmermans, Lucas Holt, Lukas Mai, 3728Marcus Holland-Moritz, Markus Jansen, Martin Hasch, Matthew Horsfall, Max 3729Maischein, Michael G Schwern, Michael Schroeder, Moritz Lenz, Nicholas Clark, 3730Niko Tyni, Oleg Nesterov, Patrik Hägglund, Paul Green, Paul Johnson, Paul 3731Marquess, Peter Martini, Rafael Garcia-Suarez, Reini Urban, Renee Baecker, 3732Rhesa Rozendaal, Ricardo Signes, Robin Barker, Ronald J. Kimball, Ruslan 3733Zakirov, Salvador Fandiño, Sawyer X, Scott Lanning, Sergey Alekseev, Shawn M 3734Moore, Shirakata Kentaro, Shlomi Fish, Sisyphus, Smylers, Steffen Müller, 3735Steve Hay, Steve Peters, Steven Schubiger, Sullivan Beck, Sven Strickroth, 3736Sébastien Aperghis-Tramoni, Thomas Sibley, Tobias Leich, Tom Wyant, Tony Cook, 3737Vadim Konovalov, Vincent Pit, Volker Schatz, Walt Mankowski, Yves Orton, 3738Zefram. 3739 3740The list above is almost certainly incomplete as it is automatically generated 3741from version control history. In particular, it does not include the names of 3742the (very much appreciated) contributors who reported issues to the Perl bug 3743tracker. 3744 3745Many of the changes included in this version originated in the CPAN modules 3746included in Perl's core. We're grateful to the entire CPAN community for 3747helping Perl to flourish. 3748 3749For a more complete list of all of Perl's historical contributors, please see 3750the F<AUTHORS> file in the Perl source distribution. 3751 3752=head1 Reporting Bugs 3753 3754If you find what you think is a bug, you might check the articles recently 3755posted to the comp.lang.perl.misc newsgroup and the perl bug database at 3756http://rt.perl.org/perlbug/ . There may also be information at 3757http://www.perl.org/ , the Perl Home Page. 3758 3759If you believe you have an unreported bug, please run the L<perlbug> program 3760included with your release. Be sure to trim your bug down to a tiny but 3761sufficient test case. Your bug report, along with the output of C<perl -V>, 3762will be sent off to perlbug@perl.org to be analysed by the Perl porting team. 3763 3764If the bug you are reporting has security implications, which make it 3765inappropriate to send to a publicly archived mailing list, then please send it 3766to perl5-security-report@perl.org. This points to a closed subscription 3767unarchived mailing list, which includes all the core committers, who will be 3768able to help assess the impact of issues, figure out a resolution, and help 3769co-ordinate the release of patches to mitigate or fix the problem across all 3770platforms on which Perl is supported. Please only use this address for 3771security issues in the Perl core, not for modules independently distributed on 3772CPAN. 3773 3774=head1 SEE ALSO 3775 3776The F<Changes> file for an explanation of how to view exhaustive details on 3777what changed. 3778 3779The F<INSTALL> file for how to build Perl. 3780 3781The F<README> file for general stuff. 3782 3783The F<Artistic> and F<Copying> files for copyright information. 3784 3785=cut 3786