From e9912eaa0d41601b26148905695843546b1f57d0 Mon Sep 17 00:00:00 2001 From: Ricardo Signes Date: Sat, 18 May 2013 09:51:49 -0400 Subject: bump the perldelta version --- pod/perl5180delta.pod | 3781 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3781 insertions(+) create mode 100644 pod/perl5180delta.pod (limited to 'pod/perl5180delta.pod') diff --git a/pod/perl5180delta.pod b/pod/perl5180delta.pod new file mode 100644 index 0000000000..cc9d4cb4b8 --- /dev/null +++ b/pod/perl5180delta.pod @@ -0,0 +1,3781 @@ +=encoding utf8 + +=head1 NAME + +perl5180delta - what is new for perl v5.18.0 + +=head1 DESCRIPTION + +This document describes differences between the v5.16.0 release and the v5.18.0 +release. + +If you are upgrading from an earlier release such as v5.14.0, first read +L, which describes differences between v5.14.0 and v5.16.0. + +=head1 Core Enhancements + +=head2 New mechanism for experimental features + +Newly-added experimental features will now require this incantation: + + no warnings "experimental::feature_name"; + use feature "feature_name"; # would warn without the prev line + +There is a new warnings category, called "experimental", containing +warnings that the L pragma emits when enabling experimental +features. + +Newly-added experimental features will also be given special warning IDs, +which consist of "experimental::" followed by the name of the feature. (The +plan is to extend this mechanism eventually to all warnings, to allow them +to be enabled or disabled individually, and not just by category.) + +By saying + + no warnings "experimental::feature_name"; + +you are taking responsibility for any breakage that future changes to, or +removal of, the feature may cause. + +Since some features (like C<~~> or C) now emit experimental warnings, +and you may want to disable them in code that is also run on perls that do not +recognize these warning categories, consider using the C pragma like this: + + no if $] >= 5.018, 'warnings', "experimental::feature_name"; + +Existing experimental features may begin emitting these warnings, too. Please +consult L for information on which features are considered +experimental. + +=head2 Hash overhaul + +Changes to the implementation of hashes in perl v5.18.0 will be one of the most +visible changes to the behavior of existing code. + +By default, two distinct hash variables with identical keys and values may now +provide their contents in a different order where it was previously identical. + +When encountering these changes, the key to cleaning up from them is to accept +that B and to act accordingly. + +=head3 Hash randomization + +The seed used by Perl's hash function is now random. This means that the +order which keys/values will be returned from functions like C, +C, and C will differ from run to run. + +This change was introduced to make Perl's hashes more robust to algorithmic +complexity attacks, and also because we discovered that it exposes hash +ordering dependency bugs and makes them easier to track down. + +Toolchain maintainers might want to invest in additional infrastructure to +test for things like this. Running tests several times in a row and then +comparing results will make it easier to spot hash order dependencies in +code. Authors are strongly encouraged not to expose the key order of +Perl's hashes to insecure audiences. + +Further, every hash has its own iteration order, which should make it much +more difficult to determine what the current hash seed is. + +=head3 New hash functions + +Perl v5.18 includes support for multiple hash functions, and changed +the default (to ONE_AT_A_TIME_HARD), you can choose a different +algorithm by defining a symbol at compile time. For a current list, +consult the F document. Note that as of Perl v5.18 we can +only recommend use of the default or SIPHASH. All the others are +known to have security issues and are for research purposes only. + +=head3 PERL_HASH_SEED environment variable now takes a hex value + +C no longer accepts an integer as a parameter; +instead the value is expected to be a binary value encoded in a hex +string, such as "0xf5867c55039dc724". This is to make the +infrastructure support hash seeds of arbitrary lengths, which might +exceed that of an integer. (SipHash uses a 16 byte seed.) + +=head3 PERL_PERTURB_KEYS environment variable added + +The C environment variable allows one to control the level of +randomization applied to C and friends. + +When C is 0, perl will not randomize the key order at all. The +chance that C changes due to an insert will be the same as in previous +perls, basically only when the bucket size is changed. + +When C is 1, perl will randomize keys in a non-repeatable +way. The chance that C changes due to an insert will be very high. This +is the most secure and default mode. + +When C is 2, perl will randomize keys in a repeatable way. +Repeated runs of the same program should produce the same output every time. + +C implies a non-default C setting. Setting +C (exactly one 0) implies C (hash key +randomization disabled); settng C to any other value implies +C (deterministic and repeatable hash key randomization). +Specifying C explicitly to a different level overrides this +behavior. + +=head3 Hash::Util::hash_seed() now returns a string + +Hash::Util::hash_seed() now returns a string instead of an integer. This +is to make the infrastructure support hash seeds of arbitrary lengths +which might exceed that of an integer. (SipHash uses a 16 byte seed.) + +=head3 Output of PERL_HASH_SEED_DEBUG has been changed + +The environment variable PERL_HASH_SEED_DEBUG now makes perl show both the +hash function perl was built with, I the seed, in hex, in use for that +process. Code parsing this output, should it exist, must change to accommodate +the new format. Example of the new format: + + $ PERL_HASH_SEED_DEBUG=1 ./perl -e1 + HASH_FUNCTION = MURMUR3 HASH_SEED = 0x1476bb9f + +=head2 Upgrade to Unicode 6.2 + +Perl now supports Unicode 6.2. A list of changes from Unicode +6.1 is at L. + +=head2 Character name aliases may now include non-Latin1-range characters + +It is possible to define your own names for characters for use in +C<\N{...}>, C, etc. These names can now be +comprised of characters from the whole Unicode range. This allows for +names to be in your native language, and not just English. Certain +restrictions apply to the characters that may be used (you can't define +a name that has punctuation in it, for example). See L. + +=head2 New DTrace probes + +The following new DTrace probes have been added: + +=over 4 + +=item * + +C + +=item * + +C + +=item * + +C + +=back + +=head2 C<${^LAST_FH}> + +This new variable provides access to the filehandle that was last read. +This is the handle used by C<$.> and by C and C without +arguments. + +=head2 Regular Expression Set Operations + +This is an B feature to allow matching against the union, +intersection, etc., of sets of code points, similar to +L. It can also be used to extend C processing +to [bracketed] character classes, and as a replacement of user-defined +properties, allowing more complex expressions than they do. See +L. + +=head2 Lexical subroutines + +This new feature is still considered B. To enable it: + + use 5.018; + no warnings "experimental::lexical_subs"; + use feature "lexical_subs"; + +You can now declare subroutines with C, C, and +C. (C requires that the "state" feature be +enabled, unless you write it as C.) + +C creates a subroutine visible within the lexical scope in which +it is declared. The subroutine is shared between calls to the outer sub. + +C declares a lexical subroutine that is created each time the +enclosing block is entered. C is generally slightly faster than +C. + +C declares a lexical alias to the package subroutine of the same +name. + +For more information, see L. + +=head2 Computed Labels + +The loop controls C, C and C, and the special C +operator, now allow arbitrary expressions to be used to compute labels at run +time. Previously, any argument that was not a constant was treated as the +empty string. + +=head2 More CORE:: subs + +Several more built-in functions have been added as subroutines to the +CORE:: namespace - namely, those non-overridable keywords that can be +implemented without custom parsers: C, C, C, +C, C, C, C, C, C, and C. + +As some of these have prototypes, C has been +changed to not make a distinction between overridable and non-overridable +keywords. This is to make C consistent with +C. + +=head2 C with negative signal names + +C has always allowed a negative signal number, which kills the +process group instead of a single process. It has also allowed signal +names. But it did not behave consistently, because negative signal names +were treated as 0. Now negative signals names like C<-INT> are supported +and treated the same way as -2 [perl #112990]. + +=head1 Security + +=head2 See also: hash overhaul + +Some of the changes in the L were made to +enhance security. Please read that section. + +=head2 C security warning in documentation + +The documentation for C now includes a section which warns readers +of the danger of accepting Storable documents from untrusted sources. The +short version is that deserializing certain types of data can lead to loading +modules and other code execution. This is documented behavior and wanted +behavior, but this opens an attack vector for malicious entities. + +=head2 C allowed code injection via a malicious template + +If users could provide a translation string to Locale::Maketext, this could be +used to invoke arbitrary Perl subroutines available in the current process. + +This has been fixed, but it is still possible to invoke any method provided by +C itself or a subclass that you are using. One of these +methods in turn will invoke the Perl core's C subroutine. + +In summary, allowing users to provide translation strings without auditing +them is a bad idea. + +This vulnerability is documented in CVE-2012-6329. + +=head2 Avoid calling memset with a negative count + +Poorly written perl code that allows an attacker to specify the count to perl's +C string repeat operator can already cause a memory exhaustion +denial-of-service attack. A flaw in versions of perl before v5.15.5 can escalate +that into a heap buffer overrun; coupled with versions of glibc before 2.16, it +possibly allows the execution of arbitrary code. + +The flaw addressed to this commit has been assigned identifier CVE-2012-5195 +and was researched by Tim Brown. + +=head1 Incompatible Changes + +=head2 See also: hash overhaul + +Some of the changes in the L are not fully +compatible with previous versions of perl. Please read that section. + +=head2 An unknown character name in C<\N{...}> is now a syntax error + +Previously, it warned, and the Unicode REPLACEMENT CHARACTER was +substituted. Unicode now recommends that this situation be a syntax +error. Also, the previous behavior led to some confusing warnings and +behaviors, and since the REPLACEMENT CHARACTER has no use other than as +a stand-in for some unknown character, any code that has this problem is +buggy. + +=head2 Formerly deprecated characters in C<\N{}> character name aliases are now errors. + +Since v5.12.0, it has been deprecated to use certain characters in +user-defined C<\N{...}> character names. These now cause a syntax +error. For example, it is now an error to begin a name with a digit, +such as in + + my $undraftable = "\N{4F}"; # Syntax error! + +or to have commas anywhere in the name. See L. + +=head2 C<\N{BELL}> now refers to U+1F514 instead of U+0007 + +Unicode 6.0 reused the name "BELL" for a different code point than it +traditionally had meant. Since Perl v5.14, use of this name still +referred to U+0007, but would raise a deprecation warning. Now, "BELL" +refers to U+1F514, and the name for U+0007 is "ALERT". All the +functions in L have been correspondingly updated. + +=head2 New Restrictions in Multi-Character Case-Insensitive Matching in Regular Expression Bracketed Character Classes + +Unicode has now withdrawn their previous recommendation for regular +expressions to automatically handle cases where a single character can +match multiple characters case-insensitively, for example, the letter +LATIN SMALL LETTER SHARP S and the sequence C. This is because +it turns out to be impracticable to do this correctly in all +circumstances. Because Perl has tried to do this as best it can, it +will continue to do so. (We are considering an option to turn it off.) +However, a new restriction is being added on such matches when they +occur in [bracketed] character classes. People were specifying +things such as C, and being surprised that it matches the +two character sequence C (since LATIN SMALL LETTER SHARP S occurs in +this range). This behavior is also inconsistent with using a +property instead of a range: C<\p{Block=Latin1}> also includes LATIN +SMALL LETTER SHARP S, but C does not match C. +The new rule is that for there to be a multi-character case-insensitive +match within a bracketed character class, the character must be +explicitly listed, and not as an end point of a range. This more +closely obeys the Principle of Least Astonishment. See +L. Note that a bug [perl +#89774], now fixed as part of this change, prevented the previous +behavior from working fully. + +=head2 Explicit rules for variable names and identifiers + +Due to an oversight, single character variable names in v5.16 were +completely unrestricted. This opened the door to several kinds of +insanity. As of v5.18, these now follow the rules of other identifiers, +in addition to accepting characters that match the C<\p{POSIX_Punct}> +property. + +There is no longer any difference in the parsing of identifiers +specified by using braces versus without braces. For instance, perl +used to allow C<${foo:bar}> (with a single colon) but not C<$foo:bar>. +Now that both are handled by a single code path, they are both treated +the same way: both are forbidden. Note that this change is about the +range of permissible literal identifiers, not other expressions. + +=head2 Vertical tabs are now whitespace + +No one could recall why C<\s> didn't match C<\cK>, the vertical tab. +Now it does. Given the extreme rarity of that character, very little +breakage is expected. That said, here's what it means: + +C<\s> in a regex now matches a vertical tab in all circumstances. + +Literal vertical tabs in a regex literal are ignored when the C +modifier is used. + +Leading vertical tabs, alone or mixed with other whitespace, are now +ignored when interpreting a string as a number. For example: + + $dec = " \cK \t 123"; + $hex = " \cK \t 0xF"; + + say 0 + $dec; # was 0 with warning, now 123 + say int $dec; # was 0, now 123 + say oct $hex; # was 0, now 15 + +=head2 C and C have been heavily reworked + +The implementation of this feature has been almost completely rewritten. +Although its main intent is to fix bugs, some behaviors, especially +related to the scope of lexical variables, will have changed. This is +described more fully in the L section. + +=head2 Stricter parsing of substitution replacement + +It is no longer possible to abuse the way the parser parses C like +this: + + %_=(_,"Just another "); + $_="Perl hacker,\n"; + s//_}->{_/e;print + +=head2 C now aliases the global C<$_> + +Instead of assigning to an implicit lexical C<$_>, C now makes the +global C<$_> an alias for its argument, just like C. However, it +still uses lexical C<$_> if there is lexical C<$_> in scope (again, just like +C) [perl #114020]. + +=head2 The smartmatch family of features are now experimental + +Smart match, added in v5.10.0 and significantly revised in v5.10.1, has been +a regular point of complaint. Although there are a number of ways in which +it is useful, it has also proven problematic and confusing for both users and +implementors of Perl. There have been a number of proposals on how to best +address the problem. It is clear that smartmatch is almost certainly either +going to change or go away in the future. Relying on its current behavior +is not recommended. + +Warnings will now be issued when the parser sees C<~~>, C, or C. +To disable these warnings, you can add this line to the appropriate scope: + + no if $] >= 5.018, "experimental::smartmatch"; + +Consider, though, replacing the use of these features, as they may change +behavior again before becoming stable. + +=head2 Lexical C<$_> is now experimental + +Since it was introduced in Perl v5.10, it has caused much confusion with no +obvious solution: + +=over + +=item * + +Various modules (e.g., List::Util) expect callback routines to use the +global C<$_>. C +does not work as one would expect. + +=item * + +A C declaration earlier in the same file can cause confusing closure +warnings. + +=item * + +The "_" subroutine prototype character allows called subroutines to access +your lexical C<$_>, so it is not really private after all. + +=item * + +Nevertheless, subroutines with a "(@)" prototype and methods cannot access +the caller's lexical C<$_>, unless they are written in XS. + +=item * + +But even XS routines cannot access a lexical C<$_> declared, not in the +calling subroutine, but in an outer scope, iff that subroutine happened not +to mention C<$_> or use any operators that default to C<$_>. + +=back + +It is our hope that lexical C<$_> can be rehabilitated, but this may +cause changes in its behavior. Please use it with caution until it +becomes stable. + +=head2 readline() with C<$/ = \N> now reads N characters, not N bytes + +Previously, when reading from a stream with I/O layers such as +C, the readline() function, otherwise known as the C<< <> >> +operator, would read I bytes from the top-most layer. [perl #79960] + +Now, I characters are read instead. + +There is no change in behaviour when reading from streams with no +extra layers, since bytes map exactly to characters. + +=head2 Overridden C is now passed one argument + +C overrides used to be passed a magical undocumented second argument +that identified the caller. Nothing on CPAN was using this, and it got in +the way of a bug fix, so it was removed. If you really need to identify +the caller, see L on CPAN. + +=head2 Here doc parsing + +The body of a here document inside a quote-like operator now always begins +on the line after the "< lists used to fool the parser into thinking they were always +surrounded by parentheses. This permitted some surprising constructions +such as C, which should really be written +C. These would sometimes get the lexer into +the wrong state, so they didn't fully work, and the similar C that one might expect to be permitted never worked at all. + +This side effect of C has now been abolished. It has been deprecated +since Perl v5.13.11. It is now necessary to use real parentheses +everywhere that the grammar calls for them. + +=head2 Interaction of lexical and default warnings + +Turning on any lexical warnings used first to disable all default warnings +if lexical warnings were not already enabled: + + $*; # deprecation warning + use warnings "void"; + $#; # void warning; no deprecation warning + +Now, the C, C, C, C and C warnings +categories are left on when turning on lexical warnings (unless they are +turned off by C, of course). + +This may cause deprecation warnings to occur in code that used to be free +of warnings. + +Those are the only categories consisting only of default warnings. Default +warnings in other categories are still disabled by C<< use warnings "category" >>, +as we do not yet have the infrastructure for controlling +individual warnings. + +=head2 C and C + +Due to an accident of history, C and C were equivalent +to a plain C, so one could even create an anonymous sub with +C. These are now disallowed outside of the "lexical_subs" +feature. Under the "lexical_subs" feature they have new meanings described +in L. + +=head2 Defined values stored in environment are forced to byte strings + +A value stored in an environment variable has always been stringified. In this +release, it is converted to be only a byte string. First, it is forced to be +only a string. Then if the string is utf8 and the equivalent of +C works, that result is used; otherwise, the equivalent of +C is used, and a warning is issued about wide characters +(L). + +=head2 C dies for unreadable files + +When C encounters an unreadable file, it now dies. It used to +ignore the file and continue searching the directories in C<@INC> +[perl #113422]. + +=head2 C and SUPER + +The various C XS functions used to treat a package whose +named ended with C<::SUPER> specially. A method lookup on the C +package would be treated as a C method lookup on the C package. This +is no longer the case. To do a C lookup, pass the C stash and the +C flag. + +=head2 C's first argument is more consistently interpreted + +After some changes earlier in v5.17, C's behavior has been +simplified: if the PATTERN argument evaluates to a string +containing one space, it is treated the way that a I string +containing one space once was. + +=head1 Deprecations + +=head2 Module removals + +The following modules will be removed from the core distribution in a future +release, and will at that time need to be installed from CPAN. Distributions +on CPAN which require these modules will need to list them as prerequisites. + +The core versions of these modules will now issue C<"deprecated">-category +warnings to alert you to this fact. To silence these deprecation warnings, +install the modules in question from CPAN. + +Note that these are (with rare exceptions) fine modules that you are encouraged +to continue to use. Their disinclusion from core primarily hinges on their +necessity to bootstrapping a fully functional, CPAN-capable Perl installation, +not usually on concerns over their design. + +=over + +=item L + +The use of this pragma is now strongly discouraged. It conflates the encoding +of source text with the encoding of I/O data, reinterprets escape sequences in +source text (a questionable choice), and introduces the UTF-8 bug to all runtime +handling of character strings. It is broken as designed and beyond repair. + +For using non-ASCII literal characters in source text, please refer to L. +For dealing with textual I/O data, please refer to L and L. + +=item L + +=item L + +=item L + +=item L and all included C modules + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=item L + +=back + +=head2 Deprecated Utilities + +The following utilities will be removed from the core distribution in a +future release as their associated modules have been deprecated. They +will remain available with the applicable CPAN distribution. + +=over + +=item L + +=item C + +=item L + +These items are part of the C distribution. + +=item L + +This item is part of the C distribution. + +=back + +=head2 PL_sv_objcount + +This interpreter-global variable used to track the total number of +Perl objects in the interpreter. It is no longer maintained and will +be removed altogether in Perl v5.20. + +=head2 Five additional characters should be escaped in patterns with C + +When a regular expression pattern is compiled with C, Perl treats 6 +characters as white space to ignore, such as SPACE and TAB. However, +Unicode recommends 11 characters be treated thusly. We will conform +with this in a future Perl version. In the meantime, use of any of the +missing characters will raise a deprecation warning, unless turned off. +The five characters are: + + U+0085 NEXT LINE + U+200E LEFT-TO-RIGHT MARK + U+200F RIGHT-TO-LEFT MARK + U+2028 LINE SEPARATOR + U+2029 PARAGRAPH SEPARATOR + +=head2 User-defined charnames with surprising whitespace + +A user-defined character name with trailing or multiple spaces in a row is +likely a typo. This now generates a warning when defined, on the assumption +that uses of it will be unlikely to include the excess whitespace. + +=head2 Various XS-callable functions are now deprecated + +All the functions used to classify characters will be removed from a +future version of Perl, and should not be used. With participating C +compilers (e.g., gcc), compiling any file that uses any of these will +generate a warning. These were not intended for public use; there are +equivalent, faster, macros for most of them. + +See L. The complete list is: + +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C, C, +C, C. + +In addition these three functions that have never worked properly are +deprecated: +C, C, and C. + +=head2 Certain rare uses of backslashes within regexes are now deprecated + +There are three pairs of characters that Perl recognizes as +metacharacters in regular expression patterns: C<{}>, C<[]>, and C<()>. +These can be used as well to delimit patterns, as in: + + m{foo} + s(foo)(bar) + +Since they are metacharacters, they have special meaning to regular +expression patterns, and it turns out that you can't turn off that +special meaning by the normal means of preceding them with a backslash, +if you use them, paired, within a pattern delimited by them. For +example, in + + m{foo\{1,3\}} + +the backslashes do not change the behavior, and this matches +S> followed by one to three more occurrences of C<"o">. + +Usages like this, where they are interpreted as metacharacters, are +exceedingly rare; we think there are none, for example, in all of CPAN. +Hence, this deprecation should affect very little code. It does give +notice, however, that any such code needs to change, which will in turn +allow us to change the behavior in future Perl versions so that the +backslashes do have an effect, and without fear that we are silently +breaking any existing code. + +=head2 Splitting the tokens C<(?> and C<(*> in regular expressions + +A deprecation warning is now raised if the C<(> and C are separated +by white space or comments in C<(?...)> regular expression constructs. +Similarly, if the C<(> and C<*> are separated in C<(*VERB...)> +constructs. + +=head2 Pre-PerlIO IO implementations + +In theory, you can currently build perl without PerlIO. Instead, you'd use a +wrapper around stdio or sfio. In practice, this isn't very useful. It's not +well tested, and without any support for IO layers or (thus) Unicode, it's not +much of a perl. Building without PerlIO will most likely be removed in the +next version of perl. + +PerlIO supports a C layer if stdio use is desired. Similarly a +sfio layer could be produced in the future, if needed. + +=head1 Future Deprecations + +=over + +=item * + +Platforms without support infrastructure + +Both Windows CE and z/OS have been historically under-maintained, and are +currently neither successfully building nor regularly being smoke tested. +Efforts are underway to change this situation, but it should not be taken for +granted that the platforms are safe and supported. If they do not become +buildable and regularly smoked, support for them may be actively removed in +future releases. If you have an interest in these platforms and you can lend +your time, expertise, or hardware to help support these platforms, please let +the perl development effort know by emailing C. + +Some platforms that appear otherwise entirely dead are also on the short list +for removal between now and v5.20.0: + +=over + +=item DG/UX + +=item NeXT + +=back + +We also think it likely that current versions of Perl will no longer +build AmigaOS, DJGPP, NetWare (natively), OS/2 and Plan 9. If you +are using Perl on such a platform and have an interest in ensuring +Perl's future on them, please contact us. + +We believe that Perl has long been unable to build on mixed endian +architectures (such as PDP-11s), and intend to remove any remaining +support code. Similarly, code supporting the long umaintained GNU +dld will be removed soon if no-one makes themselves known as an +active user. + +=item * + +Swapping of $< and $> + +Perl has supported the idiom of swapping $< and $> (and likewise $( and +$)) to temporarily drop permissions since 5.0, like this: + + ($<, $>) = ($>, $<); + +However, this idiom modifies the real user/group id, which can have +undesirable side-effects, is no longer useful on any platform perl +supports and complicates the implementation of these variables and list +assignment in general. + +As an alternative, assignment only to C<< $> >> is recommended: + + local $> = $<; + +See also: L. + +=item * + +C, long broken and of unclear present purpose, will be removed. + +=item * + +Revamping C<< "\Q" >> semantics in double-quotish strings when combined with +other escapes. + +There are several bugs and inconsistencies involving combinations +of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair. +These need to be fixed, and doing so will necessarily change current +behavior. The changes have not yet been settled. + +=item * + +Use of C<$x>, where C stands for any actual (non-printing) C0 control +character will be disallowed in a future Perl version. Use C<${x}> +instead (where again C stands for a control character), +or better, C<$^A> , where C<^> is a caret (CIRCUMFLEX ACCENT), +and C stands for any of the characters listed at the end of +L. + +=back + +=head1 Performance Enhancements + +=over 4 + +=item * + +Lists of lexical variable declarations (C) are now optimised +down to a single op and are hence faster than before. + +=item * + +A new C preprocessor define C was added that, if set, +disables Perl's taint support altogether. Using the -T or -t command +line flags will cause a fatal error. Beware that both core tests as +well as many a CPAN distribution's tests will fail with this change. On +the upside, it provides a small performance benefit due to reduced +branching. + +B + +=item * + +C with constant arguments is now constant folded in most cases +[perl #113470]. + +=item * + +Speed up in regular expression matching against Unicode properties. The +largest gain is for C<\X>, the Unicode "extended grapheme cluster." The +gain for it is about 35% - 40%. Bracketed character classes, e.g., +C<[0-9\x{100}]> containing code points above 255 are also now faster. + +=item * + +On platforms supporting it, several former macros are now implemented as static +inline functions. This should speed things up slightly on non-GCC platforms. + +=item * + +The optimisation of hashes in boolean context has been extended to +affect C, C<%hash ? ... : ...>, and C. + +=item * + +Filetest operators manage the stack in a fractionally more efficient manner. + +=item * + +Globs used in a numeric context are now numified directly in most cases, +rather than being numified via stringification. + +=item * + +The C repetition operator is now folded to a single constant at compile +time if called in scalar context with constant operands and no parentheses +around the left operand. + +=back + +=head1 Modules and Pragmata + +=head2 New Modules and Pragmata + +=over 4 + +=item * + +L version 0.16 has been added as a dual-lifed module. +It provides structured data retrieval of C output including +information only known to the C binary and not available via L. + +=back + +=head2 Updated Modules and Pragmata + +For a complete list of updates, run: + + $ corelist --diff 5.16.0 5.18.0 + +You can substitute your favorite version in place of C<5.16.0>, too. + +=over + +=item * + +L has been upgraded to 0.68. + +Work around an edge case on Linux with Busybox's unzip. + +=item * + +L has been upgraded to 1.90. + +ptar now supports the -T option as well as dashless options +[rt.cpan.org #75473], [rt.cpan.org #75475]. + +Auto-encode filenames marked as UTF-8 [rt.cpan.org #75474]. + +Don't use C on L handles [rt.cpan.org #64339]. + +Don't try to C on symlinks. + +=item * + +L has been upgraded to 2.13. + +C now plays nicely with the 'open' pragma. + +=item * + +L has been upgraded to 1.42. + +The C method of COPs has been added. This provides access to an +internal field added in perl 5.16 under threaded builds [perl #113034]. + +C now supports UTF-8 package names and embedded NULs. + +All C and C +and more SV-related flag values are now provided as constants in the C +namespace and available for export. The default export list has not changed. + +This makes the module work with the new pad API. + +=item * + +L has been upgraded to 0.95. + +The C<-nobanner> option has been fixed, and Cs can now be dumped. +When passed a sub name to dump, it will check also to see whether it +is the name of a format. If a sub and a format share the same name, +it will dump both. + +This adds support for the new C and C flags. + +=item * + +L has been upgraded to 1.18. + +This adds support (experimentally) for C, which was +added in Perl 5.17.4. + +=item * + +L has been upgraded to 1.20. + +Avoid warning when run under C. + +It now deparses +loop controls with the correct precedence, and multiple statements in a +C line are also now deparsed correctly. + +This release suppresses trailing semicolons in formats. + +This release adds stub deparsing for lexical subroutines. + +It no longer dies when deparsing C without arguments. It now +correctly omits the comma for C and C. + +=item * + +L, L and L have been upgraded to 0.33. + +The overrides for C and C have been rewritten, eliminating +several problems, and making one incompatible change: + +=over + +=item * + +Formerly, whichever of C or C was compiled later +would take precedence over the other, causing C and C not to +respect the other pragma when in scope. + +=item * + +Using any of these three pragmata would cause C and C anywhere +else in the program to evalute their arguments in list context and prevent +them from inferring $_ when called without arguments. + +=item * + +Using any of these three pragmata would make C return 1234 +(for any number not beginning with 0) anywhere in the program. Now "1234" +is translated from octal to decimal, whether within the pragma's scope or +not. + +=item * + +The global overrides that facilitate lexical use of C and C now +respect any existing overrides that were in place before the new overrides +were installed, falling back to them outside of the scope of C. + +=item * + +C, C and similar invocations for bigint +and bigrat now export a C or C function, instead of providing a +global override. + +=back + +=item * + +L has been upgraded to 1.29. + +Carp is no longer confused when C returns undef for a package that +has been deleted. + +The C and C functions are now documented. + +=item * + +L has been upgraded to 3.63. + +Unrecognized HTML escape sequences are now handled better, problematic +trailing newlines are no longer inserted after EformE tags +by C or C, and bogus "Insecure Dependency" +warnings appearing with some versions of perl are now worked around. + +=item * + +L has been upgraded to 0.64. + +The constructor now respects overridden accessor methods [perl #29230]. + +=item * + +L has been upgraded to 2.060. + +The misuse of Perl's "magic" API has been fixed. + +=item * + +L has been upgraded to 2.060. + +Upgrade bundled zlib to version 1.2.7. + +Fix build failures on Irix, Solaris, and Win32, and also when building as C++ +[rt.cpan.org #69985], [rt.cpan.org #77030], [rt.cpan.org #75222]. + +The misuse of Perl's "magic" API has been fixed. + +C, C, C and C have +been speeded up by making parameter validation more efficient. + +=item * + +L has been upgraded to 2.122. + +Treat undef requirements to C as 0 (with a warning). + +Added C method. + +=item * + +L has been upgraded to 0.9135. + +Allow adding F to PATH. + +Save the history between invocations of the shell. + +Handle multiple C and C arguments better. + +This resolves issues with the SQLite source engine. + +=item * + +L has been upgraded to 2.145. + +It has been optimized to only build a seen-scalar hash as necessary, +thereby speeding up serialization drastically. + +Additional tests were added in order to improve statement, branch, condition +and subroutine coverage. On the basis of the coverage analysis, some of the +internals of Dumper.pm were refactored. Almost all methods are now +documented. + +=item * + +L has been upgraded to 1.827. + +The main Perl module no longer uses the C<"@_"> construct. + +=item * + +L has been upgraded to 1.11. + +This fixes compilation with C++ compilers and makes the module work with +the new pad API. + +=item * + +L has been upgraded to 2.52. + +Fix C OO fallback [rt.cpan.org #66634]. + +=item * + +L has been upgraded to 5.84. + +This fixes a double-free bug, which might have caused vulnerabilities +in some cases. + +=item * + +L has been upgraded to 1.18. + +This is due to a minor code change in the XS for the VMS implementation. + +This fixes warnings about using C sections without an C +section. + +=item * + +L has been upgraded to 2.49. + +The Mac alias x-mac-ce has been added, and various bugs have been fixed +in Encode::Unicode, Encode::UTF7 and Encode::GSM0338. + +=item * + +L has been upgraded to 1.04. + +Its SPLICE implementation no longer misbehaves in list context. + +=item * + +L has been upgraded to 0.280210. + +Manifest files are now correctly embedded for those versions of VC++ which +make use of them. [perl #111782, #111798]. + +A list of symbols to export can now be passed to C when on +Windows, as on other OSes [perl #115100]. + +=item * + +L has been upgraded to 3.18. + +The generated C code now avoids unnecessarily incrementing +C on Perl versions where it's done automatically +(or on current Perl where the variable no longer exists). + +This avoids a bogus warning for initialised XSUB non-parameters [perl +#112776]. + +=item * + +L has been upgraded to 2.26. + +C no longer zeros files when copying into the same directory, +and also now fails (as it has long been documented to do) when attempting +to copy a file over itself. + +=item * + +L has been upgraded to 1.10. + +The internal cache of file names that it keeps for each caller is now +freed when that caller is freed. This means +C<< use File::DosGlob 'glob'; eval 'scalar <*>' >> no longer leaks memory. + +=item * + +L has been upgraded to 0.38. + +Added the 'file_default' option for URLs that do not have a file +component. + +Use C when available, and provide C to +override the autodetection. + +Always re-fetch F if C is set. + +=item * + +L has been upgraded to 1.23. + +This fixes inconsistent unixy path handling on VMS. + +Individual files may now appear in list of directories to be searched +[perl #59750]. + +=item * + +L has been upgraded to 1.20. + +File::Glob has had exactly the same fix as File::DosGlob. Since it is +what Perl's own C operator itself uses (except on VMS), this means +C<< eval 'scalar <*>' >> no longer leaks. + +A space-separated list of patterns return long lists of results no longer +results in memory corruption or crashes. This bug was introduced in +Perl 5.16.0. [perl #114984] + +=item * + +L has been upgraded to 3.40. + +C could produce incorrect results when given two relative paths or +the root directory twice [perl #111510]. + +=item * + +L has been upgraded to 1.07. + +C ignores the L pragma, and warns when used in +combination therewith. But it was not warning for C<-r>. This has been +fixed [perl #111640]. + +C<-p> now works, and does not return false for pipes [perl #111638]. + +Previously C's overloaded C<-x> and C<-X> operators did not give +the correct results for directories or executable files when running as +root. They had been treating executable permissions for root just like for +any other user, performing group membership tests I for files not owned +by root. They now follow the correct Unix behaviour - for a directory they +are always true, and for a file if any of the three execute permission bits +are set then they report that root can execute the file. Perl's builtin +C<-x> and C<-X> operators have always been correct. + +=item * + +L has been upgraded to 0.23 + +Fixes various bugs involving directory removal. Defers unlinking tempfiles if +the initial unlink fails, which fixes problems on NFS. + +=item * + +L has been upgraded to 1.15. + +The undocumented optional fifth parameter to C has been +removed. This was intended to provide control of the callback used by +C functions in case of fatal errors (such as filesystem problems), +but did not work (and could never have worked). No code on CPAN even +attempted to use it. The callback is now always the previous default, +C. Problems on some platforms with how the C C function +is called have also been resolved. + +=item * + +L has been upgraded to 0.15. + +C and C now returns true if the hash is +unlocked, instead of always returning false [perl #112126]. + +C, C, C and +C are now exportable [perl #112126]. + +Two new functions, C and C, have been added. +Oddly enough, these two functions were already exported, even though they +did not exist [perl #112126]. + +=item * + +L has been upgraded to 0.025. + +Add SSL verification features [github #6], [github #9]. + +Include the final URL in the response hashref. + +Add C option. + +This improves SSL support. + +=item * + +L has been upgraded to 1.28. + +C can now be called on read-only file handles [perl #64772]. + +L tries harder to cache or otherwise fetch socket +information. + +=item * + +L has been upgraded to 0.80. + +Use C instead of C in C [rt.cpan.org #76901]. + +=item * + +L has been upgraded to 1.13. + +The C function no longer uses C to close file +descriptors since that breaks the ref-counting of file descriptors done by +PerlIO in cases where the file descriptors are shared by PerlIO streams, +leading to attempts to close the file descriptors a second time when +any such PerlIO streams are closed later on. + +=item * + +L has been upgraded to 3.25. + +It includes some new codes. + +=item * + +L has been upgraded to 1.03. + +Fix the C cache option. + +=item * + +L has been upgraded to 0.4003. + +Fixed bug where modules without C<$VERSION> might have a version of '0' listed +in 'provides' metadata, which will be rejected by PAUSE. + +Fixed bug in PodParser to allow numerals in module names. + +Fixed bug where giving arguments twice led to them becoming arrays, resulting +in install paths like F. + +A minor bug fix allows markup to be used around the leading "Name" in +a POD "abstract" line, and some documentation improvements have been made. + +=item * + +L has been upgraded to 2.90 + +Version information is now stored as a delta, which greatly reduces the +size of the F file. + +This restores compatibility with older versions of perl and cleans up +the corelist data for various modules. + +=item * + +L has been upgraded to 0.54. + +Fix use of C on perls installed to a path with spaces. + +Various enhancements include the new use of Module::Metadata. + +=item * + +L has been upgraded to 1.000011. + +The creation of a Module::Metadata object for a typical module file has +been sped up by about 40%, and some spurious warnings about C<$VERSION>s +have been suppressed. + +=item * + +L has been upgraded to 4.7. + +Amongst other changes, triggers are now allowed on events, which gives +a powerful way to modify behaviour. + +=item * + +L has been upgraded to 2.41. + +This fixes some test failures on Windows. + +=item * + +L has been upgraded to 1.25. + +Reflect the removal of the boolkeys opcode and the addition of the +clonecv, introcv and padcv opcodes. + +=item * + +L has been upgraded to 1.22. + +C now warns for invalid arguments, just like C. + +=item * + +L has been upgraded to 0.16. + +This is the module implementing the ":encoding(...)" I/O layer. It no +longer corrupts memory or crashes when the encoding back-end reallocates +the buffer or gives it a typeglob or shared hash key scalar. + +=item * + +L has been upgraded to 0.16. + +The buffer scalar supplied may now only contain code pounts 0xFF or +lower. [perl #109828] + +=item * + +L has been upgraded to 1.003. + +This fixes a bug detecting the VOS operating system. + +=item * + +L has been upgraded to 1.18. + +The option C<--libpods> has been reinstated. It is deprecated, and its use +does nothing other than issue a warning that it is no longer supported. + +Since the HTML files generated by pod2html claim to have a UTF-8 charset, +actually write the files out using UTF-8 [perl #111446]. + +=item * + +L has been upgraded to 3.28. + +Numerous improvements have been made, mostly to Pod::Simple::XHTML, +which also has a compatibility change: the C option +is now disabled by default. See F for the +full details. + +=item * + +L has been upgraded to 0.23 + +Single character [class]es like C or C are now optimized +as if they did not have the brackets, i.e. C or C. + +See note about C in the L section below. + +=item * + +L has been upgraded to 2.35. + +Fix interactions with C. + +Don't eval code under C. + +=item * + +L has been upgraded to version 1.27. + +Fix an overloading issue with C. + +C and C now check the callback first (so C<&first(1)> is +disallowed). + +Fix C on magical values [rt.cpan.org #55763]. + +Fix C on previously magical values [rt.cpan.org #61118]. + +Fix reading past the end of a fixed buffer [rt.cpan.org #72700]. + +=item * + +L has been upgraded to 1.07. + +No longer require C on filehandles. + +Use C for casefolding. + +=item * + +L has been upgraded to 2.009. + +Constants and functions required for IP multicast source group membership +have been added. + +C and C now return just the IP +address in scalar context, and C now guards against incorrect +length scalars being passed in. + +This fixes an uninitialized memory read. + +=item * + +L has been upgraded to 2.41. + +Modifying C<$_[0]> within C no longer results in crashes +[perl #112358]. + +An object whose class implements C is now thawed only once +when there are multiple references to it in the structure being thawed +[perl #111918]. + +Restricted hashes were not always thawed correctly [perl #73972]. + +Storable would croak when freezing a blessed REF object with a +C method [perl #113880]. + +It can now freeze and thaw vstrings correctly. This causes a slight +incompatible change in the storage format, so the format version has +increased to 2.9. + +This contains various bugfixes, including compatibility fixes for older +versions of Perl and vstring handling. + +=item * + +L has been upgraded to 0.32. + +This contains several bug fixes relating to C, +Cand log levels in C, together with fixes for +Windows, Haiku-OS and GNU/kFreeBSD. See F +for the full details. + +=item * + +L has been upgraded to 4.02. + +Add support for italics. + +Improve error handling. + +=item * + +L has been upgraded to 1.10. This fixes the +use of the B and B shells on Windows in the event that the current +drive happens to contain a F<\dev\tty> file. + +=item * + +L has been upgraded to 3.26. + +Fix glob semantics on Win32 [rt.cpan.org #49732]. + +Don't use C when calling perl [rt.cpan.org #47890]. + +Ignore -T when reading shebang [rt.cpan.org #64404]. + +Handle the case where we don't know the wait status of the test more +gracefully. + +Make the test summary 'ok' line overridable so that it can be changed to a +plugin to make the output of prove idempotent. + +Don't run world-writable files. + +=item * + +L and L have been upgraded to +2012.0818. Support for Unicode combining characters has been added to them +both. + +=item * + +L has been upgraded to 1.31. + +This adds the option to warn about or ignore attempts to clone structures +that can't be cloned, as opposed to just unconditionally dying in +that case. + +This adds support for dual-valued values as created by +L. + +=item * + +L has been upgraded to 4.3. + +C now respects the offset argument to C [perl #112826]. + +=item * + +L has been upgraded to 1.2300. + +Seconds values greater than 59 but less than 60 no longer cause +C and C to croak. + +=item * + +L has been upgraded to 0.53. + +This adds a function L +that returns all the casefolds. + +=item * + +L has been upgraded to 0.47. + +New APIs have been added for getting and setting the current code page. + +=back + + +=head2 Removed Modules and Pragmata + +=over + +=item * + +L has been removed from the core distribution. It is +available under a different name: L. + +=back + +=head1 Documentation + +=head2 Changes to Existing Documentation + +=head3 L + +=over 4 + +=item * + +L has been reorganized, and a few new sections were added. + +=back + +=head3 L + +=over 4 + +=item * + +Now explicitly documents the behaviour of hash initializer lists that +contain duplicate keys. + +=back + +=head3 L + +=over 4 + +=item * + +The explanation of symbolic references being prevented by "strict refs" +now doesn't assume that the reader knows what symbolic references are. + +=back + +=head3 L + +=over 4 + +=item * + +L has been synchronized with version 5.0150040 from CPAN. + +=back + +=head3 L + +=over 4 + +=item * + +The return value of C is now documented. + +=item * + +Clarified documentation of C. + +=back + +=head3 L + +=over 4 + +=item * + +Loop control verbs (C, C, C, C and C) have always +had the same precedence as assignment operators, but this was not documented +until now. + +=back + +=head3 Diagnostics + +The following additions or changes have been made to diagnostic output, +including warnings and fatal error messages. For the complete list of +diagnostic messages, see L. + +=head2 New Diagnostics + +=head3 New Errors + +=over 4 + +=item * + +L + +This message now occurs when a here document label has an initial quotation +mark but the final quotation mark is missing. + +This replaces a bogus and misleading error message about not finding the label +itself [perl #114104]. + +=item * + +L + +This error is thrown when a child pseudo-process in the ithreads implementation +on Windows was not scheduled within the time period allowed and therefore was +not able to initialize properly [perl #88840]. + +=item * + +L%sE|perldiag/"Group name must start with a non-digit word character in regex; marked by <-- HERE in m/%s/"> + +This error has been added for C<(?&0)>, which is invalid. It used to +produce an incomprehensible error message [perl #101666]. + +=item * + +L + +Calling an undefined value as a subroutine now produces this error message. +It used to, but was accidentally disabled, first in Perl 5.004 for +non-magical variables, and then in Perl v5.14 for magical (e.g., tied) +variables. It has now been restored. In the mean time, undef was treated +as an empty string [perl #113576]. + +=item * + +L + +To use lexical subs, you must first enable them: + + no warnings 'experimental::lexical_subs'; + use feature 'lexical_subs'; + my sub foo { ... } + +=back + +=head3 New Warnings + +=over 4 + +=item * + +L<'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"> + +=item * + +L<'%s' resolved to '\o{%s}%d'|perldiag/"'%s' resolved to '\o{%s}%d'"> + +=item * + +L<'Trailing white-space in a charnames alias definition is deprecated'|perldiag/"Trailing white-space in a charnames alias definition is deprecated"> + +=item * + +L<'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"> + +=item * + +L<'Passing malformed UTF-8 to "%s" is deprecated'|perldiag/"Passing malformed UTF-8 to "%s" is deprecated"> + +=item * + +L + +(W closure) During compilation, an inner named subroutine or eval is +attempting to capture an outer lexical subroutine that is not currently +available. This can happen for one of two reasons. First, the lexical +subroutine may be declared in an outer anonymous subroutine that has not +yet been created. (Remember that named subs are created at compile time, +while anonymous subs are created at run-time.) For example, + + sub { my sub a {...} sub f { \&a } } + +At the time that f is created, it can't capture the current the "a" sub, +since the anonymous subroutine hasn't been created yet. Conversely, the +following won't give a warning since the anonymous subroutine has by now +been created and is live: + + sub { my sub a {...} eval 'sub f { \&a }' }->(); + +The second situation is caused by an eval accessing a variable that has +gone out of scope, for example, + + sub f { + my sub a {...} + sub { eval '\&a' } + } + f()->(); + +Here, when the '\&a' in the eval is being compiled, f() is not currently +being executed, so its &a is not available for capture. + +=item * + +L<"%s" subroutine &%s masks earlier declaration in same %s|perldiag/"%s" subroutine &%s masks earlier declaration in same %s> + +(W misc) A "my" or "state" subroutine has been redeclared in the +current scope or statement, effectively eliminating all access to +the previous instance. This is almost always a typographical error. +Note that the earlier subroutine will still exist until the end of +the scope or until all closure references to it are destroyed. + +=item * + +L + +(S experimental) This warning is emitted if you enable an experimental +feature via C. Simply suppress the warning if you want +to use the feature, but know that in doing so you are taking the risk +of using an experimental feature which may change or be removed in a +future Perl version: + + no warnings "experimental::lexical_subs"; + use feature "lexical_subs"; + +=item * + +L + +(W overflow) You called C with a number that was larger than it can +reliably handle and C probably slept for less time than requested. + +=item * + +L + +Attempts to put wide characters into environment variables via C<%ENV> now +provoke this warning. + +=item * + +"L" + +C now warns when passed a negative value [perl #83048]. + +=item * + +"L" + +C now warns when passed a value that doesn't fit in a C (since the +value will be truncated rather than overflowing) [perl #40605]. + +=item * + +"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">" + +Running perl with the C<-i> flag now warns if no input files are provided on +the command line [perl #113410]. + +=back + +=head2 Changes to Existing Diagnostics + +=over 4 + +=item * + +L<$* is no longer supported|perldiag/"$* is no longer supported"> + +The warning that use of C<$*> and C<$#> is no longer supported is now +generated for every location that references them. Previously it would fail +to be generated if another variable using the same typeglob was seen first +(e.g. C<@*> before C<$*>), and would not be generated for the second and +subsequent uses. (It's hard to fix the failure to generate warnings at all +without also generating them every time, and warning every time is +consistent with the warnings that C<$[> used to generate.) + +=item * + +The warnings for C<\b{> and C<\B{> were added. They are a deprecation +warning which should be turned off by that category. One should not +have to turn off regular regexp warnings as well to get rid of these. + +=item * + +L + +Constant overloading that returns C results in this error message. +For numeric constants, it used to say "Constant(undef)". "undef" has been +replaced with the number itself. + +=item * + +The error produced when a module cannot be loaded now includes a hint that +the module may need to be installed: "Can't locate hopping.pm in @INC (you +may need to install the hopping module) (@INC contains: ...)" + +=item * + +L + +This warning was not suppressable, even with C. Now it is +suppressible, and has been moved from the "internal" category to the +"printf" category. + +=item * + +C<< Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ >> + +This fatal error has been turned into a warning that reads: + +L<< Quantifier {n,m} with n > m can't match in regex | perldiag/Quantifier {n,m} with n > m can't match in regex >> + +(W regexp) Minima should be less than or equal to maxima. If you really want +your regexp to match something 0 times, just put {0}. + +=item * + +The "Runaway prototype" warning that occurs in bizarre cases has been +removed as being unhelpful and inconsistent. + +=item * + +The "Not a format reference" error has been removed, as the only case in +which it could be triggered was a bug. + +=item * + +The "Unable to create sub named %s" error has been removed for the same +reason. + +=item * + +The 'Can't use "my %s" in sort comparison' error has been downgraded to a +warning, '"my %s" used in sort comparison' (with 'state' instead of 'my' +for state variables). In addition, the heuristics for guessing whether +lexical $a or $b has been misused have been improved to generate fewer +false positives. Lexical $a and $b are no longer disallowed if they are +outside the sort block. Also, a named unary or list operator inside the +sort block no longer causes the $a or $b to be ignored [perl #86136]. + +=back + +=head1 Utility Changes + +=head3 L + +=over 4 + +=item * + +F no longer produces invalid code for empty defines. [perl #20636] + +=back + +=head1 Configuration and Compilation + +=over 4 + +=item * + +Added C option to Configure + +When set, it includes 'api_versionstring' in 'archname'. E.g. +x86_64-linux-5.13.6-thread-multi. It is unset by default. + +This feature was requested by Tim Bunce, who observed that +C creates a library structure that does not +differentiate by perl version. Instead, it places architecture +specific files in "$install_base/lib/perl5/$archname". This makes +it difficult to use a common C library path with +multiple versions of perl. + +By setting C<-Duseversionedarchname>, the $archname will be +distinct for architecture I API version, allowing mixed use of +C. + +=item * + +Add a C option + +If C is defined, don't include "inline.h" + +This permits test code to include the perl headers for definitions without +creating a link dependency on the perl library (which may not exist yet). + +=item * + +Configure will honour the external C environment variable, if set. + +=item * + +C no longer ignores the silent option + +=item * + +Both C and C files are now included in the distribution. + +=item * + +F will now correctly detect C when compiling with a C++ +compiler. + +=item * + +The pager detection in F has been improved to allow responses which +specify options after the program name, e.g. B, if the user +accepts the default value. This helps B when handling ANSI escapes +[perl #72156]. + +=back + +=head1 Testing + +=over 4 + +=item * + +The test suite now has a section for tests that require very large amounts +of memory. These tests won't run by default; they can be enabled by +setting the C environment variable to the number of +gibibytes of memory that may be safely used. + +=back + +=head1 Platform Support + +=head2 Discontinued Platforms + +=over 4 + +=item BeOS + +BeOS was an operating system for personal computers developed by Be Inc, +initially for their BeBox hardware. The OS Haiku was written as an open +source replacement for/continuation of BeOS, and its perl port is current and +actively maintained. + +=item UTS Global + +Support code relating to UTS global has been removed. UTS was a mainframe +version of System V created by Amdahl, subsequently sold to UTS Global. The +port has not been touched since before Perl v5.8.0, and UTS Global is now +defunct. + +=item VM/ESA + +Support for VM/ESA has been removed. The port was tested on 2.3.0, which +IBM ended service on in March 2002. 2.4.0 ended service in June 2003, and +was superseded by Z/VM. The current version of Z/VM is V6.2.0, and scheduled +for end of service on 2015/04/30. + +=item MPE/IX + +Support for MPE/IX has been removed. + +=item EPOC + +Support code relating to EPOC has been removed. EPOC was a family of +operating systems developed by Psion for mobile devices. It was the +predecessor of Symbian. The port was last updated in April 2002. + +=item Rhapsody + +Support for Rhapsody has been removed. + +=back + +=head2 Platform-Specific Notes + +=head3 AIX + +Configure now always adds C<-qlanglvl=extc99> to the CC flags on AIX when +using xlC. This will make it easier to compile a number of XS-based modules +that assume C99 [perl #113778]. + +=head3 clang++ + +There is now a workaround for a compiler bug that prevented compiling +with clang++ since Perl v5.15.7 [perl #112786]. + +=head3 C++ + +When compiling the Perl core as C++ (which is only semi-supported), the +mathom functions are now compiled as C, to ensure proper +binary compatibility. (However, binary compatibility isn't generally +guaranteed anyway in the situations where this would matter.) + +=head3 Darwin + +Stop hardcoding an alignment on 8 byte boundaries to fix builds using +-Dusemorebits. + +=head3 Haiku + +Perl should now work out of the box on Haiku R1 Alpha 4. + +=head3 MidnightBSD + +C was removed from recent versions of MidnightBSD and older versions +work better with C. Threading is now enabled using C which +corrects build errors with threading enabled on 0.4-CURRENT. + +=head3 Solaris + +In Configure, avoid running sed commands with flags not supported on Solaris. + +=head3 VMS + +=over + +=item * + +Where possible, the case of filenames and command-line arguments is now +preserved by enabling the CRTL features C and +C at start-up time. The latter only takes effect +when extended parse is enabled in the process from which Perl is run. + +=item * + +The character set for Extended Filename Syntax (EFS) is now enabled by default +on VMS. Among other things, this provides better handling of dots in directory +names, multiple dots in filenames, and spaces in filenames. To obtain the old +behavior, set the logical name C to C. + +=item * + +Fixed linking on builds configured with C<-Dusemymalloc=y>. + +=item * + +Experimental support for building Perl with the HP C++ compiler is available +by configuring with C<-Dusecxx>. + +=item * + +All C header files from the top-level directory of the distribution are now +installed on VMS, providing consistency with a long-standing practice on other +platforms. Previously only a subset were installed, which broke non-core +extension builds for extensions that depended on the missing include files. + +=item * + +Quotes are now removed from the command verb (but not the parameters) for +commands spawned via C, backticks, or a piped C. Previously, +quotes on the verb were passed through to DCL, which would fail to recognize +the command. Also, if the verb is actually a path to an image or command +procedure on an ODS-5 volume, quoting it now allows the path to contain spaces. + +=item * + +The B build has been fixed for the HP C++ compiler on OpenVMS. + +=back + +=head3 Win32 + +=over + +=item * + +Perl can now be built using Microsoft's Visual C++ 2012 compiler by specifying +CCTYPE=MSVC110 (or MSVC110FREE if you are using the free Express edition for +Windows Desktop) in F. + +=item * + +The option to build without C has been removed. + +=item * + +Fixed a problem where perl could crash while cleaning up threads (including the +main thread) in threaded debugging builds on Win32 and possibly other platforms +[perl #114496]. + +=item * + +A rare race condition that would lead to L taking more +time than requested, and possibly even hanging, has been fixed [perl #33096]. + +=item * + +C on Win32 now attempts to set C<$!> to more appropriate values +based on the Win32 API error code. [perl #112272] + +Perl no longer mangles the environment block, e.g. when launching a new +sub-process, when the environment contains non-ASCII characters. Known +problems still remain, however, when the environment contains characters +outside of the current ANSI codepage (e.g. see the item about Unicode in +C<%ENV> in L). +[perl #113536] + +=item * + +Building perl with some Windows compilers used to fail due to a problem +with miniperl's C operator (which uses the C program) +deleting the PATH environment variable [perl #113798]. + +=item * + +A new makefile option, C, has been added to the Windows +makefiles. Set this to "define" when building a 32-bit perl if you want +it to use 64-bit integers. + +Machine code size reductions, already made to the DLLs of XS modules in +Perl v5.17.2, have now been extended to the perl DLL itself. + +Building with VC++ 6.0 was inadvertently broken in Perl v5.17.2 but has +now been fixed again. + +=back + +=head3 WinCE + +Building on WinCE is now possible once again, although more work is required +to fully restore a clean build. + +=head1 Internal Changes + +=over + +=item * + +Synonyms for the misleadingly named C have been created: +C and C. All three of these return the +number of the highest index in the array, not the number of elements it +contains. + +=item * + +SvUPGRADE() is no longer an expression. Originally this macro (and its +underlying function, sv_upgrade()) were documented as boolean, although +in reality they always croaked on error and never returned false. In 2005 +the documentation was updated to specify a void return value, but +SvUPGRADE() was left always returning 1 for backwards compatibility. This +has now been removed, and SvUPGRADE() is now a statement with no return +value. + +So this is now a syntax error: + + if (!SvUPGRADE(sv)) { croak(...); } + +If you have code like that, simply replace it with + + SvUPGRADE(sv); + +or to avoid compiler warnings with older perls, possibly + + (void)SvUPGRADE(sv); + +=item * + +Perl has a new copy-on-write mechanism that allows any SvPOK scalar to be +upgraded to a copy-on-write scalar. A reference count on the string buffer +is stored in the string buffer itself. This feature is B. + +It can be enabled in a perl build by running F with +B<-Accflags=-DPERL_NEW_COPY_ON_WRITE>, and we would encourage XS authors +to try their code with such an enabled perl, and provide feedback. +Unfortunately, there is not yet a good guide to updating XS code to cope +with COW. Until such a document is available, consult the perl5-porters +mailing list. + +It breaks a few XS modules by allowing copy-on-write scalars to go +through code paths that never encountered them before. + +=item * + +Copy-on-write no longer uses the SvFAKE and SvREADONLY flags. Hence, +SvREADONLY indicates a true read-only SV. + +Use the SvIsCOW macro (as before) to identify a copy-on-write scalar. + +=item * + +C is gone. + +=item * + +The private Perl_croak_no_modify has had its context parameter removed. It is +now has a void prototype. Users of the public API croak_no_modify remain +unaffected. + +=item * + +Copy-on-write (shared hash key) scalars are no longer marked read-only. +C returns false on such an SV, but C still returns +true. + +=item * + +A new op type, C has been introduced. The perl peephole +optimiser will, where possible, substitute a single padrange op for a +pushmark followed by one or more pad ops, and possibly also skipping list +and nextstate ops. In addition, the op can carry out the tasks associated +with the RHS of a C<< my(...) = @_ >> assignment, so those ops may be optimised +away too. + +=item * + +Case-insensitive matching inside a [bracketed] character class with a +multi-character fold no longer excludes one of the possibilities in the +circumstances that it used to. [perl #89774]. + +=item * + +C has been removed. + +=item * + +The regular expression engine no longer reads one byte past the end of the +target string. While for all internally well-formed scalars this should +never have been a problem, this change facilitates clever tricks with +string buffers in CPAN modules. [perl #73542] + +=item * + +Inside a BEGIN block, C now points to the currently-compiling +subroutine, rather than the BEGIN block itself. + +=item * + +C has been deprecated. + +=item * + +C now always returns a byte count and C a character +count. Previously, C and C were both buggy and would +sometimes returns bytes and sometimes characters. C no longer +assumes that its argument is in UTF-8. Neither of these creates UTF-8 caches +for tied or overloaded values or for non-PVs any more. + +=item * + +C now copies string buffers of shared hash key scalars when +called from XS modules [perl #79824]. + +=item * + +C and C are no longer used. They are now +#defined as 0. + +=item * + +The new C flag can be set by custom regular expression +engines to indicate that the execution of the regular expression may cause +variables to be modified. This lets C know to skip certain +optimisations. Perl's own regular expression engine sets this flag for the +special backtracking verbs that set $REGMARK and $REGERROR. + +=item * + +The APIs for accessing lexical pads have changed considerably. + +Cs are now longer Cs, but their own type instead. +Cs now contain a C and a C of Cs, +rather than Cs for the pad and the list of pad names. Cs, +Cs, and Cs are to be accessed as such through the +newly added pad API instead of the plain C and C APIs. See +L for details. + +=item * + +In the regex API, the numbered capture callbacks are passed an index +indicating what match variable is being accessed. There are special +index values for the C<$`, $&, $&> variables. Previously the same three +values were used to retrieve C<${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}> +too, but these have now been assigned three separate values. See +L. + +=item * + +C was previously a boolean indicating that any of +C<$`, $&, $&> had been seen; it now contains three one-bit flags +indicating the presence of each of the variables individually. + +=item * + +The C typemap entry now supports C<&{}> overloading and typeglobs, +just like C<&{...}> [perl #96872]. + +=item * + +The C flag to indicate overloading is now on the stash, not the +object. It is now set automatically whenever a method or @ISA changes, so +its meaning has changed, too. It now means "potentially overloaded". When +the overload table is calculated, the flag is automatically turned off if +there is no overloading, so there should be no noticeable slowdown. + +The staleness of the overload tables is now checked when overload methods +are invoked, rather than during C. + +"A" magic is gone. The changes to the handling of the C flag +eliminate the need for it. + +C has been removed as no longer necessary. For XS +modules, it is now a macro alias to C. + +The fallback overload setting is now stored in a stash entry separate from +overloadedness itself. + +=item * + +The character-processing code has been cleaned up in places. The changes +should be operationally invisible. + +=item * + +The C function was made a no-op in v5.16. It was simply disabled via +a C statement; the code was left in place. Now the code supporting +what C used to do has been removed. + +=item * + +Under threaded perls, there is no longer a separate PV allocated for every +COP to store its package name (C<< cop->stashpv >>). Instead, there is an +offset (C<< cop->stashoff >>) into the new C array, which +holds stash pointers. + +=item * + +In the pluggable regex API, the C struct has acquired a new +field C, which is currently just for perl's internal use, and +should be initialized to NULL by other regex plugin modules. + +=item * + +A new function C has been added to the API, but is considered +experimental. See L. + +=item * + +Perl used to implement get magic in a way that would sometimes hide bugs in +code that could call mg_get() too many times on magical values. This hiding of +errors no longer occurs, so long-standing bugs may become visible now. If +you see magic-related errors in XS code, check to make sure it, together +with the Perl API functions it uses, calls mg_get() only once on SvGMAGICAL() +values. + +=item * + +OP allocation for CVs now uses a slab allocator. This simplifies +memory management for OPs allocated to a CV, so cleaning up after a +compilation error is simpler and safer [perl #111462][perl #112312]. + +=item * + +C has been rewritten to work with the new slab +allocator, allowing it to catch more violations than before. + +=item * + +The old slab allocator for ops, which was only enabled for C +and C, has been retired. + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +Here document terminators no longer require a terminating newline character when +they occur at the end of a file. This was already the case at the end of a +string eval [perl #65838]. + +=item * + +C<-DPERL_GLOBAL_STRUCT> builds now free the global struct B +they've finished using it. + +=item * + +A trailing '/' on a path in @INC will no longer have an additional '/' +appended. + +=item * + +The C<:crlf> layer now works when unread data doesn't fit into its own +buffer. [perl #112244]. + +=item * + +C now handles UTF-8 encoded data. [perl #116322]. + +=item * + +A bug in the core typemap caused any C types that map to the T_BOOL core +typemap entry to not be set, updated, or modified when the T_BOOL variable was +used in an OUTPUT: section with an exception for RETVAL. T_BOOL in an INPUT: +section was not affected. Using a T_BOOL return type for an XSUB (RETVAL) +was not affected. A side effect of fixing this bug is, if a T_BOOL is specified +in the OUTPUT: section (which previous did nothing to the SV), and a read only +SV (literal) is passed to the XSUB, croaks like "Modification of a read-only +value attempted" will happen. [perl #115796] + +=item * + +On many platforms, providing a directory name as the script name caused perl +to do nothing and report success. It should now universally report an error +and exit nonzero. [perl #61362] + +=item * + +C under fatal warnings no longer crashes. It had +begun crashing in Perl v5.16. + +=item * + +Stashes blessed into each other +(C) no longer result in double +frees. This bug started happening in Perl v5.16. + +=item * + +Numerous memory leaks have been fixed, mostly involving fatal warnings and +syntax errors. + +=item * + +Some failed regular expression matches such as C<'f' =~ /../g> were not +resetting C. Also, "match-once" patterns (C) failed to reset +it, too, when invoked a second time [perl #23180]. + +=item * + +Several bugs involving C and C causing stale +MRO caches have been fixed. + +=item * + +Defining a subroutine when its typeglob has been aliased no longer results +in stale method caches. This bug was introduced in Perl v5.10. + +=item * + +Localising a typeglob containing a subroutine when the typeglob's package +has been deleted from its parent stash no longer produces an error. This +bug was introduced in Perl v5.14. + +=item * + +Under some circumstances, C would fail to reset method +caches upon scope exit. + +=item * + +C is no longer an error, but produces a warning (as before) and +is treated as C [perl #115818]. + +=item * + +C now calls FETCH before deciding what type of goto +(subroutine or label) this is. + +=item * + +Renaming packages through glob assignment +(C<*Foo:: = *Bar::; *Bar:: = *Baz::>) in combination with C and +C no longer makes threaded builds crash. + +=item * + +A number of bugs related to assigning a list to hash have been fixed. Many of +these involve lists with repeated keys like C<(1, 1, 1, 1)>. + +=over 4 + +=item * + +The expression C now returns C<4>, not C<2>. + +=item * + +The return value of C<%h = (1, 1, 1)> in list context was wrong. Previously +this would return C<(1, undef, 1)>, now it returns C<(1, undef)>. + +=item * + +Perl now issues the same warning on C<($s, %h) = (1, {})> as it does for +C<(%h) = ({})>, "Reference found where even-sized list expected". + +=item * + +A number of additional edge cases in list assignment to hashes were +corrected. For more details see commit 23b7025ebc. + +=back + +=item * + +Attributes applied to lexical variables no longer leak memory. +[perl #114764] + +=item * + +C, C, C, C, C or C followed by a +bareword (or version) and then an infix operator is no longer a syntax +error. It used to be for those infix operators (like C<+>) that have a +different meaning where a term is expected. [perl #105924] + +=item * + +C and C no longer produce erroneous +ambiguity warnings. [perl #107002] + +=item * + +Class method calls are now allowed on any string, and not just strings +beginning with an alphanumeric character. [perl #105922] + +=item * + +An empty pattern created with C used in C no longer triggers +the "empty pattern reuses last pattern" behaviour. [perl #96230] + +=item * + +Tying a hash during iteration no longer results in a memory leak. + +=item * + +Freeing a tied hash during iteration no longer results in a memory leak. + +=item * + +List assignment to a tied array or hash that dies on STORE no longer +results in a memory leak. + +=item * + +If the hint hash (C<%^H>) is tied, compile-time scope entry (which copies +the hint hash) no longer leaks memory if FETCH dies. [perl #107000] + +=item * + +Constant folding no longer inappropriately triggers the special +C behaviour. [perl #94490] + +=item * + +C, C, and similar constructs +now treat the argument to C as a simple scalar. [perl #97466] + +=item * + +Running a custom debugging that defines no C<*DB::DB> glob or provides a +subroutine stub for C<&DB::DB> no longer results in a crash, but an error +instead. [perl #114990] + +=item * + +C now matches its documentation. C only resets C +patterns when called with no argument. An empty string for an argument now +does nothing. (It used to be treated as no argument.) [perl #97958] + +=item * + +C with an argument returning an empty list no longer reads past the +end of the stack, resulting in erratic behaviour. [perl #77094] + +=item * + +C<--subname> no longer produces erroneous ambiguity warnings. +[perl #77240] + +=item * + +C is now allowed as a label or package name. This was inadvertently +broken when v-strings were added in Perl v5.6. [perl #56880] + +=item * + +C, C, C and C could be confused by ties, +overloading, references and typeglobs if the stringification of such +changed the internal representation to or from UTF-8. [perl #114410] + +=item * + +utf8::encode now calls FETCH and STORE on tied variables. utf8::decode now +calls STORE (it was already calling FETCH). + +=item * + +C<$tied =~ s/$non_utf8/$utf8/> no longer loops infinitely if the tied +variable returns a Latin-1 string, shared hash key scalar, or reference or +typeglob that stringifies as ASCII or Latin-1. This was a regression from +v5.12. + +=item * + +C without /e is now better at detecting when it needs to forego +certain optimisations, fixing some buggy cases: + +=over + +=item * + +Match variables in certain constructs (C<&&>, C<||>, C<..> and others) in +the replacement part; e.g., C. [perl #26986] + +=item * + +Aliases to match variables in the replacement. + +=item * + +C<$REGERROR> or C<$REGMARK> in the replacement. [perl #49190] + +=item * + +An empty pattern (C) that causes the last-successful pattern to +be used, when that pattern contains code blocks that modify the variables +in the replacement. + +=back + +=item * + +The taintedness of the replacement string no longer affects the taintedness +of the return value of C. + +=item * + +The C<$|> autoflush variable is created on-the-fly when needed. If this +happened (e.g., if it was mentioned in a module or eval) when the +currently-selected filehandle was a typeglob with an empty IO slot, it used +to crash. [perl #115206] + +=item * + +Line numbers at the end of a string eval are no longer off by one. +[perl #114658] + +=item * + +@INC filters (subroutines returned by subroutines in @INC) that set $_ to a +copy-on-write scalar no longer cause the parser to modify that string +buffer in place. + +=item * + +C no longer returns the undefined value if the object has +string overloading that returns undef. [perl #115260] + +=item * + +The use of C, the stash name lookup cache for method calls, has +been restored, + +Commit da6b625f78f5f133 in August 2011 inadvertently broke the code that looks +up values in C. As it's a only cache, quite correctly everything +carried on working without it. + +=item * + +The error "Can't localize through a reference" had disappeared in v5.16.0 +when C appeared on the last line of an lvalue subroutine. +This error disappeared for C<\local %$ref> in perl v5.8.1. It has now +been restored. + +=item * + +The parsing of here-docs has been improved significantly, fixing several +parsing bugs and crashes and one memory leak, and correcting wrong +subsequent line numbers under certain conditions. + +=item * + +Inside an eval, the error message for an unterminated here-doc no longer +has a newline in the middle of it [perl #70836]. + +=item * + +A substitution inside a substitution pattern (C) no longer +confuses the parser. + +=item * + +It may be an odd place to allow comments, but C has +always worked, I there happens to be a null character before the +first #. Now it works even in the presence of nulls. + +=item * + +An invalid range in C or C no longer results in a memory leak. + +=item * + +String eval no longer treats a semicolon-delimited quote-like operator at +the very end (C) as a syntax error. + +=item * + +C<< warn {$_ => 1} + 1 >> is no longer a syntax error. The parser used to +get confused with certain list operators followed by an anonymous hash and +then an infix operator that shares its form with a unary operator. + +=item * + +C<(caller $n)[6]> (which gives the text of the eval) used to return the +actual parser buffer. Modifying it could result in crashes. Now it always +returns a copy. The string returned no longer has "\n;" tacked on to the +end. The returned text also includes here-doc bodies, which used to be +omitted. + +=item * + +The UTF-8 position cache is now reset when accessing magical variables, to +avoid the string buffer and the UTF-8 position cache getting out of sync +[perl #114410]. + +=item * + +Various cases of get magic being called twice for magical UTF-8 +strings have been fixed. + +=item * + +This code (when not in the presence of C<$&> etc) + + $_ = 'x' x 1_000_000; + 1 while /(.)/; + +used to skip the buffer copy for performance reasons, but suffered from C<$1> +etc changing if the original string changed. That's now been fixed. + +=item * + +Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO +might attempt to allocate more memory. + +=item * + +In a regular expression, if something is quantified with C<{n,m}> where +C m>>, it can't possibly match. Previously this was a fatal +error, but now is merely a warning (and that something won't match). +[perl #82954]. + +=item * + +It used to be possible for formats defined in subroutines that have +subsequently been undefined and redefined to close over variables in the +wrong pad (the newly-defined enclosing sub), resulting in crashes or +"Bizarre copy" errors. + +=item * + +Redefinition of XSUBs at run time could produce warnings with the wrong +line number. + +=item * + +The %vd sprintf format does not support version objects for alpha versions. +It used to output the format itself (%vd) when passed an alpha version, and +also emit an "Invalid conversion in printf" warning. It no longer does, +but produces the empty string in the output. It also no longer leaks +memory in this case. + +=item * + +C<< $obj->SUPER::method >> calls in the main package could fail if the +SUPER package had already been accessed by other means. + +=item * + +Stash aliasing (C<< *foo:: = *bar:: >>) no longer causes SUPER calls to ignore +changes to methods or @ISA or use the wrong package. + +=item * + +Method calls on packages whose names end in ::SUPER are no longer treated +as SUPER method calls, resulting in failure to find the method. +Furthermore, defining subroutines in such packages no longer causes them to +be found by SUPER method calls on the containing package [perl #114924]. + +=item * + +C<\w> now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D +(ZERO WIDTH JOINER). C<\W> no longer matches these. This change is because +Unicode corrected their definition of what C<\w> should match. + +=item * + +C no longer leaks its label. + +=item * + +Constant folding no longer changes the behaviour of functions like C +and C that can take either filenames or handles. +C nows treats its argument as a file name (since it is an +arbitrary expression), rather than the handle "foo". + +=item * + +C no longer falls back to treating "FOO" as a file name if +the filehandle has been deleted. This was broken in Perl v5.16.0. + +=item * + +Subroutine redefinitions after sub-to-glob and glob-to-glob assignments no +longer cause double frees or panic messages. + +=item * + +C now turns vstrings into plain strings when performing a substitution, +even if the resulting string is the same (C). + +=item * + +Prototype mismatch warnings no longer erroneously treat constant subs as having +no prototype when they actually have "". + +=item * + +Constant subroutines and forward declarations no longer prevent prototype +mismatch warnings from omitting the sub name. + +=item * + +C on a subroutine now clears call checkers. + +=item * + +The C operator started leaking memory on blessed objects in Perl v5.16.0. +This has been fixed [perl #114340]. + +=item * + +C no longer tries to parse its arguments as a statement, making +C a syntax error [perl #114222]. + +=item * + +On debugging builds, "uninitialized" warnings inside formats no longer cause +assertion failures. + +=item * + +On debugging builds, subroutines nested inside formats no longer cause +assertion failures [perl #78550]. + +=item * + +Formats and C statements are now permitted inside formats. + +=item * + +C and C()> now always produce the same output. +It was possible for the latter to refuse to close over $x if the variable was +not active; e.g., if it was defined outside a currently-running named +subroutine. + +=item * + +Similarly, C and C now produce the same output. +This also allows "my $x if 0" variables to be seen in the debugger [perl +#114018]. + +=item * + +Formats called recursively no longer stomp on their own lexical variables, but +each recursive call has its own set of lexicals. + +=item * + +Attempting to free an active format or the handle associated with it no longer +results in a crash. + +=item * + +Format parsing no longer gets confused by braces, semicolons and low-precedence +operators. It used to be possible to use braces as format delimiters (instead +of C<=> and C<.>), but only sometimes. Semicolons and low-precedence operators +in format argument lines no longer confuse the parser into ignoring the line's +return value. In format argument lines, braces can now be used for anonymous +hashes, instead of being treated always as C blocks. + +=item * + +Formats can now be nested inside code blocks in regular expressions and other +quoted constructs (C and C) [perl #114040]. + +=item * + +Formats are no longer created after compilation errors. + +=item * + +Under debugging builds, the B<-DA> command line option started crashing in Perl +v5.16.0. It has been fixed [perl #114368]. + +=item * + +A potential deadlock scenario involving the premature termination of a pseudo- +forked child in a Windows build with ithreads enabled has been fixed. This +resolves the common problem of the F test hanging on Windows [perl +#88840]. + +=item * + +The code which generates errors from C could potentially read one or +two bytes before the start of the filename for filenames less than three bytes +long and ending C. This has now been fixed. Note that it could +never have happened with module names given to C or C anyway. + +=item * + +The handling of pathnames of modules given to C has been made +thread-safe on VMS. + +=item * + +Non-blocking sockets have been fixed on VMS. + +=item * + +Pod can now be nested in code inside a quoted construct outside of a string +eval. This used to work only within string evals [perl #114040]. + +=item * + +C now looks for an empty label, producing the "goto must have +label" error message, instead of exiting the program [perl #111794]. + +=item * + +C now dies with "Can't find label" instead of "goto must have +label". + +=item * + +The C function C used to result in crashes when used on C<%^H> +[perl #111000]. + +=item * + +A call checker attached to a closure prototype via C +is now copied to closures cloned from it. So C now +works inside an attribute handler for a closure. + +=item * + +Writing to C<$^N> used to have no effect. Now it croaks with "Modification +of a read-only value" by default, but that can be overridden by a custom +regular expression engine, as with C<$1> [perl #112184]. + +=item * + +C on a control character glob (C) no longer emits an +erroneous warning about ambiguity [perl #112456]. + +=item * + +For efficiency's sake, many operators and built-in functions return the +same scalar each time. Lvalue subroutines and subroutines in the CORE:: +namespace were allowing this implementation detail to leak through. +C used to print "BB". The same thing +would happen with an lvalue subroutine returning the return value of C. +Now the value is copied in such cases. + +=item * + +C syntax with an empty block or a block returning an empty list +used to crash or use some random value left on the stack as its invocant. +Now it produces an error. + +=item * + +C now works with extremely large offsets (E2 GB) [perl #111730]. + +=item * + +Changes to overload settings now take effect immediately, as do changes to +inheritance that affect overloading. They used to take effect only after +C. + +Objects that were created before a class had any overloading used to remain +non-overloaded even if the class gained overloading through C +or @ISA changes, and even after C. This has been fixed +[perl #112708]. + +=item * + +Classes with overloading can now inherit fallback values. + +=item * + +Overloading was not respecting a fallback value of 0 if there were +overloaded objects on both sides of an assignment operator like C<+=> +[perl #111856]. + +=item * + +C now croaks with hash and array arguments, instead of producing +erroneous warnings. + +=item * + +C now implies C, like +C and C. + +=item * + +Subs in the CORE:: namespace no longer crash after C when called +with no argument list (C<&CORE::time> with no parentheses). + +=item * + +C no longer produces the "'/' must follow a numeric type in unpack" +error when it is the data that are at fault [perl #60204]. + +=item * + +C and C<"@array"> now call FETCH only once on a tied C<$"> +[perl #8931]. + +=item * + +Some subroutine calls generated by compiling core ops affected by a +C override had op checking performed twice. The checking +is always idempotent for pure Perl code, but the double checking can +matter when custom call checkers are involved. + +=item * + +A race condition used to exist around fork that could cause a signal sent to +the parent to be handled by both parent and child. Signals are now blocked +briefly around fork to prevent this from happening [perl #82580]. + +=item * + +The implementation of code blocks in regular expressions, such as C<(?{})> +and C<(??{})>, has been heavily reworked to eliminate a whole slew of bugs. +The main user-visible changes are: + +=over 4 + +=item * + +Code blocks within patterns are now parsed in the same pass as the +surrounding code; in particular it is no longer necessary to have balanced +braces: this now works: + + /(?{ $x='{' })/ + +This means that this error message is no longer generated: + + Sequence (?{...}) not terminated or not {}-balanced in regex + +but a new error may be seen: + + Sequence (?{...}) not terminated with ')' + +In addition, literal code blocks within run-time patterns are only +compiled once, at perl compile-time: + + for my $p (...) { + # this 'FOO' block of code is compiled once, + # at the same time as the surrounding 'for' loop + /$p{(?{FOO;})/; + } + +=item * + +Lexical variables are now sane as regards scope, recursion and closure +behavior. In particular, C behaves (from a closure viewpoint) +exactly like C, while C is like +C. So this code now works how you might +expect, creating three regexes that match 0, 1, and 2: + + for my $i (0..2) { + push @r, qr/^(??{$i})$/; + } + "1" =~ $r[1]; # matches + +=item * + +The C pragma is now only required for code blocks defined +at runtime; in particular in the following, the text of the C<$r> pattern is +still interpolated into the new pattern and recompiled, but the individual +compiled code-blocks within C<$r> are reused rather than being recompiled, +and C isn't needed any more: + + my $r = qr/abc(?{....})def/; + /xyz$r/; + +=item * + +Flow control operators no longer crash. Each code block runs in a new +dynamic scope, so C etc. will not see +any enclosing loops. C returns a value +from the code block, not from any enclosing subroutine. + +=item * + +Perl normally caches the compilation of run-time patterns, and doesn't +recompile if the pattern hasn't changed, but this is now disabled if +required for the correct behavior of closures. For example: + + my $code = '(??{$x})'; + for my $x (1..3) { + # recompile to see fresh value of $x each time + $x =~ /$code/; + } + +=item * + +The C and C<(?msix)> etc. flags are now propagated into the return +value from C<(??{})>; this now works: + + "AB" =~ /a(??{'b'})/i; + +=item * + +Warnings and errors will appear to come from the surrounding code (or for +run-time code blocks, from an eval) rather than from an C: + + use re 'eval'; $c = '(?{ warn "foo" })'; /$c/; + /(?{ warn "foo" })/; + +formerly gave: + + foo at (re_eval 1) line 1. + foo at (re_eval 2) line 1. + +and now gives: + + foo at (eval 1) line 1. + foo at /some/prog line 2. + +=back + +=item * + +Perl now can be recompiled to use any Unicode version. In v5.16, it +worked on Unicodes 6.0 and 6.1, but there were various bugs if earlier +releases were used; the older the release the more problems. + +=item * + +C no longer produces "uninitialized" warnings in lvalue context +[perl #9423]. + +=item * + +An optimization involving fixed strings in regular expressions could cause +a severe performance penalty in edge cases. This has been fixed +[perl #76546]. + +=item * + +In certain cases, including empty subpatterns within a regular expression (such +as C<(?:)> or C<(?:|)>) could disable some optimizations. This has been fixed. + +=item * + +The "Can't find an opnumber" message that C produces when passed +a string like "CORE::nonexistent_keyword" now passes UTF-8 and embedded +NULs through unchanged [perl #97478]. + +=item * + +C now treats magical variables like C<$1> the same way as +non-magical variables when checking for the CORE:: prefix, instead of +treating them as subroutine names. + +=item * + +Under threaded perls, a runtime code block in a regular expression could +corrupt the package name stored in the op tree, resulting in bad reads +in C, and possibly crashes [perl #113060]. + +=item * + +Referencing a closure prototype (C<\&{$_[1]}> in an attribute handler for a +closure) no longer results in a copy of the subroutine (or assertion +failures on debugging builds). + +=item * + +C now returns the right answer on threaded builds if +the current package has been assigned over (as in +C<*ThisPackage:: = *ThatPackage::>) [perl #78742]. + +=item * + +If a package is deleted by code that it calls, it is possible for C +to see a stack frame belonging to that deleted package. C could +crash if the stash's memory address was reused for a scalar and a +substitution was performed on the same scalar [perl #113486]. + +=item * + +C no longer treats its first argument differently +depending on whether it is a string or number internally. + +=item * + +C with C<< <& >> for the mode checks to see whether the third argument is +a number, in determining whether to treat it as a file descriptor or a handle +name. Magical variables like C<$1> were always failing the numeric check and +being treated as handle names. + +=item * + +C's handling of magical variables (C<$1>, ties) has undergone several +fixes. C is only called once now on a tied argument or a tied C<$@> +[perl #97480]. Tied variables returning objects that stringify as "" are +no longer ignored. A tied C<$@> that happened to return a reference the +I time it was used is no longer ignored. + +=item * + +C now treats C<$@> with a number in it the same way, regardless of +whether it happened via C<$@=3> or C<$@="3">. It used to ignore the +former. Now it appends "\t...caught", as it has always done with +C<$@="3">. + +=item * + +Numeric operators on magical variables (e.g., S>) used to use +floating point operations even where integer operations were more appropriate, +resulting in loss of accuracy on 64-bit platforms [perl #109542]. + +=item * + +Unary negation no longer treats a string as a number if the string happened +to be used as a number at some point. So, if C<$x> contains the string "dogs", +C<-$x> returns "-dogs" even if C<$y=0+$x> has happened at some point. + +=item * + +In Perl v5.14, C<-'-10'> was fixed to return "10", not "+10". But magical +variables (C<$1>, ties) were not fixed till now [perl #57706]. + +=item * + +Unary negation now treats strings consistently, regardless of the internal +C flag. + +=item * + +A regression introduced in Perl v5.16.0 involving +C/I/> has been fixed. Only the first +instance is supposed to be meaningful if a character appears more than +once in C>. Under some circumstances, the final instance +was overriding all earlier ones. [perl #113584] + +=item * + +Regular expressions like C previously silently inserted a NUL +character, thus matching as if it had been written C. Now it +matches as if it had been written as C, with a message that the +sequence C<"\8"> is unrecognized. + +=item * + +C<__SUB__> now works in special blocks (C, C, etc.). + +=item * + +Thread creation on Windows could theoretically result in a crash if done +inside a C block. It still does not work properly, but it no longer +crashes [perl #111610]. + +=item * + +C<\&{''}> (with the empty string) now autovivifies a stub like any other +sub name, and no longer produces the "Unable to create sub" error +[perl #94476]. + +=item * + +A regression introduced in v5.14.0 has been fixed, in which some calls +to the C module would clobber C<$_> [perl #113750]. + +=item * + +C now always either sets or clears C<$@>, even when the file can't be +read. This ensures that testing C<$@> first (as recommended by the +documentation) always returns the correct result. + +=item * + +The array iterator used for the C construct is now correctly +reset when C<@array> is cleared [perl #75596]. This happens, for example, when +the array is globally assigned to, as in C<@array = (...)>, but not when its +B are assigned to. In terms of the XS API, it means that C +will now reset the iterator. + +This mirrors the behaviour of the hash iterator when the hash is cleared. + +=item * + +C<< $class->can >>, C<< $class->isa >>, and C<< $class->DOES >> now return +correct results, regardless of whether that package referred to by C<$class> +exists [perl #47113]. + +=item * + +Arriving signals no longer clear C<$@> [perl #45173]. + +=item * + +Allow C declarations with an empty variable list [perl #113554]. + +=item * + +During parsing, subs declared after errors no longer leave stubs +[perl #113712]. + +=item * + +Closures containing no string evals no longer hang on to their containing +subroutines, allowing variables closed over by outer subroutines to be +freed when the outer sub is freed, even if the inner sub still exists +[perl #89544]. + +=item * + +Duplication of in-memory filehandles by opening with a "<&=" or ">&=" mode +stopped working properly in v5.16.0. It was causing the new handle to +reference a different scalar variable. This has been fixed [perl #113764]. + +=item * + +C expressions no longer crash with custom regular expression engines +that do not set C at regular expression compilation time +[perl #112962]. + +=item * + +C no longer crashes with certain magical arrays and hashes +[perl #112966]. + +=item * + +C on elements of certain magical arrays and hashes used not to +arrange to have the element deleted on scope exit, even if the element did +not exist before C. + +=item * + +C no longer returns multiple items [perl #73690]. + +=item * + +String to floating point conversions no longer misparse certain strings under +C [perl #109318]. + +=item * + +C<@INC> filters that die no longer leak memory [perl #92252]. + +=item * + +The implementations of overloaded operations are now called in the correct +context. This allows, among other things, being able to properly override +C<< <> >> [perl #47119]. + +=item * + +Specifying only the C key when calling C now behaves +properly [perl #113010]. + +=item * + +C<< sub foo { my $a = 0; while ($a) { ... } } >> and +C<< sub foo { while (0) { ... } } >> now return the same thing [perl #73618]. + +=item * + +String negation now behaves the same under C as it does +without [perl #113012]. + +=item * + +C now returns the Unicode replacement character (U+FFFD) for -1, +regardless of the internal representation. -1 used to wrap if the argument +was tied or a string internally. + +=item * + +Using a C after its enclosing sub was freed could crash as of +perl v5.12.0, if the format referenced lexical variables from the outer sub. + +=item * + +Using a C after its enclosing sub was undefined could crash as of +perl v5.10.0, if the format referenced lexical variables from the outer sub. + +=item * + +Using a C defined inside a closure, which format references +lexical variables from outside, never really worked unless the C +call was directly inside the closure. In v5.10.0 it even started crashing. +Now the copy of that closure nearest the top of the call stack is used to +find those variables. + +=item * + +Formats that close over variables in special blocks no longer crash if a +stub exists with the same name as the special block before the special +block is compiled. + +=item * + +The parser no longer gets confused, treating C as a syntax +error if preceded by C [perl #16249]. + +=item * + +The return value of C is no longer truncated on 64-bit platforms +[perl #113980]. + +=item * + +Constant folding no longer causes C to print to the +FOO handle [perl #78064]. + +=item * + +C now calls the named subroutine and uses the file name it +returns, instead of opening a file named "subname". + +=item * + +Subroutines looked up by rv2cv check hooks (registered by XS modules) are +now taken into consideration when determining whether C should be +the sub call C or the method call C<< "bar"->foo >>. + +=item * + +C is no longer treated specially, allowing global overrides +to be called directly via C [perl #113016]. + +=item * + +Calling an undefined sub whose typeglob has been undefined now produces the +customary "Undefined subroutine called" error, instead of "Not a CODE +reference". + +=item * + +Two bugs involving @ISA have been fixed. C<*ISA = *glob_without_array> and +C would prevent future modifications to @ISA from +updating the internal caches used to look up methods. The +*glob_without_array case was a regression from Perl v5.12. + +=item * + +Regular expression optimisations sometimes caused C<$> with C to +produce failed or incorrect matches [perl #114068]. + +=item * + +C<__SUB__> now works in a C block when the enclosing subroutine is +predeclared with C syntax [perl #113710]. + +=item * + +Unicode properties only apply to Unicode code points, which leads to +some subtleties when regular expressions are matched against +above-Unicode code points. There is a warning generated to draw your +attention to this. However, this warning was being generated +inappropriately in some cases, such as when a program was being parsed. +Non-Unicode matches such as C<\w> and C<[:word:]> should not generate the +warning, as their definitions don't limit them to apply to only Unicode +code points. Now the message is only generated when matching against +C<\p{}> and C<\P{}>. There remains a bug, [perl #114148], for the very +few properties in Unicode that match just a single code point. The +warning is not generated if they are matched against an above-Unicode +code point. + +=item * + +Uninitialized warnings mentioning hash elements would only mention the +element name if it was not in the first bucket of the hash, due to an +off-by-one error. + +=item * + +A regular expression optimizer bug could cause multiline "^" to behave +incorrectly in the presence of line breaks, such that +C<"/\n\n" =~ m#\A(?:^/$)#im> would not match [perl #115242]. + +=item * + +Failed C in list context no longer corrupts the stack. +C<@a = (1, 2, fork, 3)> used to gobble up the 2 and assign C<(1, undef, 3)> +if the C call failed. + +=item * + +Numerous memory leaks have been fixed, mostly involving tied variables that +die, regular expression character classes and code blocks, and syntax +errors. + +=item * + +Assigning a regular expression (C<${qr//}>) to a variable that happens to +hold a floating point number no longer causes assertion failures on +debugging builds. + +=item * + +Assigning a regular expression to a scalar containing a number no longer +causes subsequent numification to produce random numbers. + +=item * + +Assigning a regular expression to a magic variable no longer wipes away the +magic. This was a regression from v5.10. + +=item * + +Assigning a regular expression to a blessed scalar no longer results in +crashes. This was also a regression from v5.10. + +=item * + +Regular expression can now be assigned to tied hash and array elements with +flattening into strings. + +=item * + +Numifying a regular expression no longer results in an uninitialized +warning. + +=item * + +Negative array indices no longer cause EXISTS methods of tied variables to +be ignored. This was a regression from v5.12. + +=item * + +Negative array indices no longer result in crashes on arrays tied to +non-objects. + +=item * + +C<$byte_overload .= $utf8> no longer results in doubly-encoded UTF-8 if the +left-hand scalar happened to have produced a UTF-8 string the last time +overloading was invoked. + +=item * + +C now uses the current value of @_, instead of using the array +the subroutine was originally called with. This means +C now works [perl #43077]. + +=item * + +If a debugger is invoked recursively, it no longer stomps on its own +lexical variables. Formerly under recursion all calls would share the same +set of lexical variables [perl #115742]. + +=item * + +C<*_{ARRAY}> returned from a subroutine no longer spontaneously +becomes empty. + +=back + +=head1 Known Problems + +=over 4 + +=item * + +UTF8-flagged strings in C<%ENV> on HP-UX 11.00 are buggy + +The interaction of UTF8-flagged strings and C<%ENV> on HP-UX 11.00 is +currently dodgy in some not-yet-fully-diagnosed way. Expect test +failures in F, followed by unknown behavior when storing +wide characters in the environment. + +=back + +=head1 Obituary + +Hojung Yoon (AMORETTE), 24, of Seoul, South Korea, went to his long rest +on May 8, 2013 with llama figurine and autographed TIMTOADY card. He +was a brilliant young Perl 5 & 6 hacker and a devoted member of +Seoul.pm. He programmed Perl, talked Perl, ate Perl, and loved Perl. We +believe that he is still programming in Perl with his broken IBM laptop +somewhere. He will be missed. + +=head1 Acknowledgements + +Perl v5.18.0 represents approximately 12 months of development since +Perl v5.16.0 and contains approximately 400,000 lines of changes across +2,100 files from 113 authors. + +Perl continues to flourish into its third decade thanks to a vibrant +community of users and developers. The following people are known to +have contributed the improvements that became Perl v5.18.0: + +Aaron Crane, Aaron Trevena, Abhijit Menon-Sen, Adrian M. Enache, Alan +Haggai Alavi, Alexandr Ciornii, Andrew Tam, Andy Dougherty, Anton Nikishaev, +Aristotle Pagaltzis, Augustina Blair, Bob Ernst, Brad Gilbert, Breno G. de +Oliveira, Brian Carlson, Brian Fraser, Charlie Gonzalez, Chip Salzenberg, Chris +'BinGOs' Williams, Christian Hansen, Colin Kuskie, Craig A. Berry, Dagfinn +Ilmari Mannsåker, Daniel Dragan, Daniel Perrett, Darin McBride, Dave Rolsky, +David Golden, David Leadbeater, David Mitchell, David Nicol, Dominic +Hargreaves, E. Choroba, Eric Brine, Evan Miller, Father Chrysostomos, Florian +Ragwitz, François Perrad, George Greer, Goro Fuji, H.Merijn Brand, Herbert +Breunung, Hugo van der Sanden, Igor Zaytsev, James E Keenan, Jan Dubois, +Jasmine Ahuja, Jerry D. Hedden, Jess Robinson, Jesse Luehrs, Joaquin Ferrero, +Joel Berger, John Goodyear, John Peacock, Karen Etheridge, Karl Williamson, +Karthik Rajagopalan, Kent Fredric, Leon Timmermans, Lucas Holt, Lukas Mai, +Marcus Holland-Moritz, Markus Jansen, Martin Hasch, Matthew Horsfall, Max +Maischein, Michael G Schwern, Michael Schroeder, Moritz Lenz, Nicholas Clark, +Niko Tyni, Oleg Nesterov, Patrik Hägglund, Paul Green, Paul Johnson, Paul +Marquess, Peter Martini, Rafael Garcia-Suarez, Reini Urban, Renee Baecker, +Rhesa Rozendaal, Ricardo Signes, Robin Barker, Ronald J. Kimball, Ruslan +Zakirov, Salvador Fandiño, Sawyer X, Scott Lanning, Sergey Alekseev, Shawn M +Moore, Shirakata Kentaro, Shlomi Fish, Sisyphus, Smylers, Steffen Müller, +Steve Hay, Steve Peters, Steven Schubiger, Sullivan Beck, Sven Strickroth, +Sébastien Aperghis-Tramoni, Thomas Sibley, Tobias Leich, Tom Wyant, Tony Cook, +Vadim Konovalov, Vincent Pit, Volker Schatz, Walt Mankowski, Yves Orton, +Zefram. + +The list above is almost certainly incomplete as it is automatically generated +from version control history. In particular, it does not include the names of +the (very much appreciated) contributors who reported issues to the Perl bug +tracker. + +Many of the changes included in this version originated in the CPAN modules +included in Perl's core. We're grateful to the entire CPAN community for +helping Perl to flourish. + +For a more complete list of all of Perl's historical contributors, please see +the F file in the Perl source distribution. + +=head1 Reporting Bugs + +If you find what you think is a bug, you might check the articles recently +posted to the comp.lang.perl.misc newsgroup and the perl bug database at +http://rt.perl.org/perlbug/ . There may also be information at +http://www.perl.org/ , the Perl Home Page. + +If you believe you have an unreported bug, please run the L program +included with your release. Be sure to trim your bug down to a tiny but +sufficient test case. Your bug report, along with the output of C, +will be sent off to perlbug@perl.org to be analysed by the Perl porting team. + +If the bug you are reporting has security implications, which make it +inappropriate to send to a publicly archived mailing list, then please send it +to perl5-security-report@perl.org. This points to a closed subscription +unarchived mailing list, which includes all the core committers, who will be +able to help assess the impact of issues, figure out a resolution, and help +co-ordinate the release of patches to mitigate or fix the problem across all +platforms on which Perl is supported. Please only use this address for +security issues in the Perl core, not for modules independently distributed on +CPAN. + +=head1 SEE ALSO + +The F file for an explanation of how to view exhaustive details on +what changed. + +The F file for how to build Perl. + +The F file for general stuff. + +The F and F files for copyright information. + +=cut -- cgit v1.2.1