=encoding utf8
-=for comment
-This has been completed up to 007f907 except for:
-b3dbdd48ca2da90bce7f16d545cca54c3dc58f35 (Leon Timmermans)
-816005240f1a3b9989c940e630e829048597537c (Craig Berry)
-44caa20c7d9248fd77483468d77c9b5835e7066e (Craig Berry)
-4581ada393ba58f2b8f438c7b9c336d6c79ec94c (Craig Berry)
-3b28d668e9efe9433c3099521167a6723cbddc26 (Craig Berry)
-and any bugs that Karl Williamson has fixed.
+=head1 NAME
+
+perldelta - what is new for perl v5.14.0
+
+=head1 DESCRIPTION
+
+This document describes differences between the 5.12.0 release and
+the 5.14.0 release.
+
+If you are upgrading from an earlier release such as 5.10.0, first read
+L<perl5120delta>, which describes differences between 5.10.0 and
+5.12.0.
+
+Some of the bug fixes in this release have been backported to subsequent
+releases of 5.12.x. Those are indicated with the 5.12.x version in
+parentheses.
+
+=head1 Notice
+
+XXX Any important notices here
+
+=head1 Core Enhancements
+
+=head2 Unicode
+
+=head3 Unicode Version 6.0 is now supported (mostly)
+
+Perl comes with the Unicode 6.0 data base updated with
+L<Corrigendum #8|http://www.unicode.org/versions/corrigendum8.html>,
+with one exception noted below.
+See L<http://unicode.org/versions/Unicode6.0.0> for details on the new
+release. Perl does not support any Unicode provisional properties,
+including the new ones for this release.
+
+Unicode 6.0 has chosen to use the name C<BELL> for the character at U+1F514,
+which is a symbol that looks like a bell, and is used in Japanese cell
+phones. This conflicts with the long-standing Perl usage of having
+C<BELL> mean the ASCII C<BEL> character, U+0007. In Perl 5.14,
+C<\N{BELL}> will continue to mean U+0007, but its use will generate a
+deprecated warning message, unless such warnings are turned off. The
+new name for U+0007 in Perl will be C<ALERT>, which corresponds nicely
+with the existing shorthand sequence for it, C<"\a">. C<\N{BEL}> will
+mean U+0007, with no warning given. The character at U+1F514 will not
+have a name in 5.14, but can be referred to by C<\N{U+1F514}>. The plan
+is that in Perl 5.16, C<\N{BELL}> will refer to U+1F514, and so all code
+that uses C<\N{BELL}> should convert by then to using C<\N{ALERT}>,
+C<\N{BEL}>, or C<"\a"> instead.
+
+=head3 Full functionality for C<use feature 'unicode_strings'>
+
+This release provides full functionality for C<use feature
+'unicode_strings'>. Under its scope, all string operations executed and
+regular expressions compiled (even if executed outside its scope) have
+Unicode semantics. See L<feature>.
+
+This feature avoids most forms of the "Unicode Bug" (See
+L<perlunicode/The "Unicode Bug"> for details.) If there is a
+possibility that your code will process Unicode strings, you are
+B<strongly> encouraged to use this subpragma to avoid nasty surprises.
+
+=head3 C<\N{I<name>}> and C<charnames> enhancements
+
+=over
+
+=item *
+
+C<\N{}> and C<charnames::vianame> now know about the abbreviated
+character names listed by Unicode, such as NBSP, SHY, LRO, ZWJ, etc., all
+the customary abbreviations for the C0 and C1 control characters (such as
+ACK, BEL, CAN, etc.), and a few new variants of some C1 full names that
+are in common usage.
+
+=item *
+
+Unicode has a number of named character sequences, in which particular sequences
+of code points are given names. C<\N{...}> now recognizes these.
+
+=item *
+
+C<\N{}>, C<charnames::vianame>, C<charnames::viacode> now know about every
+character in Unicode. Previously, they didn't know about the Hangul syllables
+nor a number of CJK (Chinese/Japanese/Korean) characters.
+
+=item *
+
+In the past, it was ineffective to override one of Perl's abbreviations
+with your own custom alias. Now it works.
+
+=item *
+
+You can also create a custom alias of the ordinal of a
+character, known by C<\N{...}>, C<charnames::vianame()>, and
+C<charnames::viacode()>. Previously, an alias had to be to an official
+Unicode character name. This made it impossible to create an alias for
+a code point that had no name, such as those reserved for private
+use.
+
+=item *
+
+A new function, C<charnames::string_vianame()>, has been added.
+This function is a run-time version of C<\N{...}>, returning the string
+of characters whose Unicode name is its parameter. It can handle
+Unicode named character sequences, whereas the pre-existing
+C<charnames::vianame()> cannot, as the latter returns a single code
+point.
+
+=back
+
+See L<charnames> for details on all these changes.
+
+=head3 New warnings categories for problematic (non-)Unicode code points.
+
+Three new warnings subcategories of "utf8" have been added. These
+allow you to turn off some "utf8" warnings, while allowing
+others warnings to remain on. The three categories are:
+C<surrogate> when UTF-16 surrogates are encountered;
+C<nonchar> when Unicode non-character code points are encountered;
+and C<non_unicode> when code points that are above the legal Unicode
+maximum of 0x10FFFF are encountered.
+
+=head3 Any unsigned value can be encoded as a character
+
+With this release, Perl is adopting a model that any unsigned value can
+be treated as a code point and encoded internally (as utf8) without
+warnings - not just the code points that are legal in Unicode.
+However, unless utf8 or the corresponding sub-category (see previous
+item) warnings have been
+explicitly lexically turned off, outputting or performing a
+Unicode-defined operation (such as upper-casing) on such a code point
+will generate a warning. Attempting to input these using strict rules
+(such as with the C<:encoding('UTF-8')> layer) will continue to fail.
+Prior to this release the handling was very inconsistent, and incorrect
+in places. Also, the Unicode non-characters, some of which previously were
+erroneously considered illegal in places by Perl, contrary to the Unicode
+standard, are now always legal internally. But inputting or outputting
+them will work the same as for the non-legal Unicode code points, as the
+Unicode standard says they are illegal for "open interchange".
+
+=head3 Unicode database files not installed
+
+The Unicode database files are no longer installed with Perl. This
+doesn't affect any functionality in Perl and saves significant disk
+space. If you previously were explicitly opening and reading those
+files, you can download them from
+L<http://www.unicode.org/Public/zipped/6.0.0/>.
+
+=head2 Regular Expressions
+
+=head3 C<(?^...)> construct to signify default modifiers
+
+An ASCII caret (also called a "circumflex accent") C<"^">
+immediately following a C<"(?"> in a regular expression
+now means that the subexpression does not inherit the
+surrounding modifiers such as C</i>, but reverts to the
+Perl defaults. Any modifiers following the caret override the defaults.
+
+The stringification of regular expressions now uses this
+notation. E.g., before, C<qr/hlagh/i> would be stringified as
+C<(?i-xsm:hlagh)>, but now it's stringified as C<(?^i:hlagh)>.
+
+The main purpose of this is to allow tests that rely on the
+stringification not to have to change when new modifiers are added.
+See L<perlre/Extended Patterns>.
+
+=head3 C</d>, C</l>, C</u>, C</a>, and C</aa> modifiers
+
+Four new regular expression modifiers have been added. These are mutually
+exclusive; one only can be turned on at a time.
+
+The C</l> modifier says to compile the regular expression as if it were
+in the scope of C<use locale>, even if it is not.
+
+The C</u> modifier says to compile the regular expression as if it were
+in the scope of a C<use feature "unicode_strings"> pragma.
+
+The C</d> (default) modifier is used to override any C<use locale> and
+C<use feature "unicode_strings"> pragmas that are in effect at the time
+of compiling the regular expression.
+
+The C</a> regular expression modifier restricts C<\s>, C<\d> and C<\w> and
+the Posix (C<[[:posix:]]>) character classes to the ASCII range. Their
+complements and C<\b> and C<\B> are correspondingly
+affected. Otherwise, C</a> behaves like the C</u> modifier, in that
+case-insensitive matching uses Unicode semantics.
+
+The C</aa> modifier is like C</a>, except that, in case-insensitive matching, no ASCII character will match a
+non-ASCII character. For example,
+
+ 'k' =~ /\N{KELVIN SIGN}/ai
+
+will match; it won't under C</aa>.
+
+See L<perlre/Modifiers> for more detail.
+
+=head3 Non-destructive substitution
+
+The substitution (C<s///>) and transliteration
+(C<y///>) operators now support an C</r> option that
+copies the input variable, carries out the substitution on
+the copy and returns the result. The original remains unmodified.
+
+ my $old = 'cat';
+ my $new = $old =~ s/cat/dog/r;
+ # $old is 'cat' and $new is 'dog'
+
+This is particularly useful with C<map>. See L<perlop> for more examples.
+
+=head3 Reentrant regular expression engine
+
+It is now safe to use regular expressions within C<(?{...})> and
+C<(??{...})> code blocks inside regular expressions.
+
+These block are still experimental, however, and still have problems with
+lexical (C<my>) variables and abnormal exiting.
+
+=head3 C<use re '/flags';>
+
+The C<re> pragma now has the ability to turn on regular expression flags
+till the end of the lexical scope:
+
+ use re '/x';
+ "foo" =~ / (.+) /; # /x implied
+
+See L<re/"'/flags' mode"> for details.
+
+=head3 \o{...} for octals
+
+There is a new octal escape sequence, C<"\o">, in double-quote-like
+contexts. This construct allows large octal ordinals beyond the
+current max of 0777 to be represented. It also allows you to specify a
+character in octal which can safely be concatenated with other regex
+snippets and which won't be confused with being a backreference to
+a regex capture group. See L<perlre/Capture groups>.
+
+=head3 Add C<\p{Titlecase}> as a synonym for C<\p{Title}>
+
+This synonym is added for symmetry with the Unicode property names
+C<\p{Uppercase}> and C<\p{Lowercase}>.
+
+=head3 Regular expression debugging output improvement
+
+Regular expression debugging output (turned on by C<use re 'debug';>) now
+uses hexadecimal when escaping non-ASCII characters, instead of octal.
+
+=head3 Return value of C<delete $+{...}>
+
+Custom regular expression engines can now determine the return value of
+C<delete> on an entry of C<%+> or C<%->.
+
+=head2 Syntactical Enhancements
+
+=head3 Array and hash container functions accept references
+
+All built-in functions that operate directly on array or hash
+containers now also accept hard references to arrays or hashes:
+
+ |----------------------------+---------------------------|
+ | Traditional syntax | Terse syntax |
+ |----------------------------+---------------------------|
+ | push @$arrayref, @stuff | push $arrayref, @stuff |
+ | unshift @$arrayref, @stuff | unshift $arrayref, @stuff |
+ | pop @$arrayref | pop $arrayref |
+ | shift @$arrayref | shift $arrayref |
+ | splice @$arrayref, 0, 2 | splice $arrayref, 0, 2 |
+ | keys %$hashref | keys $hashref |
+ | keys @$arrayref | keys $arrayref |
+ | values %$hashref | values $hashref |
+ | values @$arrayref | values $arrayref |
+ | ($k,$v) = each %$hashref | ($k,$v) = each $hashref |
+ | ($k,$v) = each @$arrayref | ($k,$v) = each $arrayref |
+ |----------------------------+---------------------------|
+
+This allows these built-in functions to act on long dereferencing chains
+or on the return value of subroutines without needing to wrap them in
+C<@{}> or C<%{}>:
+
+ push @{$obj->tags}, $new_tag; # old way
+ push $obj->tags, $new_tag; # new way
+
+ for ( keys %{$hoh->{genres}{artists}} ) {...} # old way
+ for ( keys $hoh->{genres}{artists} ) {...} # new way
+
+For C<push>, C<unshift> and C<splice>, the reference will auto-vivify
+if it is not defined, just as if it were wrapped with C<@{}>.
+
+For C<keys>, C<values>, C<each>, when overloaded dereferencing is
+present, the overloaded dereference is used instead of dereferencing the
+underlying reftype. Warnings are issued about assumptions made in
+ambiguous cases.
+
+=head3 Single term prototype
+
+The C<+> prototype is a special alternative to C<$> that will act like
+C<\[@%]> when given a literal array or hash variable, but will otherwise
+force scalar context on the argument. See L<perlsub/Prototypes>.
+
+=head3 C<package> block syntax
+
+A package declaration can now contain a code block, in which case the
+declaration is in scope only inside that block. So C<package Foo { ... }>
+is precisely equivalent to C<{ package Foo; ... }>. It also works with
+a version number in the declaration, as in C<package Foo 1.2 { ... }>.
+See L<perlfunc>.
+
+=head3 Statement labels can appear in more places
+
+Statement labels can now occur before any type of statement or declaration,
+such as C<package>.
+
+=head3 Stacked labels
+
+Multiple statement labels can now appear before a single statement.
+
+=head3 Uppercase X/B allowed in hexadecimal/binary literals
+
+Literals may now use either upper case C<0X...> or C<0B...> prefixes,
+in addition to the already supported C<0x...> and C<0b...>
+syntax [perl #76296].
+
+C, Ruby, Python and PHP already supported this syntax, and it makes
+Perl more internally consistent. A round-trip with C<eval sprintf
+"%#X", 0x10> now returns C<16>, the way C<eval sprintf "%#x", 0x10> does.
+
+=head3 Overridable tie functions
+
+C<tie>, C<tied> and C<untie> can now be overridden [perl #75902].
+
+=head2 Exception Handling
+
+Several changes have been made to the way C<die>, C<warn>, and C<$@>
+behave, in order to make them more reliable and consistent.
+
+When an exception is thrown inside an C<eval>, the exception is no
+longer at risk of being clobbered by code running during unwinding
+(e.g., destructors). Previously, the exception was written into C<$@>
+early in the throwing process, and would be overwritten if C<eval> was
+used internally in the destructor for an object that had to be freed
+while exiting from the outer C<eval>. Now the exception is written
+into C<$@> last thing before exiting the outer C<eval>, so the code
+running immediately thereafter can rely on the value in C<$@> correctly
+corresponding to that C<eval>. (C<$@> is still also set before exiting the
+C<eval>, for the sake of destructors that rely on this.)
+
+Likewise, a C<local $@> inside an C<eval> will no longer clobber any
+exception thrown in its scope. Previously, the restoration of C<$@> upon
+unwinding would overwrite any exception being thrown. Now the exception
+gets to the C<eval> anyway. So C<local $@> is safe before a C<die>.
+
+Exceptions thrown from object destructors no longer modify the C<$@>
+of the surrounding context. (If the surrounding context was exception
+unwinding, this used to be another way to clobber the exception being
+thrown.) Previously such an exception was
+sometimes emitted as a warning, and then either was
+string-appended to the surrounding C<$@> or completely replaced the
+surrounding C<$@>, depending on whether that exception and the surrounding
+C<$@> were strings or objects. Now, an exception in this situation is
+always emitted as a warning, leaving the surrounding C<$@> untouched.
+In addition to object destructors, this also affects any function call
+performed by XS code using the C<G_KEEPERR> flag.
+
+Warnings for C<warn> can now be objects, in the same way as exceptions
+for C<die>. If an object-based warning gets the default handling,
+of writing to standard error, it is stringified as
+before, with the file and line number appended. But
+a C<$SIG{__WARN__}> handler will now receive an
+object-based warning as an object, where previously it was passed the
+result of stringifying the object.
+
+=head2 Other Enhancements
+
+=head3 Assignment to C<$0> sets the legacy process name with C<prctl()> on Linux
+
+On Linux the legacy process name will be set with L<prctl(2)>, in
+addition to altering the POSIX name via C<argv[0]> as perl has done
+since version 4.000. Now system utilities that read the legacy process
+name such as ps, top and killall will recognize the name you set when
+assigning to C<$0>. The string you supply will be cut off at 16 bytes,
+this is a limitation imposed by Linux.
+
+=head3 C<srand()> now returns the seed
+
+This allows programs that need to have repeatable results not to have to come
+up with their own seed-generating mechanism. Instead, they can use C<srand()>
+and stash the return value for future use. Typical is a test program which
+has too many combinations to test comprehensively in the time available to it
+each run. It can test a random subset each time and, should there be a failure,
+log the seed used for that run so that it can later be used to reproduce the
+same results.
+
+=head3 printf-like functions understand post-1980 size modifiers
+
+Perl's printf and sprintf operators, and Perl's internal printf replacement
+function, now understand the C90 size modifiers "hh" (C<char>), "z"
+(C<size_t>), and "t" (C<ptrdiff_t>). Also, when compiled with a C99
+compiler, Perl now understands the size modifier "j" (C<intmax_t>).
+
+So, for example, on any modern machine, C<sprintf('%hhd', 257)> returns '1'.
+
+=head3 New global variable C<${^GLOBAL_PHASE}>
+
+A new global variable, C<${^GLOBAL_PHASE}>, has been added to allow
+introspection of the current phase of the perl interpreter. It's explained in
+detail in L<perlvar/"${^GLOBAL_PHASE}"> and
+L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT and END">.
+
+=head3 C<-d:-foo> calls C<Devel::foo::unimport>
+
+The syntax C<-dI<B<:>foo>> was extended in 5.6.1 to make C<-dI<:fooB<=bar>>>
+equivalent to C<-MDevel::foo=bar>, which expands
+internally to C<use Devel::foo 'bar';>.
+F<perl> now allows prefixing the module name with C<->, with the same
+semantics as C<-M>, I<i.e.>
+
+=over 4
+
+=item C<-d:-foo>
+
+Equivalent to C<-M-Devel::foo>, expands to
+C<no Devel::foo;>, calls C<< Devel::foo->unimport() >>
+if the method exists.
+
+=item C<-d:-foo=bar>
+
+Equivalent to C<-M-Devel::foo=bar>, expands to C<no Devel::foo 'bar';>,
+calls C<< Devel::foo->unimport('bar') >> if the method exists.
+
+=back
+
+This is particularly useful for suppressing the default actions of a
+C<Devel::*> module's C<import> method whilst still loading it for debugging.
+
+=head3 Filehandle method calls load L<IO::File> on demand
+
+When a method call on a filehandle would die because the method cannot
+be resolved, and L<IO::File> has not been loaded, Perl now loads L<IO::File>
+via C<require> and attempts method resolution again:
+
+ open my $fh, ">", $file;
+ $fh->binmode(":raw"); # loads IO::File and succeeds
+
+This also works for globs like STDOUT, STDERR and STDIN:
+
+ STDOUT->autoflush(1);
+
+Because this on-demand load only happens if method resolution fails, the
+legacy approach of manually loading an L<IO::File> parent class for partial
+method support still works as expected:
+
+ use IO::Handle;
+ open my $fh, ">", $file;
+ $fh->autoflush(1); # IO::File not loaded
+
+=head3 IPv6 support
+
+The C<Socket> module provides new affordances for IPv6,
+including implementations of the C<Socket::getaddrinfo()> and
+C<Socket::getnameinfo()> functions, along with related constants, and a
+handful of new functions. See L<Socket>.
+
+=head3 DTrace probes now include package name
+
+The DTrace probes now include an additional argument (C<arg3>) which contains
+the package the subroutine being entered or left was compiled in.
+
+For example using the following DTrace script:
+
+ perl$target:::sub-entry
+ {
+ printf("%s::%s\n", copyinstr(arg0), copyinstr(arg3));
+ }
+
+and then running:
+
+ perl -e'sub test { }; test'
+
+DTrace will print:
+
+ main::test
+
+=head2 New C APIs
+
+See L</Internal Changes>.
+
+=head1 Security
+
+=head2 User-defined regular expression properties
+
+In L<perlunicode/"User-Defined Character Properties">, it says you can
+create custom properties by defining subroutines whose names begin with
+"In" or "Is". However, Perl did not actually enforce that naming
+restriction, so \p{foo::bar} could call foo::bar() if it existed. Now this
+convention has been enforced.
+
+Also, Perl no longer allows a tainted regular expression to invoke a
+user-defined. It simply dies instead [perl #82616].
+
+=head1 Incompatible Changes
+
+Perl 5.14.0 is not binary-compatible with any previous stable release.
+
+In addition to the sections that follow, see L</C API Changes>.
+
+=head2 Regular Expressions and String Escapes
+
+=head3 \400-\777
+
+Use of C<\400>-C<\777> in regexes in certain circumstances has given
+different, anomalous behavior than their use in all other
+double-quote-like contexts. Since 5.10.1, a deprecated warning message
+has been raised when this happens. Now, all double-quote-like contexts
+have the same behavior, namely to be equivalent to C<\x{100}> -
+C<\x{1FF}>, with no deprecation warning. Use of these values in the
+command line option C<"-0"> retains the current meaning to slurp input
+files whole; previously, this was documented only for C<"-0777">. It is
+recommended, however, because of various ambiguities, to use the new
+C<\o{...}> construct to represent characters in octal.
+
+=head3 Most C<\p{}> properties are now immune to case-insensitive matching
+
+For most Unicode properties, it doesn't make sense to have them match
+differently under C</i> case-insensitive matching than not. And doing
+so leads to unexpected results and potential security holes. For
+example
+
+ m/\p{ASCII_Hex_Digit}+/i
+
+could previously match non-ASCII characters because of the Unicode
+matching rules (although there were a number of bugs with this). Now
+matching under C</i> gives the same results as non-C</i> matching except
+for those few properties where people have come to expect differences,
+namely the ones where casing is an integral part of their meaning, such
+as C<m/\p{Uppercase}/i> and C<m/\p{Lowercase}/i>, both of which match
+the exact same code points, namely those matched by C<m/\p{Cased}/i>.
+Details are in L<perlrecharclass/Unicode Properties>.
+
+User-defined property handlers that need to match differently under
+C</i> must change to read the new boolean parameter passed to them which is
+non-zero if case-insensitive matching is in effect or 0 otherwise. See
+L<perluniprops/User-Defined Character Properties>.
+
+=head3 \p{} implies Unicode semantics
+
+Now, a Unicode property match specified in the pattern will indicate
+that the pattern is meant for matching according to Unicode rules, the way
+C<\N{}> does.
+
+=head3 Regular expressions retain their localeness when interpolated
+
+Regular expressions compiled under C<"use locale"> now retain this when
+interpolated into a new regular expression compiled outside a
+C<"use locale">, and vice-versa.
+
+Previously, a regular expression interpolated into another one inherited
+the localeness of the surrounding one, losing whatever state it
+originally had. This is considered a bug fix, but may trip up code that
+has come to rely on the incorrect behavior.
+
+=head3 Stringification of regexes has changed
+
+Default regular expression modifiers are now notated by using
+C<(?^...)>. Code relying on the old stringification will fail. The
+purpose of this is so that when new modifiers are added, such code will
+not have to change (after this one time), as the stringification will
+automatically incorporate the new modifiers.
+
+Code that needs to work properly with both old- and new-style regexes
+can avoid the whole issue by using (for Perls since 5.9.5; see L<re>):
+
+ use re qw(regexp_pattern);
+ my ($pat, $mods) = regexp_pattern($re_ref);
+
+If the actual stringification is important, or older Perls need to be
+supported, you can use something like the following:
+
+ # Accept both old and new-style stringification
+ my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? '^' : '-xism';
+
+And then use C<$modifiers> instead of C<-xism>.
+
+=head3 Run-time code blocks in regular expressions inherit pragmata
+
+Code blocks in regular expressions (C<(?{...})> and C<(??{...})>) used not
+to inherit any pragmata (strict, warnings, etc.) if the regular expression
+was compiled at run time as happens in cases like these two:
+
+ use re 'eval';
+ $foo =~ $bar; # when $bar contains (?{...})
+ $foo =~ /$bar(?{ $finished = 1 })/;
+
+This was a bug, which has now been fixed. But it has the potential to break
+any code that was relying on it.
+
+=head2 Stashes and Package Variables
+
+=head3 Localised tied hashes and arrays are no longed tied
+
+In the following:
+
+ tie @a, ...;
+ {
+ local @a;
+ # here, @a is a now a new, untied array
+ }
+ # here, @a refers again to the old, tied array
+
+The new local array used to be made tied too, which was fairly pointless,
+and has now been fixed. This fix could however potentially cause a change
+in behaviour of some code.
+
+=head3 Stashes are now always defined
+
+C<defined %Foo::> now always returns true, even when no symbols have yet been
+defined in that package.
+
+This is a side effect of removing a special case kludge in the tokeniser,
+added for 5.10.0, to hide side effects of changes to the internal storage of
+hashes that drastically reduce their memory usage overhead.
+
+Calling defined on a stash has been deprecated since 5.6.0, warned on
+lexicals since 5.6.0, and warned for stashes (and other package
+variables) since 5.12.0. C<defined %hash> has always exposed an
+implementation detail - emptying a hash by deleting all entries from it does
+not make C<defined %hash> false, hence C<defined %hash> is not valid code to
+determine whether an arbitrary hash is empty. Instead, use the behaviour
+that an empty C<%hash> always returns false in a scalar context.
+
+=head3 Dereferencing typeglobs
+
+If you assign a typeglob to a scalar variable:
+
+ $glob = *foo;
+
+the glob that is copied to C<$glob> is marked with a special flag
+indicating that the glob is just a copy. This allows subsequent assignments
+to C<$glob> to overwrite the glob. The original glob, however, is
+immutable.
+
+Many Perl operators did not distinguish between these two types of globs.
+This would result in strange behaviour in edge cases: C<untie $scalar>
+would do nothing if the last thing assigned to the scalar was a glob
+(because it treated it as C<untie *$scalar>, which unties a handle).
+Assignment to a glob slot (e.g., C<*$glob = \@some_array>) would simply
+assign C<\@some_array> to C<$glob>.
+
+To fix this, the C<*{}> operator (including the C<*foo> and C<*$foo> forms)
+has been modified to make a new immutable glob if its operand is a glob
+copy. This allows operators that make a distinction between globs and
+scalars to be modified to treat only immutable globs as globs. (C<tie>,
+C<tied> and C<untie> have been left as they are for compatibility's sake,
+but will warn. See L</Deprecations>.)
+
+This causes an incompatible change in code that assigns a glob to the
+return value of C<*{}> when that operator was passed a glob copy. Take the
+following code, for instance:
+
+ $glob = *foo;
+ *$glob = *bar;
+
+The C<*$glob> on the second line returns a new immutable glob. That new
+glob is made an alias to C<*bar>. Then it is discarded. So the second
+assignment has no effect.
+
+See L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for even
+more detail.
+
+=head3 Clearing stashes
+
+Stash list assignment C<%foo:: = ()> used to make the stash anonymous
+temporarily while it was being emptied. Consequently, any of its
+subroutines referenced elsewhere would become anonymous (showing up as
+"(unknown)" in C<caller>). Now they retain their package names, such that
+C<caller> will return the original sub name if there is still a reference
+to its typeglob, or "foo::__ANON__" otherwise [perl #79208].
+
+=head3 Magic variables outside the main package
+
+In previous versions of Perl, magic variables like C<$!>, C<%SIG>, etc. would
+'leak' into other packages. So C<%foo::SIG> could be used to access signals,
+C<${"foo::!"}> (with strict mode off) to access C's C<errno>, etc.
+
+This was a bug, or an 'unintentional' feature, which caused various ill effects,
+such as signal handlers being wiped when modules were loaded, etc.
+
+This has been fixed (or the feature has been removed, depending on how you see
+it).
+
+=head2 Changes to Syntax or to Perl Operators
+
+=head3 C<given> return values
+
+C<given> blocks now return the last evaluated
+expression, or an empty list if the block was exited by C<break>. Thus you
+can now write:
+
+ my $type = do {
+ given ($num) {
+ break when undef;
+ 'integer' when /^[+-]?[0-9]+$/;
+ 'float' when /^[+-]?[0-9]+(?:\.[0-9]+)?$/;
+ 'unknown';
+ }
+ };
+
+See L<perlsyn/Return value> for details.
+
+=head3 Change in the parsing of certain prototypes
+
+Functions declared with the following prototypes now behave correctly as unary
+functions:
+
+ *
+ \$ \% \@ \* \&
+ \[...]
+ ;$ ;*
+ ;\$ ;\% etc.
+ ;\[...]
+
+Due to this bug fix [perl #75904], functions
+using the C<(*)>, C<(;$)> and C<(;*)> prototypes
+are parsed with higher precedence than before. So in the following example:
+
+ sub foo($);
+ foo $a < $b;
+
+the second line is now parsed correctly as C<< foo($a) < $b >>, rather than
+C<< foo($a < $b) >>. This happens when one of these operators is used in
+an unparenthesised argument:
+
+ < > <= >= lt gt le ge
+ == != <=> eq ne cmp ~~
+ &
+ | ^
+ &&
+ || //
+ .. ...
+ ?:
+ = += -= *= etc.
+
+=head3 Smart-matching against array slices
+
+Previously, the following code resulted in a successful match:
+
+ my @a = qw(a y0 z);
+ my @b = qw(a x0 z);
+ @a[0 .. $#b] ~~ @b;
+
+This odd behaviour has now been fixed [perl #77468].
+
+=head3 Negation treats strings differently from before
+
+The unary negation operator C<-> now treats strings that look like numbers
+as numbers [perl #57706].
+
+=head3 Negative zero
+
+Negative zero (-0.0), when converted to a string, now becomes "0" on all
+platforms. It used to become "-0" on some, but "0" on others.
+
+If you still need to determine whether a zero is negative, use
+C<sprintf("%g", $zero) =~ /^-/> or the L<Data::Float> module on CPAN.
+
+=head3 C<:=> is now a syntax error
+
+Previously C<my $pi := 4;> was exactly equivalent to C<my $pi : = 4;>,
+with the C<:> being treated as the start of an attribute list, ending before
+the C<=>. The use of C<:=> to mean C<: => was deprecated in 5.12.0, and is now
+a syntax error. This will allow the future use of C<:=> as a new token.
+
+We find no Perl 5 code on CPAN using this construction, outside the core's
+tests for it, so we believe that this change will have very little impact on
+real-world codebases.
+
+If it is absolutely necessary to have empty attribute lists (for example,
+because of a code generator) then avoid the error by adding a space before
+the C<=>.
+
+=head2 Threads and Processes
+
+=head3 Directory handles not copied to threads
+
+On systems other than Windows that do not have
+a C<fchdir> function, newly-created threads no
+longer inherit directory handles from their parent threads. Such programs
+would usually have crashed anyway [perl #75154].
+
+=head3 C<close> on shared pipes
+
+The C<close> function no longer waits for the child process to exit if the
+underlying file descriptor is still in use by another thread, to avoid
+deadlocks. It returns true in such cases.
+
+=head3 fork() emulation will not wait for signalled children
+
+On Windows parent processes would not terminate until all forked
+childred had terminated first. However, C<kill('KILL', ...)> is
+inherently unstable on pseudo-processes, and C<kill('TERM', ...)>
+might not get delivered if the child if blocked in a system call.
+
+To avoid the deadlock and still provide a safe mechanism to terminate
+the hosting process, Perl will now no longer wait for children that
+have been sent a SIGTERM signal. It is up to the parent process to
+waitpid() for these children if child clean-up processing must be
+allowed to finish. However, it is also the responsibility of the
+parent then to avoid the deadlock by making sure the child process
+can't be blocked on I/O either.
+
+See L<perlfork> for more information about the fork() emulation on
+Windows.
+
+=head2 Configuration
+
+=head3 Naming fixes in Policy_sh.SH may invalidate Policy.sh
+
+Several long-standing typos and naming confusions in Policy_sh.SH have
+been fixed, standardizing on the variable names used in config.sh.
+
+This will change the behavior of Policy.sh if you happen to have been
+accidentally relying on the Policy.sh incorrect behavior.
+
+=head3 Perl source code is read in text mode on Windows
+
+Perl scripts used to be read in binary mode on Windows for the benefit
+of the ByteLoader module (which is no longer part of core Perl). This
+had the side effect of breaking various operations on the DATA filehandle,
+including seek()/tell(), and even simply reading from DATA after file handles
+have been flushed by a call to system(), backticks, fork() etc.
+
+The default build options for Windows have been changed to read Perl source
+code on Windows in text mode now. Hopefully ByteLoader will be updated on
+CPAN to automatically handle this situation [perl #28106].
+
+=head1 Deprecations
+
+See also L</Deprecated C APIs>.
+
+=head2 Omitting a space between a regular expression and subsequent word
+
+Omitting a space between a regular expression operator or
+its modifiers and the following word is deprecated. For
+example, C<< m/foo/sand $bar >> will still be parsed
+as C<< m/foo/s and $bar >> but will issue a warning.
+
+=head2 C<\cI<X>>
+
+The backslash-c construct was designed as a way of specifying
+non-printable characters, but there were no restrictions (on ASCII
+platforms) on what the character following the C<c> could be. Now,
+a deprecation warning is raised if that character isn't an ASCII character.
+Also, a deprecation warning is raised for C<"\c{"> (which is the same
+as simply saying C<";">).
+
+=head2 C<"\b{"> and C<"\B{">
+
+In regular expressions, a literal C<"{"> immediately following a C<"\b">
+(not in a bracketed character class) or a C<"\B{"> is now deprecated
+to allow for its future use by Perl itself.
+
+=head2 Deprecation warning added for deprecated-in-core .pl libs
+
+This is a mandatory warning, not obeying -X or lexical warning bits.
+The warning is modelled on that supplied by deprecate.pm for
+deprecated-in-core .pm libraries. It points to the specific CPAN
+distribution that contains the .pl libraries. The CPAN version, of
+course, does not generate the warning.
+
+=head2 List assignment to C<$[>
+
+Assignment to C<$[> was deprecated and started to give warnings in
+Perl version 5.12.0. This version of perl also starts to emit a warning when
+assigning to C<$[> in list context. This fixes an oversight in 5.12.0.
+
+=head2 Use of qw(...) as parentheses
+
+Historically the parser fooled itself into thinking that C<qw(...)> literals
+were always enclosed in parentheses, and as a result you could sometimes omit
+parentheses around them:
+
+ for $x qw(a b c) { ... }
+
+The parser no longer lies to itself in this way. Wrap the list literal in
+parentheses, like this:
+
+ for $x (qw(a b c)) { ... }
+
+=head2 C<\N{BELL}> is deprecated
+
+This is because Unicode is using that name for a different character.
+See L</Unicode Version 6.0 is now supported (mostly)> for more
+explanation.
+
+=head2 C<?PATTERN?> is deprecated
+
+C<?PATTERN?> (without the initial m) has been deprecated and now produces
+a warning. This is to allow future use of C<?> in new operators.
+The match-once functionality is still available in the form of C<m?PATTERN?>.
+
+=head2 Tie functions on scalars holding typeglobs
+
+Calling a tie function (C<tie>, C<tied>, C<untie>) with a scalar argument
+acts on a file handle if the scalar happens to hold a typeglob.
+
+This is a long-standing bug that will be removed in Perl 5.16, as
+there is currently no way to tie the scalar itself when it holds
+a typeglob, and no way to untie a scalar that has had a typeglob
+assigned to it.
+
+Now there is a deprecation warning whenever a tie
+function is used on a handle without an explicit C<*>.
+
+=head2 User-defined case-mapping
+
+This feature is being deprecated due to its many issues, as documented in
+L<perlunicode/User-Defined Case Mappings (for serious hackers only)>.
+It is planned to remove this feature in Perl 5.16. A CPAN module,
+L<Unicode::Casing>, providing improved functionality is being prepared for
+release by the time 5.14 is available.
+
+=head2 Deprecated modules
+
+The following modules will be removed from the core distribution in a
+future release, and should be installed from CPAN instead. Distributions
+on CPAN which require these should add them to their prerequisites. The
+core versions of these modules will issue a deprecation warning.
+
+If you ship a packaged version of Perl, either alone or as part of a
+larger system, then you should carefully consider the repercussions of
+core module deprecations. You may want to consider shipping your default
+build of Perl with packages for some or all deprecated modules which
+install into C<vendor> or C<site> perl library directories. This will
+inhibit the deprecation warnings.
+
+Alternatively, you may want to consider patching F<lib/deprecate.pm>
+to provide deprecation warnings specific to your packaging system
+or distribution of Perl, consistent with how your packaging system
+or distribution manages a staged transition from a release where the
+installation of a single package provides the given functionality, to
+a later release where the system administrator needs to know to install
+multiple packages to get that same functionality.
+
+You can silence these deprecation warnings by installing the modules
+in question from CPAN. To install the latest version of all of them,
+just install C<Task::Deprecations::5_14>.
+
+=over
+
+=item L<Devel::DProf>
+
+We strongly recommend that you install and used L<Devel::NYTProf> in
+preference, as it offers significantly improved profiling and reporting.
+
+=back
+
+=head1 Performance Enhancements
+
+=head2 "Safe signals" optimisation
+
+Signal dispatch has been moved from the runloop into control ops. This
+should give a few percent speed increase, and eliminates almost all of
+the speed penalty caused by the introduction of "safe signals" in
+5.8.0. Signals should still be dispatched within the same statement as
+they were previously - if this is not the case, or it is possible to
+create uninterruptible loops, this is a bug, and reports are encouraged
+of how to recreate such issues.
+
+=head2 Optimisation of shift; and pop; calls without arguments
+
+Two fewer OPs are used for shift and pop calls with no argument (with
+implicit C<@_>). This change makes C<shift;> 5% faster than C<shift @_;>
+on non-threaded perls and 25% faster on threaded.
+
+=head2 Optimisation of regexp engine string comparison work
+
+The foldEQ_utf8 API function for case-insensitive comparison of strings (which
+is used heavily by the regexp engine) was substantially refactored and
+optimised - and its documentation much improved as a free bonus gift.
+
+=head2 Regular expression compilation speed-up
+
+Compiling regular expressions has been made faster for the case where upgrading
+the regex to utf8 is necessary but that isn't known when the compilation begins.
+
+=head2 String appending is 100 times faster
+
+When doing a lot of string appending, perl could end up allocating a lot more
+memory than needed in a very inefficient way, if perl was configured to use the
+system's C<malloc> implementation instead of its own.
+
+C<sv_grow>, which is what's being used to allocate more memory if necessary
+when appending to a string, has now been taught how to round up the memory
+it requests to a certain geometric progression, making it much faster on
+certain platforms and configurations. On Win32, it's now about 100 times
+faster.
+
+=head2 Eliminate C<PL_*> accessor functions under ithreads
+
+When C<MULTIPLICITY> was first developed, and interpreter state moved into
+an interpreter struct, thread and interpreter local C<PL_*> variables were
+defined as macros that called accessor functions, returning the address of
+the value, outside of the perl core. The intent was to allow members
+within the interpreter struct to change size without breaking binary
+compatibility, so that bug fixes could be merged to a maintenance branch
+that necessitated such a size change.
+
+However, some non-core code defines C<PERL_CORE>, sometimes intentionally
+to bypass this mechanism for speed reasons, sometimes for other reasons but
+with the inadvertent side effect of bypassing this mechanism. As some of
+this code is widespread in production use, the result is that the core
+I<can't> change the size of members of the interpreter struct, as it will
+break such modules compiled against a previous release on that maintenance
+branch. The upshot is that this mechanism is redundant, and well-behaved
+code is penalised by it. Hence it can and should be removed (and has
+been).
+
+=head2 Freeing weak references
+
+When an object has many weak references to it, freeing that object
+can under some some circumstances take O(N^2) time to free (where N is the
+number of references). The number of circumstances has been reduced
+[perl #75254]
+
+=head2 Lexical array and hash assignments
+
+An earlier optimisation to speed up C<my @array = ...> and
+C<my %hash = ...> assignments caused a bug and was disabled in Perl 5.12.0.
+
+Now we have found another way to speed up these assignments [perl #82110].
+
+=head2 C<@_> uses less memory
+
+Previously, C<@_> was allocated for every subroutine at compile time with
+enough space for four entries. Now this allocation is done on demand when
+the subroutine is called [perl #72416].
+
+=head2 Size optimisations to SV and HV structures
+
+xhv_fill has been eliminated from struct xpvhv, saving 1 IV per hash and
+on some systems will cause struct xpvhv to become cache-aligned. To avoid
+this memory saving causing a slowdown elsewhere, boolean use of HvFILL
+now calls HvTOTALKEYS instead (which is equivalent) - so while the fill
+data when actually required are now calculated on demand, the cases when
+this needs to be done should be few and far between.
+
+The order of structure elements in SV bodies has changed. Effectively,
+the NV slot has swapped location with STASH and MAGIC. As all access to
+SV members is via macros, this should be completely transparent. This
+change allows the space saving for PVHVs documented above, and may reduce
+the memory allocation needed for PVIVs on some architectures.
+
+C<XPV>, C<XPVIV>, and C<XPVNV> now only allocate the parts of the C<SV> body
+they actually use, saving some space.
+
+Scalars containing regular expressions now only allocate the part of the C<SV>
+body they actually use, saving some space.
+
+=head2 Memory consumption improvements to Exporter
+
+The @EXPORT_FAIL AV is no longer created unless required, hence neither is
+the typeglob backing it. This saves about 200 bytes for every package that
+uses Exporter but doesn't use this functionality.
+
+=head2 Memory savings for weak references
+
+For weak references, the common case of just a single weak reference per
+referent has been optimised to reduce the storage required. In this case it
+saves the equivalent of one small Perl array per referent.
+
+=head2 C<%+> and C<%-> use less memory
+
+The bulk of the C<Tie::Hash::NamedCapture> module used to be in the perl
+core. It has now been moved to an XS module, to reduce the overhead for
+programs that do not use C<%+> or C<%->.
+
+=head2 Multiple small improvements to threads
+
+The internal structures of threading now make fewer API calls and fewer
+allocations, resulting in noticeably smaller object code. Additionally,
+many thread context checks have been deferred so that they're only done
+when required (although this is only possible for non-debugging builds).
+
+=head2 Adjacent pairs of nextstate opcodes are now optimized away
+
+Previously, in code such as
+
+ use constant DEBUG => 0;
+
+ sub GAK {
+ warn if DEBUG;
+ print "stuff\n";
+ }
+
+the ops for C<warn if DEBUG;> would be folded to a C<null> op (C<ex-const>), but
+the C<nextstate> op would remain, resulting in a runtime op dispatch of
+C<nextstate>, C<nextstate>, ....
+
+The execution of a sequence of C<nextstate> ops is indistinguishable from just
+the last C<nextstate> op so the peephole optimizer now eliminates the first of
+a pair of C<nextstate> ops, except where the first carries a label, since labels
+must not be eliminated by the optimizer and label usage isn't conclusively known
+at compile time.
+
+=head1 Modules and Pragmata
+
+=head2 New Modules and Pragmata
+
+=over 4
+
+=item *
+
+C<CPAN::Meta::YAML> 0.003 has been added as a dual-life module. It supports a
+subset of YAML sufficient for reading and writing META.yml and MYMETA.yml files
+included with CPAN distributions or generated by the module installation
+toolchain. It should not be used for any other general YAML parsing or
+generation task.
+
+=item *
+
+C<CPAN::Meta> version 2.110440 has been added as a dual-life module. It
+provides a standard library to read, interpret and write CPAN distribution
+metadata files (e.g. META.json and META.yml) which describes a
+distribution, its contents, and the requirements for building it and
+installing it. The latest CPAN distribution metadata specification is
+included as C<CPAN::Meta::Spec> and notes on changes in the specification
+over time are given in C<CPAN::Meta::History>.
+
+=item *
+
+C<HTTP::Tiny> 0.011 has been added as a dual-life module. It is a very
+small, simple HTTP/1.1 client designed for simple GET requests and file
+mirroring. It has has been added to enable CPAN.pm and CPANPLUS to
+"bootstrap" HTTP access to CPAN using pure Perl without relying on external
+binaries like F<curl> or F<wget>.
+
+=item *
+
+C<JSON::PP> 2.27105 has been added as a dual-life module, for the sake of
+reading F<META.json> files in CPAN distributions.
+
+=item *
+
+C<Module::Metadata> 1.000003 has been added as a dual-life module. It gathers
+package and POD information from Perl module files. It is a standalone module
+based on Module::Build::ModuleInfo for use by other module installation
+toolchain components. Module::Build::ModuleInfo has been deprecated in
+favor of this module instead.
+
+=item *
+
+C<Perl::OSType> 1.002 has been added as a dual-life module. It maps Perl
+operating system names (e.g. 'dragonfly' or 'MSWin32') to more generic types
+with standardized names (e.g. "Unix" or "Windows"). It has been refactored
+out of Module::Build and ExtUtils::CBuilder and consolidates such mappings into
+a single location for easier maintenance.
+
+=item *
+
+The following modules were added by the C<Unicode::Collate>
+upgrade. See below for details.
+
+C<Unicode::Collate::CJK::Big5>
+
+C<Unicode::Collate::CJK::GB2312>
+
+C<Unicode::Collate::CJK::JISX0208>
+
+C<Unicode::Collate::CJK::Korean>
+
+C<Unicode::Collate::CJK::Pinyin>
+
+C<Unicode::Collate::CJK::Stroke>
+
+=item *
+
+C<Version::Requirements> version 0.101020 has been added as a dual-life
+module. It provides a standard library to model and manipulates module
+prerequisites and version constraints as defined in the L<CPAN::Meta::Spec>.
+
+=back
+
+=head2 Selected Module and Pragma Updates
+
+=over 4
+
+=item *
+
+C<Archive::Extract> has been upgraded from version 0.38 to 0.48.
+
+Updates since 0.38 include: a safe print method that guards
+Archive::Extract from changes to $\; a fix to the tests when run in core
+perl; support for TZ files; a modification for the lzma
+logic to favour IO::Uncompress::Unlzma; and a fix
+for an issue with NetBSD-current and its new unzip
+executable.
+
+=item *
+
+C<Archive::Tar> has been upgraded from version 1.54 to 1.76.
+
+Important changes since 1.54 include the following:
+
+=over
+
+=item *
+
+Compatibility with busybox implementations of tar
+
+=item *
+
+A fix so that C<write()> and C<create_archive()>
+close only handles they opened
+
+=item *
+
+A bug was fixed regarding the exit code of extract_archive.
+
+=item *
+
+C<ptar> has a new option to allow safe
+creation of tarballs without world-writable files on Windows, allowing those
+archives to be uploaded to CPAN.
+
+=item *
+
+A new ptargrep utility for using regular expressions against
+the contents of files in a tar archive.
+
+=item *
+
+Pax extended headers are now skipped.
+
+=back
+
+=item *
+
+C<B> has been upgraded from version 1.23 to 1.27.
+
+It no longer crashes when taking apart a C<y///> containing characters
+outside the octet range or compiled in a C<use utf8> scope.
+
+The size of the shared object has been reduced by about 40%, with no
+reduction in functionality.
+
+=item *
+
+C<B::Concise> has been upgraded from version 0.78 to 0.82.
+
+B::Concise marks rv2sv, rv2av and rv2hv ops with the new OPpDEREF flag
+as "DREFed".
+
+It no longer produces mangled output with the C<-tree> option
+[perl #80632].
+
+=item *
+
+C<B::Deparse> has been upgraded from version 0.96 to 1.02.
+
+The deparsing of a nextstate op has changed when it has both a
+change of package (relative to the previous nextstate), or a change of
+C<%^H> or other state, and a label. Previously the label was emitted
+first, but now the label is emitted last (5.12.1).
+
+The C<no 5.13.2> or similar form is now correctly handled by B::Deparse
+(5.12.3).
+
+B::Deparse now properly handles the code that applies a conditional
+pattern match against implicit C<$_> as it was fixed in [perl #20444].
+
+Deparsing of C<our> followed by a variable with funny characters
+(as permitted under the C<utf8> pragma) has also been fixed [perl #33752].
+
+=item *
+
+C<Carp> has been upgraded from version 1.15 to 1.19.
+
+L<Carp> now detects incomplete L<caller()|perlfunc/"caller EXPR"> overrides and
+avoids using bogus C<@DB::args>. To provide backtraces,
+Carp relies on particular behaviour of the C<caller>
+built-in. Carp now detects if other code has
+overridden this with an incomplete implementation, and modifies its backtrace
+accordingly. Previously incomplete overrides would cause incorrect values
+in backtraces (best case), or obscure fatal errors (worst case).
+
+This fixes certain cases of C<Bizarre copy of ARRAY> caused by modules
+overriding C<caller()> incorrectly (5.12.2).
+
+It now also avoids using regular expressions that cause perl to
+load its Unicode tables, in order to avoid the 'BEGIN not safe after
+errors' error that will ensue if there has been a syntax error
+[perl #82854].
+
+=item *
+
+C<CGI> has been upgraded from version 3.48 to 3.51.
+
+This provides the following security fixes: the MIME boundary in
+multipart_init is now random and the handling of
+newlines embedded in header values has been improved.
+
+=item *
+
+C<Compress::Raw::Bzip2> has been upgraded from version 2.024 to 2.033.
+
+It has been updated to use bzip2 1.0.6.
+
+=item *
+
+C<CPAN> has been upgraded from version 1.94_56 to 1.9600.-
+
+Major highlights:
+
+=over 4
+
+=item * much less configuration dialog hassle
+
+=item * support for META/MYMETA.json
+
+=item * support for local::lib
+
+=item * support for HTTP::Tiny to reduce the dependency on ftp sites
+
+=item * automatic mirror selection
+
+=item * iron out all known bugs in configure_requires
+
+=item * support for distributions compressed with bzip2
+
+=item * allow Foo/Bar.pm on the commandline to mean Foo::Bar
+
+=back
+
+=item *
+
+C<CPANPLUS> has been upgraded from version 0.90 to 0.9103.
+
+A change to F<cpanp-run-perl>
+resolves L<RT #55964|http://rt.cpan.org/Public/Bug/Display.html?id=55964>
+and L<RT #57106|http://rt.cpan.org/Public/Bug/Display.html?id=57106>, both
+of which related to failures to install distributions that use
+C<Module::Install::DSL> (5.12.2).
+
+A dependency on Config was not recognised as a
+core module dependency. This has been fixed.
+
+CPANPLUS now includes support for META.json and MYMETA.json.
+
+=item *
+
+C<Data::Dumper> has been upgraded from version 2.125 to 2.130_02.
+
+The indentation used to be off when C<$Data::Dumper::Terse> was set. This
+has been fixed [perl #73604].
+
+This upgrade also fixes a crash when using custom sort functions that might
+cause the stack to change [perl #74170].
+
+C<Dumpxs> no longer crashes with globs returned by C<*$io_ref>
+[perl #72332].
+
+=item *
+
+C<Devel::DProf> has been upgraded from version 20080331.00 to 20110228.00.
+
+Merely loading C<Devel::DProf> now no longer triggers profiling to start.
+C<use Devel::DProf> and C<perl -d:DProf ...> still behave as before and start
+the profiler.
+
+NOTE: C<Devel::DProf> is deprecated and will be removed from a future
+version of Perl. We strongly recommend that you install and use
+L<Devel::NYTProf> instead, as it offers significantly improved
+profiling and reporting.
+
+=item *
+
+C<diagnostics> has been upgraded from version 1.19 to 1.22.
+
+It now renders pod links slightly better, and has been taught to find
+descriptions for messages that share their descriptions with other
+messages.
+
+=item *
+
+C<Digest::MD5> has been upgraded from version 2.39 to 2.51.
+
+It is now safe to use this module in combination with threads.
+
+=item *
+
+C<Digest::SHA> has been upgraded from version 5.47 to 5.61.
+
+C<shasum> now more closely mimics C<sha1sum>/C<md5sum>.
+
+C<Addfile> accepts all POSIX filenames.
+
+New SHA-512/224 and SHA-512/256 transforms (ref. NIST Draft FIPS 180-4
+[February 2011])
+
+=item *
+
+C<DynaLoader> has been upgraded from version 1.10 to 1.12.
+
+It fixes a buffer overflow when passed a very long file name.
+
+It no longer inherits from AutoLoader; hence it no longer
+produces weird error messages for unsuccessful method calls on classes that
+inherit from DynaLoader [perl #84358].
+
+=item *
+
+C<Encode> has been upgraded from version 2.39 to 2.42.
+
+Now, all 66 Unicode non-characters are treated the same way U+FFFF has
+always been treated; in cases when it was disallowed, all 66 are
+disallowed; in those cases where it warned, all 66 warn.
+
+=item *
+
+C<Errno> has been upgraded from version 1.11 to 1.13.
+
+The implementation of C<Errno> has been refactored to use about 55% less memory.
+
+On some platforms with unusual header files, like Win32/gcc using mingw64
+headers, some constants which weren't actually error numbers have been exposed
+by C<Errno>. This has been fixed [perl #77416].
+
+=item *
+
+C<Exporter> has been upgraded from version 5.64_01 to 5.64_03.
+
+Exporter no longer overrides C<$SIG{__WARN__}> [perl #74472]
+
+=item *
+
+C<ExtUtils::Constant> has been upgraded from 0.22 to 0.23.
+
+The C<AUTOLOAD> helper code generated by C<ExtUtils::Constant::ProxySubs>
+can now C<croak> for missing constants, or generate a complete C<AUTOLOAD>
+subroutine in XS, allowing simplification of many modules that use it
+(C<Fcntl>, C<File::Glob>, C<GDBM_File>, C<I18N::Langinfo>, C<POSIX>,
+C<Socket>).
+
+C<ExtUtils::Constant::ProxySubs> can now optionally push the names of all
+constants onto the package's C<@EXPORT_OK>.
+
+=item *
+
+C<File::DosGlob> has been upgraded from version 1.01 to 1.03.
+
+It allows patterns containing literal parentheses (they no longer need to
+be escaped). On Windows, it no longer
+adds an extra F<./> to the file names
+returned when the pattern is a relative glob with a drive specification,
+like F<c:*.pl> [perl #71712].
+
+=item *
+
+C<File::Fetch> has been upgraded from version 0.24 to 0.32.
+
+C<HTTP::Lite> is now supported for 'http' scheme.
+
+The C<fetch> utility is supported on FreeBSD, NetBSD and
+Dragonfly BSD for the C<http> and C<ftp> schemes.
+
+=item *
+
+C<File::Find> has been upgraded from version 1.15 to 1.18.
+
+It improves handling of backslashes on Windows, so that paths like
+F<c:\dir\/file> are no longer generated [perl #71710].
+
+=item *
+
+C<File::Spec> has been upgraded from version 3.31 to 3.33.
+
+Several portability fixes were made in C<File::Spec::VMS>: a colon is now
+recognized as a delimiter in native filespecs; caret-escaped delimiters are
+recognized for better handling of extended filespecs; C<catpath()> returns
+an empty directory rather than the current directory if the input directory
+name is empty; C<abs2rel()> properly handles Unix-style input (5.12.2).
+
+=item *
+
+C<File::stat> has been upgraded from 1.02 to 1.04.
+
+The C<-x> and C<-X> file test operators now work correctly under the root
+user.
+
+=item *
+
+C<GDBM_File> has been upgraded from 1.10 to 1.13.
+
+This fixes a memory leak when DBM filters are used.
+
+=item *
+
+C<Hash::Util> has been upgraded from 0.07 to 0.10.
+
+Hash::Util no longer emits spurious "uninitialized" warnings when
+recursively locking hashes that have undefined values [perl #74280].
+
+=item *
+
+C<I18N::Langinfo> has been upgraded from version 0.03 to 0.07.
+
+C<langinfo()> now defaults to using C<$_> if there is no argument given, just
+as the documentation has always claimed.
+
+=item *
+
+C<IO::Select> has been upgraded from version 1.17 to 1.18.
+
+It now allows IO::Handle objects (and objects in derived classes) to be
+removed from an IO::Select set even if the underlying file descriptor is
+closed or invalid.
+
+=item *
+
+C<IPC::Cmd> has been upgraded from version 0.54 to 0.68.
+
+Resolves an issue with splitting Win32 command lines. An argument
+consisting of the single character "0" used to be omitted (CPAN RT #62961).
+
+=item *
+
+C<IPC::Open3> has been upgraded from 1.05 to 1.08.
+
+C<open3> now produces an error if the C<exec> call fails, allowing this
+condition to be distinguished from a child process that exited with a
+non-zero status [perl #72016].
+
+The internal C<xclose> routine now knows how to handle file descriptors, as
+documented, so duplicating STDIN in a child process using its file
+descriptor now works [perl #76474].
+
+=item *
+
+C<Locale::Maketext> has been upgraded from version 1.14 to 1.17.
+
+Locale::Maketext now supports external caches.
+
+This upgrade also fixes an infinite loop in
+C<Locale::Maketext::Guts::_compile()> when
+working with tainted values (CPAN RT #40727).
+
+C<< ->maketext >> calls will now back up and restore C<$@> so that error
+messages are not suppressed (CPAN RT #34182).
+
+=item *
+
+C<Math::BigInt> has been upgraded from version 1.89_01 to 1.994.
+
+This fixes, among other things, incorrect results when computing binomial
+coefficients [perl #77640].
+
+It also prevents C<sqrt($int)> from crashing under C<use bigrat;>
+[perl #73534].
+
+=item *
+
+C<MIME::Base64> has been upgraded from 3.08 to 3.13.
+
+Includes new functions to calculate the length of encoded and decoded
+base64 strings.
+
+Now provides C<encode_base64url> and C<decode_base64url> functions to process
+the base64 scheme for "URL applications".
+
+=item *
+
+C<Module::Build> has been upgraded from version 0.3603 to 0.3800.
+
+A notable change is the deprecation of several modules.
+Module::Build::Version has been deprecated and Module::Build now relies
+directly upon L<version>. Module::Build::ModuleInfo has been deprecated in
+favor of a standalone copy of it called L<Module::Metadata>.
+Module::Build::YAML has been deprecated in favor of L<CPAN::Meta::YAML>.
+
+Module::Build now also generates META.json and MYMETA.json files
+in accordance with version 2 of the CPAN distribution metadata specification,
+L<CPAN::Meta::Spec>. The older format META.yml and MYMETA.yml files are
+still generated, as well.
+
+=item *
+
+C<Module::CoreList> has been upgraded from version 2.29 to XXX.
+
+Besides listing the updated core modules of this release, it also stops listing
+the C<Filespec> module. That module never existed in core. The scripts
+generating C<Module::CoreList> confused it with C<VMS::Filespec>, which actually
+is a core module as of perl 5.8.7.
+
+=item *
+
+C<NDBM_File> and C<ODBM_File> have been upgraded from 1.08 to 1.11, and
+from 1.08 to 1.09, respectively.
+
+This fixes a memory leak when DBM filters are used.
+
+=item *
+
+C<overload> has been upgraded from 1.11 to 1.12.
+
+C<overload::Method> can now handle subroutines that are themselves blessed
+into overloaded classes [perl #71998].
+
+The documentation has greatly improved. See L</Documentation> below.
+
+=item *
+
+C<Parse::CPAN::Meta> has been upgraded from version 1.40 to 1.4401.
+
+The latest Parse::CPAN::Meta can now read YAML and JSON files using
+L<CPAN::Meta::YAML> and L<JSON::PP>, which are now part of the Perl core.
+
+=item *
+
+C<PerlIO::scalar> has been upgraded from 0.07 to 0.11.
+
+A C<read> after a C<seek> beyond the end of the string no longer thinks it
+has data to read [perl #78716].
+
+=item *
+
+C<POSIX> has been upgraded from 1.19 to 1.23.
+
+It now includes constants for POSIX signal constants.
+
+=item *
+
+C<re> has been upgraded from version 0.11 to 0.17.
+
+New C<use re "/flags"> pragma
+
+The C<regmust> function used to crash when called on a regular expression
+belonging to a pluggable engine. Now it croaks instead.
+
+C<regmust> no longer leaks memory.
+
+=item *
+
+C<Safe> has been upgraded from version 2.25 to 2.29.
+
+Coderefs returned by C<reval()> and C<rdo()> are now wrapped via
+C<wrap_code_refs> (5.12.1).
+
+This fixes a possible infinite loop when looking for coderefs.
+
+It adds several version::vxs::* routines to the default share.
+
+=item *
+
+C<SelfLoader> has been upgraded from 1.17 to 1.18.
+
+It now works in taint mode [perl #72062].
+
+=item *
+
+C<sigtrap> has been upgraded from version 1.04 to 1.05.
+
+It no longer tries to modify read-only arguments when generating a
+backtrace [perl #72340].
+
+=item *
+
+C<Socket> has been upgraded from version 1.87 to 1.94.
+
+See L</IPv6 support>, above.
+
+=item *
+
+C<Storable> has been upgraded from version 2.22 to 2.27.
+
+Includes performance improvement for overloaded classes.
+
+This adds support for serialising code references that contain UTF-8 strings
+correctly. The Storable minor version
+number changed as a result, meaning that
+Storable users who set C<$Storable::accept_future_minor> to a C<FALSE> value
+will see errors (see L<Storable/FORWARD COMPATIBILITY> for more details).
+
+Freezing no longer gets confused if the Perl stack gets reallocated
+during freezing [perl #80074].
+
+=item *
+
+C<Test::Simple> has been upgraded from version 0.94 to 0.98.
+
+Among many other things, subtests without a C<plan> or C<no_plan> now have an
+implicit C<done_testing()> added to them.
+
+=item *
+
+C<Thread::Semaphore> has been upgraded from version 2.09 to 2.12.
+
+It provides two new methods that give more control over the decrementing of
+semaphores: C<down_nb> and C<down_force>.
+
+=item *
+
+C<Tie::Hash> has been upgraded from version 1.03 to 1.04.
+
+Calling C<< Tie::Hash-E<gt>TIEHASH() >> used to loop forever. Now it C<croak>s.
+
+=item *
+
+C<Unicode::Collate> has been upgraded from version 0.52_01 to 0.73.
+
+Unicode::Collate has been updated to use Unicode 6.0.0.
+
+Unicode::Collate::Locale now supports a plethora of new locales: ar, be,
+bg, de__phonebook, hu, hy, kk, mk, nso, om, tn, vi, hr, ig, ja, ko, ru, sq,
+se, sr, to, uk, zh, zh__big5han, zh__gb2312han, zh__pinyin and zh__stroke.
+
+The following modules have been added:
+
+C<Unicode::Collate::CJK::Big5> for C<zh__big5han> which makes
+tailoring of CJK Unified Ideographs in the order of CLDR's big5han ordering.
+
+C<Unicode::Collate::CJK::GB2312> for C<zh__gb2312han> which makes
+tailoring of CJK Unified Ideographs in the order of CLDR's gb2312han ordering.
+
+C<Unicode::Collate::CJK::JISX0208> which makes tailoring of 6355 kanji
+(CJK Unified Ideographs) in the JIS X 0208 order.
+
+C<Unicode::Collate::CJK::Korean> which makes tailoring of CJK Unified Ideographs
+in the order of CLDR's Korean ordering.
+
+C<Unicode::Collate::CJK::Pinyin> for C<zh__pinyin> which makes
+tailoring of CJK Unified Ideographs in the order of CLDR's pinyin ordering.
+
+C<Unicode::Collate::CJK::Stroke> for C<zh__stroke> which makes
+tailoring of CJK Unified Ideographs in the order of CLDR's stroke ordering.
+
+This also sees the switch from using the pure-perl version of this
+module to the XS version.
+
+=item *
+
+C<Unicode::UCD> has been upgraded from version 0.27 to 0.32.
+
+A new function, C<Unicode::UCD::num()>, has been added. This function
+returns the numeric value of the string passed it or C<undef> if the string
+in its entirety has no "safe" numeric value. (For more detail, and for the
+definition of "safe", see L<Unicode::UCD/num>.)
+
+This upgrade also includes a number of bug fixes:
+
+=over 4
+
+=item charinfo()
+
+=over 4
+
+=item *
+
+It is now updated to Unicode Version 6 with Corrigendum #8, except,
+as with Perl 5.14, the code point at U+1F514 has no name.
+
+=item *
+
+The Hangul syllable code points have the correct names, and their
+decompositions are always output without requiring L<Lingua::KO::Hangul::Util>
+to be installed.
+
+=item *
+
+The CJK (Chinese-Japanese-Korean) code points U+2A700 to U+2B734
+and U+2B740 to U+2B81D are now properly handled.
+
+=item *
+
+The numeric values are now output for those CJK code points that have them.
+
+=item *
+
+The names that are output for code points with multiple aliases are now the
+corrected ones.
+
+=back
+
+=item charscript()
+
+This now correctly returns "Unknown" instead of C<undef> for the script
+of a code point that hasn't been assigned another one.
+
+=item charblock()
+
+This now correctly returns "No_Block" instead of C<undef> for the block
+of a code point that hasn't been assigned to another one.
+
+=back
+
+=item *
+
+C<version> has been upgraded from 0.82 to 0.88.
+
+Due to a bug, now fixed, the C<is_strict> and C<is_lax> functions did not
+work when exported (5.12.1).
+
+=item *
+
+C<warnings> and C<warnings::register> have been upgraded from version 1.09
+to 1.11 and from version 1.01 to 1.02 respectively.
+
+Calling C<use warnings> without arguments is now significantly more efficient.
+
+It is now possible to register warning categories other than the names of
+packages using C<warnings::register>. See L<perllexwarn> for more information.
+
+=item *
+
+C<VMS::DCLsym> has been upgraded from version 1.03 to 1.05.
+
+Two bugs have been fixed [perl #84086]:
+
+The symbol table name was lost when tying a hash, due to a thinko in
+C<TIEHASH>. The result was that all tied hashes interacted with the
+local symbol table.
+
+Unless a symbol table name had been explicitly specified in the call
+to the constructor, querying the special key ':LOCAL' failed to
+identify objects connected to the local symbol table.
+
+=item *
+
+C<Win32> has been upgraded from version 0.39 to 0.44.
+
+This release has several new functions: C<Win32::GetSystemMetrics>,
+C<Win32::GetProductInfo>, C<Win32::GetOSDisplayName>.
+
+The names returned by C<Win32::GetOSName> and C<Win32::GetOSDisplayName>
+have been corrected.
+
+=back
+
+=head2 Removed Modules and Pragmata
+
+The following modules have been removed from the core distribution, and if
+needed should be installed from CPAN instead.
+
+=over
+
+=item C<Class::ISA>
+
+=item C<Pod::Plainer>
+
+=item C<Switch>
+
+=back
+
+The removal of C<Shell> has been deferred until after 5.14, as the
+implementation of C<Shell> shipped with 5.12.0 did not correctly issue the
+warning that it was to be removed from core.
+
+=head1 Documentation
+
+=head2 New Documentation
+
+=head3 L<perlgpl>
+
+L<perlgpl> has been updated to contain GPL version 1, as is included in the
+F<README> distributed with perl (5.12.1).
+
+=head3 Perl 5.12.x delta files
+
+The perldelta files for Perl 5.12.1 to 5.12.3 have been added from the
+maintenance branch: L<perl5121delta>, L<perl5122delta>, L<perl5123delta>.
+
+=head3 L<perlpodstyle>
+
+New style guide for POD documentation,
+split mostly from the NOTES section of the pod2man man page.
+
+=head3 L<perlsource>, L<perlinterp>, L<perlhacktut>, and L<perlhacktips>
+
+See L</L<perlhack> and perlrepository revamp>, below.
+
+=head2 Changes to Existing Documentation
+
+=head3 L<perlmodlib> is now complete
+
+The perlmodlib page that came with Perl 5.12.0 was missing a lot of
+modules, due to a bug in the script that generates the list. This has been
+fixed [perl #74332] (5.12.1).
+
+=head3 Replace wrong tr/// table in L<perlebcdic>
+
+L<perlebcdic> contains a helpful table to use in tr/// to convert
+between EBCDIC and Latin1/ASCII. Unfortunately, the table was the
+inverse of the one it describes, though the code that used the table
+worked correctly for the specific example given.
+
+The table has been changed to its inverse, and the sample code changed
+to correspond, as this is easier for the person trying to follow the
+instructions since deriving the old table is somewhat more complicated.
+
+The table has also been changed to hex from octal, as that is more the norm
+these days, and the recipes in the pod altered to print out leading
+zeros to make all the values the same length.
+
+=head3 Tricks for user-defined casing
+
+L<perlunicode> now contains an explanation of how to override, mangle
+and otherwise tweak the way perl handles upper-, lower- and other-case
+conversions on Unicode data, and how to provide scoped changes to alter
+one's own code's behaviour without stomping on anybody else.
+
+=head3 INSTALL explicitly states the requirement for C89
+
+This was already true but it's now Officially Stated For The Record
+(5.12.2).
+
+=head3 Explanation of C<\xI<HH>> and C<\oI<OOO>> escapes
+
+L<perlop> has been updated with more detailed explanation of these two
+character escapes.
+
+=head3 C<-0I<NNN>> switch
+
+In L<perlrun>, the behavior of the C<-0NNN> switch for C<-0400> or higher
+has been clarified (5.12.2).
+
+=head3 Maintenance policy
+
+L<perlpolicy> now contains the policy on what patches are acceptable for
+maintenance branches (5.12.1).
+
+=head3 Deprecation policy
+
+L<perlpolicy> now contains the policy on compatibility and deprecation
+along with definitions of terms like "deprecation" (5.12.2).
+
+=head3 New descriptions in L<perldiag>
+
+The following existing diagnostics are now documented:
+
+=over 4
+
+=item *
+
+L<Ambiguous use of %c resolved as operator %c|perldiag/"Ambiguous use of %c resolved as operator %c">
+
+=item *
+
+L<Ambiguous use of %c{%s} resolved to %c%s|perldiag/"Ambiguous use of %c{%s} resolved to %c%s">
+
+=item *
+
+L<Ambiguous use of %c{%s%s} resolved to %c%s%s|perldiag/"Ambiguous use of %c{%s%s} resolved to %c%s%s">
+
+=item *
+
+L<Ambiguous use of -%s resolved as -&%s()|perldiag/"Ambiguous use of -%s resolved as -&%s()">
+
+=item *
+
+L<Invalid strict version format (%s)|perldiag/"Invalid strict version format (%s)">
+
+=item *
+
+L<Invalid version format (%s)|perldiag/"Invalid version format (%s)">
+
+=item *
+
+L<Invalid version object|perldiag/"Invalid version object">
+
+=back
+
+=head3 L<perlbook>
+
+L<perlbook> has been expanded to cover many more popular books.
+
+=head3 C<SvTRUE> macro
+
+The documentation for the C<SvTRUE> macro in
+L<perlapi> was simply wrong in stating that
+get-magic is not processed. It has been corrected.
+
+=head3 L<perlvar> revamp
+
+L<perlvar> reorders the variables and groups them by topic. Each variable
+introduced after Perl 5.000 notes the first version in which it is
+available. L<perlvar> also has a new section for deprecated variables to
+note when they were removed.
+
+=head3 Array and hash slices in scalar context
+
+These are now documented in L<perldata>.
+
+=head3 C<use locale> and formats
+
+L<perlform> and L<perllocale> have been corrected to state that
+C<use locale> affects formats.
+
+=head3 L<overload>
+
+L<overload>'s documentation has practically undergone a rewrite. It
+is now much more straightforward and clear.
+
+=head3 L<perlhack> and perlrepository revamp
+
+The L<perlhack> and perlrepository documents have been heavily edited and
+split up into several new documents.
+
+The L<perlhack> document is now much shorter, and focuses on the Perl 5
+development process and submitting patches to Perl. The technical content has
+been moved to several new documents, L<perlsource>, L<perlinterp>,
+L<perlhacktut>, and L<perlhacktips>. This technical content has only been
+lightly edited.
+
+The perlrepository document has been renamed to L<perlgit>. This new document
+is just a how-to on using git with the Perl source code. Any other content
+that used to be in perlrepository has been moved to perlhack.
+
+=head3 Time::Piece examples
+
+Examples in L<perlfaq4> have been updated to show the use of
+L<Time::Piece>.
+
+=head1 Diagnostics
+
+The following additions or changes have been made to diagnostic output,
+including warnings and fatal error messages. For the complete list of
+diagnostic messages, see L<perldiag>.
+
+=head2 New Diagnostics
+
+=head3 New Errors
+
+=over
+
+=item Closure prototype called
+
+This error occurs when a subroutine reference passed to an attribute
+handler is called, if the subroutine is a closure [perl #68560].
+
+=item Insecure user-defined property %s
+
+Perl detected tainted data when trying to compile a regular
+expression that contains a call to a user-defined character property
+function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
+See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
+
+=item panic: gp_free failed to free glob pointer - something is repeatedly re-creating entries
+
+This new error is triggered if a destructor called on an object in a
+typeglob that is being freed creates a new typeglob entry containing an
+object with a destructor that creates a new entry containing an object....
+
+=item Parsing code internal error (%s)
+
+This new fatal error is produced when parsing
+code supplied by an extension violates the
+parser's API in a detectable way.
+
+=item refcnt: fd %d%s
+
+This new error only occurs if a internal consistency check fails when a
+pipe is about to be closed.
+
+=item Regexp modifier "/%c" may not appear twice
+
+The regular expression pattern has one of the
+mutually exclusive modifiers repeated.
+
+=item Regexp modifiers "/%c" and "/%c" are mutually exclusive
+
+The regular expression pattern has more than one of the mutually
+exclusive modifiers.
+
+=item Using !~ with %s doesn't make sense
+
+This error occurs when C<!~> is used with C<s///r> or C<y///r>.
+
+=back
+
+=head3 New Warnings
+
+=over
+
+=item "\b{" is deprecated; use "\b\{" instead
+
+=item "\B{" is deprecated; use "\B\{" instead
+
+Use of an unescaped "{" immediately following a C<\b> or C<\B> is now
+deprecated so as to reserve its use for Perl itself in a future release.
+
+=item Operation "%s" returns its argument for ...
+
+Performing an operation requiring Unicode semantics (such as case-folding)
+on a Unicode surrogate or a non-Unicode character now triggers a warning:
+'Operation "%s" returns its argument for ...'.
+
+=item Use of qw(...) as parentheses is deprecated
+
+See L</"Use of qw(...) as parentheses">, above, for details.
+
+=back
+
+=head2 Changes to Existing Diagnostics
+
+=over 4
+
+=item *
+
+The "Variable $foo is not imported" warning that precedes a
+C<strict 'vars'> error has now been assigned the "misc" category, so that
+C<no warnings> will suppress it [perl #73712].
+
+=item *
+
+C<warn> and C<die> now produce 'Wide character' warnings when fed a
+character outside the byte range if STDERR is a byte-sized handle.
+
+=item *
+
+The 'Layer does not match this perl' error message has been replaced with
+these more helpful messages [perl #73754]:
+
+=over 4
+
+=item *
+
+PerlIO layer function table size (%d) does not match size expected by this
+perl (%d)
+
+=item *
+
+PerlIO layer instance size (%d) does not match size expected by this perl
+(%d)
+
+=back
+
+=item *
+
+The "Found = in conditional" warning that is emitted when a constant is
+assigned to a variable in a condition is now withheld if the constant is
+actually a subroutine or one generated by C<use constant>, since the value
+of the constant may not be known at the time the program is written
+[perl #77762].
+
+=item *
+
+Previously, if none of the C<gethostbyaddr>, C<gethostbyname> and
+C<gethostent> functions were implemented on a given platform, they would
+all die with the message 'Unsupported socket function "gethostent" called',
+with analogous messages for C<getnet*> and C<getserv*>. This has been
+corrected.
+
+=item *
+
+The warning message about unrecognized regular expression escapes passed
+through has been changed to include any literal '{' following the
+two-character escape. E.g., "\q{" is now emitted instead of "\q".
+
+=back
+
+=head1 Utility Changes
+
+=head3 L<perlbug>
+
+=over 4
+
+=item *
+
+L<perlbug> now looks in the EMAIL environment variable for a return address
+if the REPLY-TO and REPLYTO variables are empty.
+
+=item *
+
+L<perlbug> did not previously generate a From: header, potentially
+resulting in dropped mail. Now it does include that header.
+
+=item *
+
+The user's address is now used as the return-path.
+
+Many systems these days don't have a valid Internet domain name and
+perlbug@perl.org does not accept email with a return-path that does
+not resolve. So the user's address is now passed to sendmail so it's
+less likely to get stuck in a mail queue somewhere [perl #82996].
+
+=item *
+
+L<perlbug> now always gives the reporter a chance to change the email
+address it guesses for them (5.12.2).
+
+=item *
+
+L<perlbug> should no longer warn about uninitialized values when using the C<-d>
+and C<-v> options (5.12.2).
+
+=back
+
+=head3 L<perl5db.pl>
+
+=over
+
+=item *
+
+The remote terminal works after forking and spawns new sessions - one
+for each forked process.
+
+=back
+
+=head3 L<ptargrep>
+
+=over 4
+
+=item *
+
+L<ptargrep> is a new utility to apply pattern matching to the contents of
+files in a tar archive. It comes with C<Archive::Tar>.
+
+=back
+
+=head1 Configuration and Compilation
+
+See also L</"Naming fixes in Policy_sh.SH may invalidate Policy.sh">,
+above.
+
+=over 4
+
+=item *
+
+CCINCDIR and CCLIBDIR for the mingw64
+cross-compiler are now correctly under
+$(CCHOME)\mingw\include and \lib rather than immediately below $(CCHOME).
+
+This means the 'incpath', 'libpth', 'ldflags', 'lddlflags' and
+'ldflags_nolargefiles' values in Config.pm and Config_heavy.pl are now
+set correctly.
+
+=item *
+
+'make test.valgrind' has been adjusted to account for cpan/dist/ext
+separation.
+
+=item *
+
+On compilers that support it, C<-Wwrite-strings> is now added to cflags by
+default.
+
+=item *
+
+The C<Encode> module can now (once again) be included in a static Perl
+build. The special-case handling for this situation got broken in Perl
+5.11.0, and has now been repaired.
+
+=item *
+
+The previous default size of a PerlIO buffer (4096 bytes) has been increased
+to the larger of 8192 bytes and your local BUFSIZ. Benchmarks show that doubling
+this decade-old default increases read and write performance in the neighborhood
+of 25% to 50% when using the default layers of perlio on top of unix. To choose
+a non-default size, such as to get back the old value or to obtain an even
+larger value, configure with:
+
+ ./Configure -Accflags=-DPERLIOBUF_DEFAULT_BUFSIZ=N
+
+where N is the desired size in bytes; it should probably be a multiple of
+your page size.
+
+=item *
+
+An "incompatible operand types" error in ternary expressions when building
+with C<clang> has been fixed (5.12.2).
+
+=item *
+
+Perl now skips setuid C<File::Copy> tests on partitions it detects to be mounted
+as C<nosuid> (5.12.2).
+
+=back
+
+=head1 Platform Support
+
+=head2 New Platforms
+
+=over 4
+
+=item AIX
+
+Perl now builds on AIX 4.2 (5.12.1).
+
+=back
+
+=head2 Discontinued Platforms
+
+=over 4
+
+=item Apollo DomainOS
+
+The last vestiges of support for this platform have been excised from the
+Perl distribution. It was officially discontinued in version 5.12.0. It had
+not worked for years before that.
+
+=item MacOS Classic
+
+The last vestiges of support for this platform have been excised from the
+Perl distribution. It was officially discontinued in an earlier version.
+
+=back
+
+=head2 Platform-Specific Notes
+
+=head3 AIX
+
+=over
+
+=item *
+
+F<README.aix> has been updated with information about the XL C/C++ V11 compiler
+suite (5.12.2).
+
+=back
+
+=head3 ARM
+
+=over
+
+=item *
+
+The C<d_u32align> configuration probe on ARM has been fixed (5.12.2).
+
+=back
+
+=head3 Cygwin
+
+=over 4
+
+=item *
+
+MakeMaker has been updated to build man pages on cygwin.
+
+=item *
+
+Improved rebase behaviour
+
+If a dll is updated on cygwin the old imagebase address is reused.
+This solves most rebase errors, especially when updating on core dll's.
+See L<http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README> for more information.
+
+=item *
+
+Support for the standard cygwin dll prefix, which is e.g. needed for FFI's
+
+=item *
+
+Updated build hints file
+
+=back
+
+=head3 FreeBSD 7
+
+=over
+
+=item *
+
+FreeBSD 7 no longer contains F</usr/bin/objformat>. At build time,
+Perl now skips the F<objformat> check for versions 7 and higher and
+assumes ELF (5.12.1).
+
+=back
+
+=head3 HP-UX
+
+=over
+
+=item *
+
+Perl now allows -Duse64bitint without promoting to use64bitall on HP-UX
+(5.12.1).
+
+=back
+
+=head3 IRIX
+
+Conversion of strings to floating-point numbers is now more accurate on
+IRIX systems [perl #32380].
+
+=head3 Mac OS X
+
+Early versions of Mac OS X (Darwin) had buggy implementations of the
+C<setregid>, C<setreuid>, C<setrgid> and C<setruid> functions, so perl
+would pretend they did not exist.
+
+These functions are now recognised on Mac OS 10.5 (Leopard; Darwin 9) and
+higher, as they have been fixed [perl #72990].
+
+=head3 MirBSD
+
+Previously if you built perl with a shared libperl.so on MirBSD (the
+default config), it would work up to the installation; however, once
+installed, it would be unable to find libperl. So path handling is now
+treated as in the other BSD dialects.
+
+=head3 NetBSD
+
+The NetBSD hints file has been changed to make the system's malloc the
+default.
+
+=head3 Recent OpenBSDs now use perl's malloc
+
+OpenBSD E<gt> 3.7 has a new malloc implementation which is mmap-based
+and as such can release memory back to the OS; however, perl's use of
+this malloc causes a substantial slowdown so we now default to using
+perl's malloc instead [perl #75742].
+
+=head3 OpenVOS
+
+perl now builds again with OpenVOS (formerly known as Stratus VOS)
+[perl #78132] (5.12.3).
+
+=head3 Solaris
+
+DTrace is now supported on Solaris. There used to be build failures, but
+these have been fixed [perl #73630] (5.12.3).
+
+=head3 VMS
+
+=over
+
+=item *
+
+It's now possible to build extensions on older (pre 7.3-2) VMS systems.
+
+DCL symbol length was limited to 1K up until about seven years or
+so ago, but there was no particularly deep reason to prevent those
+older systems from configuring and building Perl (5.12.1).
+
+=item *
+
+We fixed the previously-broken C<-Uuseperlio> build on VMS.
+
+We were checking a variable that doesn't exist in the non-default
+case of disabling perlio. Now we only look at it when it exists (5.12.1).
+
+=item *
+
+We fixed the -Uuseperlio command-line option in configure.com.
+
+Formerly it only worked if you went through all the questions
+interactively and explicitly answered no (5.12.1).
+
+=item *
+
+C<PerlIOUnix_open> now honours the default permissions on VMS.
+
+When C<perlio> became the default and C<unixio> became the default bottom layer,
+the most common path for creating files from Perl became C<PerlIOUnix_open>,
+which has always explicitly used C<0666> as the permission mask.
+
+To avoid this, C<0777> is now passed as the permissions to C<open()>. In the
+VMS CRTL, C<0777> has a special meaning over and above intersecting with the
+current umask; specifically, it allows Unix syscalls to preserve native default
+permissions (5.12.3).
+
+=item *
+
+Spurious record boundaries are no longer
+introduced by the PerlIO layer during output (5.12.3).
+
+=item *
+
+The shortening of symbols longer than 31 characters in the C sources is
+now done by the compiler rather than by xsubpp (which could only do so
+for generated symbols in XS code).
+
+=item *
+
+Record-oriented files (record format variable or variable with fixed control)
+opened for write by the perlio layer will now be line-buffered to prevent the
+introduction of spurious line breaks whenever the perlio buffer fills up.
+
+=item *
+
+F<git_version.h> is now installed on VMS. This was an oversight in v5.12.0 which
+caused some extensions to fail to build (5.12.2).
+
+=item *
+
+Several memory leaks in L<stat()|perlfunc/"stat FILEHANDLE"> have been fixed (5.12.2).
+
+=item *
+
+A memory leak in C<Perl_rename()> due to a double allocation has been
+fixed (5.12.2).
+
+=item *
+
+A memory leak in C<vms_fid_to_name()> (used by C<realpath()> and
+C<realname()>) has been fixed (5.12.2).
+
+=back
+
+=head3 Windows
+
+See also L</"fork() emulation will not wait for signalled children"> and
+L</"Perl source code is read in text mode on Windows">, above.
+
+=over 4
+
+=item *
+
+Fixed build process for SDK2003SP1 compilers.
+
+=item *
+
+Compilation with Visual Studio 2010 is now supported.
+
+=item *
+
+When using old 32-bit compilers, the define C<_USE_32BIT_TIME_T> will now
+be set in C<$Config{ccflags}>. This improves portability when compiling
+XS extensions using new compilers, but for a perl compiled with old 32-bit
+compilers.
+
+=item *
+
+C<$Config{gccversion}> is now set correctly when perl is built using the
+mingw64 compiler from L<http://mingw64.org> [perl #73754].
+
+=item *
+
+When building Perl with the mingw64 x64 cross-compiler C<incpath>,
+C<libpth>, C<ldflags>, C<lddlflags> and C<ldflags_nolargefiles> values
+in F<Config.pm> and F<Config_heavy.pl> were not previously being set
+correctly because, with that compiler, the include and lib directories
+are not immediately below C<$(CCHOME)> (5.12.2).
+
+=item *
+
+The build process proceeds more smoothly with mingw and dmake when
+F<C:\MSYS\bin> is in the PATH, due to a C<Cwd> fix.
+
+=item *
+
+Support for building with Visual C++ 2010 is now underway, but is not yet
+complete. See F<README.win32> or L<perlwin32> for more details.
+
+=item *
+
+The option to use an externally-supplied C<crypt()>, or to build with no
+C<crypt()> at all, has been removed. Perl supplies its own C<crypt()>
+implementation for Windows, and the political situation that required
+this part of the distribution to sometimes be omitted is long gone.
+
+=back
+
+=head1 Internal Changes
+
+=head2 New APIs
+
+=head3 CLONE_PARAMS structure added to ease correct thread creation
+
+Modules that create threads should now create C<CLONE_PARAMS> structures
+by calling the new function C<Perl_clone_params_new()>, and free them with
+C<Perl_clone_params_del()>. This will ensure compatibility with any future
+changes to the internals of the C<CLONE_PARAMS> structure layout, and that
+it is correctly allocated and initialised.
+
+=head3 New parsing functions
+
+Several functions have been added for parsing statements or multiple
+statements:
+
+=over
+
+=item *
+
+C<parse_fullstmt> parses a complete Perl statement.
+
+=item *
+
+C<parse_stmtseq> parses a sequence of statements, up
+to closing brace or EOF.
+
+=item *
+
+C<parse_block> parses a block [perl #78222].
+
+=item *
+
+C<parse_barestmt> parses a statement
+without a label.
+
+=item *
+
+C<parse_label> parses a statement label, separate from statements.
+
+=back
+
+The
+L<C<parse_fullexpr()>|perlapi/parse_fullexpr>,
+L<C<parse_listexpr()>|perlapi/parse_listexpr>,
+L<C<parse_termexpr()>|perlapi/parse_termexpr>, and
+L<C<parse_arithexpr()>|perlapi/parse_arithexpr>
+functions have been added to the API. They perform
+recursive-descent parsing of expressions at various precedence levels.
+They are expected to be used by syntax plugins.
+
+See L<perlapi> for details.
+
+=head3 Hints hash API
+
+A new C API for introspecting the hinthash C<%^H> at runtime has been
+added. See C<cop_hints_2hv>, C<cop_hints_fetchpvn>, C<cop_hints_fetchpvs>,
+C<cop_hints_fetchsv>, and C<hv_copy_hints_hv> in L<perlapi> for details.
+
+A new, experimental API has been added for accessing the internal
+structure that Perl uses for C<%^H>. See the functions beginning with
+C<cophh_> in L<perlapi>.
+
+=head3 C interface to C<caller()>
+
+The C<caller_cx> function has been added as an XSUB-writer's equivalent of
+C<caller()>. See L<perlapi> for details.
+
+=head3 Custom per-subroutine check hooks
+
+XS code in an extension module can now annotate a subroutine (whether
+implemented in XS or in Perl) so that nominated XS code will be called
+at compile time (specifically as part of op checking) to change the op
+tree of that subroutine. The compile-time check function (supplied by
+the extension module) can implement argument processing that can't be
+expressed as a prototype, generate customised compile-time warnings,
+perform constant folding for a pure function, inline a subroutine
+consisting of sufficiently simple ops, replace the whole call with a
+custom op, and so on. This was previously all possible by hooking the
+C<entersub> op checker, but the new mechanism makes it easy to tie the
+hook to a specific subroutine. See L<perlapi/cv_set_call_checker>.
+
+To help in writing custom check hooks, several subtasks within standard
+C<entersub> op checking have been separated out and exposed in the API.
+
+=head3 Improved support for custom OPs
+
+Custom ops can now be registered with the new C<custom_op_register> C
+function and the C<XOP> structure. This will make it easier to add new
+properties of custom ops in the future. Two new properties have been added
+already, C<xop_class> and C<xop_peep>.
+
+C<xop_class> is one of the OA_*OP constants, and allows L<B> and other
+introspection mechanisms to work with custom ops
+that aren't BASEOPs. C<xop_peep> is a pointer to
+a function that will be called for ops of this
+type from C<Perl_rpeep>.
+
+See L<perlguts/Custom Operators> and L<perlapi/Custom Operators> for more
+detail.
+
+The old C<PL_custom_op_names>/C<PL_custom_op_descs> interface is still
+supported but discouraged.
+
+=head3 Scope hooks
+
+It is now possible for XS code to hook into Perl's lexical scope
+mechanism at compile time, using the new C<Perl_blockhook_register>
+function. See L<perlguts/"Compile-time scope hooks">.
+
+=head3 The recursive part of the peephole optimizer is now hookable
+
+In addition to C<PL_peepp>, for hooking into the toplevel peephole optimizer, a
+C<PL_rpeepp> is now available to hook into the optimizer recursing into
+side-chains of the optree.
+
+=head3 New non-magical variants of existing functions
+
+The following functions/macros have been added to the API. The C<*_nomg>
+macros are equivalent to their non-_nomg variants, except that they ignore
+get-magic. Those ending in C<_flags> allow one to specify whether
+get-magic is processed.
+
+ sv_2bool_flags
+ SvTRUE_nomg
+ sv_2nv_flags
+ SvNV_nomg
+ sv_cmp_flags
+ sv_cmp_locale_flags
+ sv_eq_flags
+ sv_collxfrm_flags
+
+In some of these cases, the non-_flags functions have
+been replaced with wrappers around the new functions.
+
+=head3 pv/pvs/sv versions of existing functions
+
+Many functions ending with pvn now have equivalent pv/pvs/sv versions.
+
+=head3 List op-building functions
+
+List op-building functions have been added to the
+API. See L<op_append_elem|perlapi/op_append_elem>,
+L<op_append_list|perlapi/op_append_list>, and
+L<op_prepend_elem|perlapi/op_prepend_elem> in L<perlapi>.
+
+=head3 C<LINKLIST>
+
+The L<LINKLIST|perlapi/LINKLIST> macro, part of op building that
+constructs the execution-order op chain, has been added to the API.
+
+=head3 Localisation functions
+
+The C<save_freeop>, C<save_op>, C<save_pushi32ptr> and C<save_pushptrptr>
+functions have been added to the API.
+
+=head3 Stash names
+
+A stash can now have a list of effective names in addition to its usual
+name. The first effective name can be accessed via the C<HvENAME> macro,
+which is now the recommended name to use in MRO linearisations (C<HvNAME>
+being a fallback if there is no C<HvENAME>).
+
+These names are added and deleted via C<hv_ename_add> and
+C<hv_ename_delete>. These two functions are I<not> part of the API.
+
+=head3 New functions for finding and removing magic
+
+The L<C<mg_findext()>|perlapi/mg_findext> and
+L<C<sv_unmagicext()>|perlapi/sv_unmagicext>
+functions have been added to the API.
+They allow extension authors to find and remove magic attached to
+scalars based on both the magic type and the magic virtual table, similar to how
+C<sv_magicext()> attaches magic of a certain type and with a given virtual table
+to a scalar. This eliminates the need for extensions to walk the list of
+C<MAGIC> pointers of an C<SV> to find the magic that belongs to them.
+
+=head3 C<find_rundefsv>
+
+This function returns the SV representing C<$_>, whether it's lexical
+or dynamic.
+
+=head3 C<Perl_croak_no_modify>
+
+C<Perl_croak_no_modify()> is short-hand for
+C<Perl_croak("%s", PL_no_modify)>.
+
+=head3 C<PERL_STATIC_INLINE> define
+
+The C<PERL_STATIC_INLINE> define has been added to provide the best-guess
+incantation to use for static inline functions, if the C compiler supports
+C99-style static inline. If it doesn't, it'll give a plain C<static>.
+
+C<HAS_STATIC_INLINE> can be used to check if the compiler actually supports
+inline functions.
+
+=head3 New C<pv_escape> option for hexadecimal escapes
+
+A new option, C<PERL_PV_ESCAPE_NONASCII>, has been added to C<pv_escape> to
+dump all characters above ASCII in hexadecimal. Before, one could get all
+characters as hexadecimal or the Latin1 non-ASCII as octal.
+
+=head3 C<lex_start>
+
+C<lex_start> has been added to the API, but is considered experimental.
+
+=head3 C<op_scope()> and C<op_lvalue()>
+
+The C<op_scope()> and C<op_lvalue()> functions have been added to the API,
+but are considered experimental.
+
+=head2 C API Changes
+
+=head3 C<PERL_POLLUTE> has been removed
+
+The option to define C<PERL_POLLUTE> to expose older 5.005 symbols for
+backwards compatibility has been removed. It's use was always discouraged,
+and MakeMaker contains a more specific escape hatch:
+
+ perl Makefile.PL POLLUTE=1
+
+This can be used for modules that have not been upgraded to 5.6 naming
+conventions (and really should be completely obsolete by now).
+
+=head3 Check API compatibility when loading XS modules
+
+When perl's API changes in incompatible ways (which usually happens between
+major releases), XS modules compiled for previous versions of perl will not
+work anymore. They will need to be recompiled against the new perl.
+
+In order to ensure that modules are recompiled, and to prevent users from
+accidentally loading modules compiled for old perls into newer ones, the
+C<XS_APIVERSION_BOOTCHECK> macro has been added. That macro, which is
+called when loading every newly compiled extension, compares the API
+version of the running perl with the version a module has been compiled for
+and raises an exception if they don't match.
+
+=head3 Perl_fetch_cop_label
+
+The first argument of the C API function C<Perl_fetch_cop_label> has changed
+from C<struct refcounted he *> to C<COP *>, to insulate the user from
+implementation details.
+
+This API function was marked as "may change", and likely isn't in use outside
+the core. (Neither an unpacked CPAN, nor Google's codesearch, finds any other
+references to it.)
+
+=head3 GvCV() and GvGP() are no longer lvalues
+
+The new GvCV_set() and GvGP_set() macros are now provided to replace
+assignment to those two macros.
+
+This allows a future commit to eliminate some backref magic between GV
+and CVs, which will require complete control over assignment to the
+gp_cv slot.
+
+=head3 CvGV() is no longer an lvalue
+
+Under some circumstances, the C<CvGV()> field of a CV is now
+reference-counted. To ensure consistent behaviour, direct assignment to
+it, for example C<CvGV(cv) = gv> is now a compile-time error. A new macro,
+C<CvGV_set(cv,gv)> has been introduced to perform this operation
+safely. Note that modification of this field is not part of the public
+API, regardless of this new macro (and despite its being listed in this section).
+
+=head3 CvSTASH() is no longer an lvalue
+
+The C<CvSTASH()> macro can now only be used as an rvalue. C<CvSTASH_set()>
+has been added to replace assignment to C<CvSTASH()>. This is to ensure
+that backreferences are handled properly. These macros are not part of the
+API.
+
+=head3 Calling conventions for C<newFOROP> and C<newWHILEOP>
+
+The way the parser handles labels has been cleaned up and refactored. As a
+result, the C<newFOROP()> constructor function no longer takes a parameter
+stating what label is to go in the state op.
+
+The C<newWHILEOP()> and C<newFOROP()> functions no longer accept a line
+number as a parameter.
+
+=head3 Flags passed to C<uvuni_to_utf8_flags> and C<utf8n_to_uvuni>
+
+Some of the flags parameters to uvuni_to_utf8_flags() and
+utf8n_to_uvuni() have changed. This is a result of Perl's now allowing
+internal storage and manipulation of code points that are problematic
+in some situations. Hence, the default actions for these functions has
+been complemented to allow these code points. The new flags are
+documented in L<perlapi>. Code that requires the problematic code
+points to be rejected needs to change to use the new flags. Some flag
+names are retained for backward source compatibility, though they do
+nothing, as they are now the default. However the flags
+C<UNICODE_ALLOW_FDD0>, C<UNICODE_ALLOW_FFFF>, C<UNICODE_ILLEGAL>, and
+C<UNICODE_IS_ILLEGAL> have been removed, as they stem from a
+fundamentally broken model of how the Unicode non-character code points
+should be handled, which is now described in
+L<perlunicode/Non-character code points>. See also L</Selected Bug Fixes>.
+
+XXX Which bugs in particular? Selected Bug Fixes is too long for this link
+to be meaningful right now
+I don't see the bugs in that section currently -- khw
+
+=head2 Deprecated C APIs
+
+=over
+
+=item C<Perl_ptr_table_clear>
+
+C<Perl_ptr_table_clear> is no longer part of Perl's public API. Calling it
+now generates a deprecation warning, and it will be removed in a future
+release.
+
+=item C<sv_compile_2op>
+
+The C<sv_compile_2op()> API function is now deprecated. Searches suggest
+that nothing on CPAN is using it, so this should have zero impact.
+
+It attempted to provide an API to compile code down to an optree, but failed
+to bind correctly to lexicals in the enclosing scope. It's not possible to
+fix this problem within the constraints of its parameters and return value.
+
+=item C<find_rundefsvoffset>
+
+The C<find_rundefsvoffset> function has been deprecated. It appeared that
+its design was insufficient for reliably getting the lexical C<$_> at
+run-time.
+
+Use the new C<find_rundefsv> function or the C<UNDERBAR> macro
+instead. They directly return the right SV representing C<$_>, whether it's
+lexical or dynamic.
+
+=item C<CALL_FPTR> and C<CPERLscope>
+
+Those are left from an old implementation of C<MULTIPLICITY> using C++ objects,
+which was removed in Perl 5.8. Nowadays these macros do exactly nothing, so
+they shouldn't be used anymore.
+
+For compatibility, they are still defined for external C<XS> code. Only
+extensions defining C<PERL_CORE> must be updated now.
+
+=back
+
+=head2 Other Internal Changes
+
+=head3 Stack unwinding
+
+The protocol for unwinding the C stack at the last stage of a C<die>
+has changed how it identifies the target stack frame. This now uses
+a separate variable C<PL_restartjmpenv>, where previously it relied on
+the C<blk_eval.cur_top_env> pointer in the C<eval> context frame that
+has nominally just been discarded. This change means that code running
+during various stages of Perl-level unwinding no longer needs to take
+care to avoid destroying the ghost frame.
+
+=head3 Scope stack entries
+
+The format of entries on the scope stack has been changed, resulting in a
+reduction of memory usage of about 10%. In particular, the memory used by
+the scope stack to record each active lexical variable has been halved.
+
+=head3 Memory allocation for pointer tables
+
+Memory allocation for pointer tables has been changed. Previously
+C<Perl_ptr_table_store> allocated memory from the same arena system as
+C<SV> bodies and C<HE>s, with freed memory remaining bound to those arenas
+until interpreter exit. Now it allocates memory from arenas private to the
+specific pointer table, and that memory is returned to the system when
+C<Perl_ptr_table_free> is called. Additionally, allocation and release are
+both less CPU intensive.
+
+=head3 C<UNDERBAR>
+
+The C<UNDERBAR> macro now calls C<find_rundefsv>. C<dUNDERBAR> is now a
+noop but should still be used to ensure past and future compatibility.
+
+=head3 String comparison routines renamed
+
+The ibcmp_* functions have been renamed and are now called foldEQ,
+foldEQ_locale and foldEQ_utf8. The old names are still available as
+macros.
+
+=head3 C<chop> and C<chomp> implementations merged
+
+The opcode bodies for C<chop> and C<chomp> and for C<schop> and C<schomp>
+have been merged. The implementation functions C<Perl_do_chop()> and
+C<Perl_do_chomp()>, never part of the public API, have been merged and
+moved to a static function in F<pp.c>. This shrinks the perl binary
+slightly, and should not affect any code outside the core (unless it is
+relying on the order of side effects when C<chomp> is passed a I<list> of
+values).
+
+=head1 Selected Bug Fixes
+
+=head2 I/O
+
+=over 4
+
+=item *
+
+Perl no longer produces this warning:
+
+ $ perl -we 'open my $f, ">", \my $x; binmode $f, "scalar"'
+ Use of uninitialized value in binmode at -e line 1.
+
+=item *
+
+Opening a glob reference via C<< open $fh, "E<gt>", \*glob >> will no longer
+cause the glob to be corrupted when the filehandle is printed to. This would
+cause perl to crash whenever the glob's contents were accessed
+[perl #77492].
+
+=item *
+
+PerlIO no longer crashes when called recursively, e.g., from a signal
+handler. Now it just leaks memory [perl #75556].
+
+=item *
+
+Most I/O functions were not warning for unopened handles unless the
+'closed' and 'unopened' warnings categories were both enabled. Now only
+C<use warnings 'unopened'> is necessary to trigger these warnings (as was
+always meant to be the case).
+
+=item *
+
+There have been several fixes to PerlIO layers:
+
+When C<binmode FH, ":crlf"> pushes the C<:crlf> layer on top of the stack,
+it no longer enables crlf layers lower in the stack, to avoid unexpected
+results [perl #38456].
+
+Opening a file in C<:raw> mode now does what it advertises to do (first
+open the file, then binmode it), instead of simply leaving off the top
+layer [perl #80764].
+
+The three layers C<:pop>, C<:utf8> and C<:bytes> didn't allow stacking when
+opening a file. For example
+this:
+
+ open FH, '>:pop:perlio', 'some.file' or die $!;
+
+Would throw an error: "Invalid argument". This has been fixed in this
+release [perl #82484].
+
+=back
+
+=head2 Regular Expression Bug Fixes
+
+=over
+
+=item *
+
+The regular expression engine no longer loops when matching
+C<"\N{LATIN SMALL LIGATURE FF}" =~ /f+/i> and similar expressions
+[perl #72998] (5.12.1).
+
+=item *
+
+The trie runtime code should no longer allocate massive amounts of memory,
+fixing #74484.
+
+=item *
+
+Syntax errors in C<< (?{...}) >> blocks no longer cause panic messages
+[perl #2353].
+
+=item *
+
+A pattern like C<(?:(o){2})?> no longer causes a "panic" error
+[perl #39233].
+
+=item *
+
+A fatal error in regular expressions containing C<(.*?)> when processing
+UTF-8 data has been fixed [perl #75680] (5.12.2).
+
+=item *
+
+An erroneous regular expression engine optimisation that caused regex verbs like
+C<*COMMIT> sometimes to be ignored has been removed.
+
+=item *
+
+The regular expression bracketed character class C<[\8\9]> was effectively the
+same as C<[89\000]>, incorrectly matching a NULL character. It also gave
+incorrect warnings that the C<8> and C<9> were ignored. Now C<[\8\9]> is the
+same as C<[89]> and gives legitimate warnings that C<\8> and C<\9> are
+unrecognized escape sequences, passed-through.
+
+=item *
+
+A regular expression match in the right-hand side of a global substitution
+(C<s///g>) that is in the same scope will no longer cause match variables
+to have the wrong values on subsequent iterations. This can happen when an
+array or hash subscript is interpolated in the right-hand side, as in
+C<s|(.)|@a{ print($1), /./ }|g> [perl #19078].
+
+=item *
+
+Several cases in which characters in the Latin-1 non-ASCII range (0x80 to
+0xFF) used not to match themselves or used to match both a character class
+and its complement have been fixed. For instance, U+00E2 could match both
+C<\w> and C<\W> [perl #78464] [perl #18281] [perl #60156].
+
+=item *
+
+Matching a Unicode character against an alternation containing characters
+that happened to match continuation bytes in the former's UTF8
+representation (C<qq{\x{30ab}} =~ /\xab|\xa9/>) would cause erroneous
+warnings [perl #70998].
+
+=item *
+
+The trie optimisation was not taking empty groups into account, preventing
+'foo' from matching C</\A(?:(?:)foo|bar|zot)\z/> [perl #78356].
+
+=item *
+
+A pattern containing a C<+> inside a lookahead would sometimes cause an
+incorrect match failure in a global match (e.g., C</(?=(\S+))/g>)
+[perl #68564].
+
+=item *
+
+A regular expression optimisation would sometimes cause a match with a
+C<{n,m}> quantifier to fail when it should match [perl #79152].
+
+=item *
+
+Case insensitive matching in regular expressions compiled under C<use
+locale> now works much more sanely when the pattern or
+target string is encoded internally in
+UTF8. Previously, under these conditions the localeness
+was completely lost. Now, code points above 255 are treated as Unicode,
+but code points between 0 and 255 are treated using the current locale
+rules, regardless of whether the pattern or the string is encoded in UTF8.
+The few case-insensitive matches that cross the 255/256 boundary are not
+allowed. For example, 0xFF does not caselessly match the character at
+0x178, LATIN CAPITAL LETTER Y WITH DIAERESIS, because 0xFF may not be
+LATIN SMALL LETTER Y in the current locale, and Perl has no way of
+knowing if that character even exists in the locale, much less what code
+point it is.
+
+=item *
+
+The C<(?|...)> regular expression construct no longer crashes if the final
+branch has more sets of capturing parentheses than any other branch. This
+was fixed in Perl 5.10.1 for the case of a single branch, but that fix did
+not take multiple branches into account [perl #84746].
+
+=item *
+
+A bug has been fixed in the implementation of C<{...}> quantifiers in
+regular expressions that prevented the code block in
+C</((\w+)(?{ print $2 })){2}/> from seeing the C<$2> sometimes
+[perl #84294].
+
+=back
+
+=head2 Syntax/Parsing Bugs
+
+=over
+
+=item *
+
+C<when(scalar){...}> no longer crashes, but produces a syntax error
+[perl #74114] (5.12.1).
+
+=item *
+
+A label right before a string eval (C<foo: eval $string>) no longer causes
+the label to be associated also with the first statement inside the eval
+[perl #74290] (5.12.1).
+
+=item *
+
+The C<no 5.13.2;> form of C<no> no longer tries to turn on features or
+pragmata (i.e., strict) [perl #70075] (5.12.2).
+
+=item *
+
+C<BEGIN {require 5.12.0}> now behaves as documented, rather than behaving
+identically to C<use 5.12.0;>. Previously, C<require> in a C<BEGIN> block
+was erroneously executing the C<use feature ':5.12.0'> and
+C<use strict;> behaviour, which only C<use> was documented to
+provide [perl #69050].
+
+=item *
+
+A regression introduced in Perl 5.12.0, making
+C<< my $x = 3; $x = length(undef) >> result in C<$x> set to C<3> has been
+fixed. C<$x> will now be C<undef> [perl #85508] (5.12.2).
+
+=item *
+
+When strict 'refs' mode is off, C<%{...}> in rvalue context returns
+C<undef> if its argument is undefined. An optimisation introduced in perl
+5.12.0 to make C<keys %{...}> faster when used as a boolean did not take
+this into account, causing C<keys %{+undef}> (and C<keys %$foo> when
+C<$foo> is undefined) to be an error, which it should only be in strict
+mode [perl #81750].
+
+=item *
+
+Constant-folding used to cause
+
+ $text =~ ( 1 ? /phoo/ : /bear/)
+
+to turn into
+
+ $text =~ /phoo/
+
+at compile time. Now it correctly matches against C<$_> [perl #20444].
+
+=item *
+
+Parsing Perl code (either with string C<eval> or by loading modules) from
+within a C<UNITCHECK> block no longer causes the interpreter to crash
+[perl #70614].
+
+=item *
+
+String evals no longer fail after 2 billion scopes have been
+compiled [perl #83364].
+
+=item *
+
+The parser no longer hangs when encountering certain Unicode characters,
+such as U+387 [perl #74022].
+
+=item *
+
+Several contexts no longer allow a Unicode character to begin a word
+that should never begin words, for an example an accent that must follow
+another character previously could precede all other characters.
+
+=item *
+
+Defining a constant with the same name as one of perl's special blocks
+(e.g., INIT) stopped working in 5.12.0, but has now been fixed
+[perl #78634].
+
+=item *
-=head1 NAME
+A reference to a literal value used as a hash key (C<$hash{\"foo"}>) used
+to be stringified, even if the hash was tied [perl #79178].
-[ this is a template for a new perldelta file. Any text flagged as
-XXX needs to be processed before release. ]
+=item *
-perldelta - what is new for perl v5.13.11
+A closure containing an C<if> statement followed by a constant or variable
+is no longer treated as a constant [perl #63540].
-=head1 DESCRIPTION
+=item *
-This document describes differences between the 5.13.10 release and
-the 5.13.11 release.
+C<state> can now be used with attributes. It used to mean the same thing as
+C<my> if attributes were present [perl #68658].
-If you are upgrading from an earlier release such as 5.13.9, first read
-L<perl5139delta>, which describes differences between 5.13.9 and
-5.13.10.
+=item *
-=head1 Notice
+Expressions like C<< @$a > 3 >> no longer cause C<$a> to be mentioned in
+the "Use of uninitialized value in numeric gt" warning when C<$a> is
+undefined (since it is not part of the C<E<gt>> expression, but the operand
+of the C<@>) [perl #72090].
-XXX Any important notices here
+=item *
-=head1 Core Enhancements
+Accessing an element of a package array with a hard-coded number (as
+opposed to an arbitrary expression) would crash if the array did not exist.
+Usually the array would be autovivified during compilation, but typeglob
+manipulation could remove it, as in these two cases which used to crash:
-XXX New core language features go here. Summarise user-visible core language
-enhancements. Particularly prominent performance optimisations could go
-here, but most should go in the L</Performance Enhancements> section.
+ *d = *a; print $d[0];
+ undef *d; print $d[0];
-[ List each enhancement as a =head2 entry ]
+=item *
-=head1 Security
+The C<-C> command line option, when used on the shebang line, can now be
+followed by other options [perl #72434].
-XXX Any security-related notices go here. In particular, any security
-vulnerabilities closed should be noted here rather than in the
-L</Selected Bug Fixes> section.
+=item *
-[ List each security issue as a =head2 entry ]
+The C<B> module was returning C<B::OP>s instead of C<B::LOGOP>s for C<entertry> [perl #80622].
+This was due to a bug in the perl core, not in C<B> itself.
-=head2 User-defined regular expression properties
+=back
-Perl no longer allows a tainted regular expression to invoke a user-defined
-property via C<\p{...}> syntax. It simply dies instead [perl #82616].
+=head2 Stashes, Globs and Method Lookup
-=head1 Incompatible Changes
+Perl 5.10.0 introduced a new internal mechanism for caching MROs (method
+resolution orders, or lists of parent classes; aka "isa" caches) to make
+method lookup faster (so @ISA arrays would not have to be searched
+repeatedly). Unfortunately, this brought with it quite a few bugs. Almost
+all of these have been fixed now, along with a few MRO-related bugs that
+existed before 5.10.0:
-XXX For a release on a stable branch, this section aspires to be:
+=over
- There are no changes intentionally incompatible with 5.XXX.XXX. If any
- exist, they are bugs and reports are welcome.
+=item *
-[ List each incompatible change as a =head2 entry ]
+The following used to have erratic effects on method resolution, because
+the "isa" caches were not reset or otherwise ended up listing the wrong
+classes. These have been fixed.
-=head2 Passing references to warn()
+=over
-An earlier Perl 5.13.x release changed C<warn($ref)> to leave the reference
-unchanged, allowing C<$SIG{__WARN__}> handlers to access the original
-reference. But this stopped warnings that were references from having the
-file and line number appended even when there was no C<$SIG{__WARN__}>
-handler in place.
+=item Aliasing packages by assigning to globs [perl #77358]
-Now C<warn> checks for the presence of such a handler and, if there is
-none, proceeds to stringify the reference and append the file and line
-number. This allows simple uses of C<warn> for debugging to continue to
-work as they did before.
+=item Deleting packages by deleting their containing stash elements
-=head2 fork() emulation will not wait for signalled children
+=item Undefining the glob containing a package (C<undef *Foo::>)
-On Windows parent processes would not terminate until all forked
-childred had terminated first. However, C<kill('KILL', ...)> is
-inherently unstable on pseudo-processes, and C<kill('TERM', ...)>
-might not get delivered if the child if blocked in a system call.
+=item Undefining an ISA glob (C<undef *Foo::ISA>)
-To avoid the deadlock and still provide a safe mechanism to terminate
-the hosting process, Perl will now no longer wait for children that
-have been sent a SIGTERM signal. It is up to the parent process to
-waitpid() for these children if child clean-up processing must be
-allowed to finish. However, it is also the responsibility of the
-parent then to avoid the deadlock by making sure the child process
-can't be blocked on I/O either.
+=item Deleting an ISA stash element (C<delete $Foo::{ISA}>)
-See L<perlfork> for more information about the fork() emulation on
-Windows.
+=item Sharing @ISA arrays between classes (via C<*Foo::ISA = \@Bar::ISA> or
+C<*Foo::ISA = *Bar::ISA>) [perl #77238]
-=head2 Perl source code is read in text mode on Windows
+=back
-Perl scripts used to be read in binary mode on Windows for the benefit
-of the ByteLoader module (which is no longer part of core Perl). This
-had the side effect of breaking various operations on the DATA filehandle,
-including seek()/tell(), and even simply reading from DATA after file handles
-have been flushed by a call to system(), backticks, fork() etc.
+C<undef *Foo::ISA> would even stop a new C<@Foo::ISA> array from updating
+caches.
-The default build options for Windows have been changed to read Perl source
-code on Windows in text mode now. Hopefully ByteLoader will be updated on
-CPAN to automatically handle this situation.
+=item *
-=head1 Deprecations
+Typeglob assignments would crash if the glob's stash no longer existed, so
+long as the glob assigned to was named 'ISA' or the glob on either side of
+the assignment contained a subroutine.
-XXX Any deprecated features, syntax, modules etc. should be listed here.
-In particular, deprecated modules should be listed here even if they are
-listed as an updated module in the L</Modules and Pragmata> section.
+=item *
-[ List each deprecation as a =head2 entry ]
+C<PL_isarev>, which is accessible to Perl via C<mro::get_isarev> is now
+updated properly when packages are deleted or removed from the C<@ISA> of
+other classes. This allows many packages to be created and deleted without
+causing a memory leak [perl #75176].
-=head1 Performance Enhancements
+=back
-XXX Changes which enhance performance without changing behaviour go here. There
-may well be none in a stable release.
+In addition, various other bugs related to typeglobs and stashes have been
+fixed:
-[ List each enhancement as a =item entry ]
+=over
-=over 4
+=item *
+
+Some work has been done on the internal pointers that link between symbol
+tables (stashes), typeglobs and subroutines. This has the effect that
+various edge cases related to deleting stashes or stash entries (e.g.
+<%FOO:: = ()>), and complex typeglob or code reference aliasing, will no
+longer crash the interpreter.
=item *
-An earlier optimisation to speed up C<my @array = ...> and
-C<my %hash = ...> assignments caused a bug and was disabled in Perl 5.12.0.
+Assigning a reference to a glob copy now assigns to a glob slot instead of
+overwriting the glob with a scalar [perl #1804] [perl #77508].
-Now we have found another way to speed up these assignments [perl #82110].
+=item *
-=back
+A bug when replacing the glob of a loop variable within the loop has been fixed
+[perl #21469]. This
+means the following code will no longer crash:
-=head1 Modules and Pragmata
+ for $x (...) {
+ *x = *y;
+ }
-XXX All changes to installed files in F<cpan/>, F<dist/>, F<ext/> and F<lib/>
-go here. If Module::CoreList is updated, generate an initial draft of the
-following sections using F<Porting/corelist-perldelta.pl>, which prints stub
-entries to STDOUT. Results can be pasted in place of the '=head2' entries
-below. A paragraph summary for important changes should then be added by hand.
-In an ideal world, dual-life modules would have a F<Changes> file that could be
-cribbed.
+=item *
-[ Within each section, list entries as a =item entry ]
+Assigning a glob to a PVLV used to convert it to a plain string. Now it
+works correctly, and a PVLV can hold a glob. This would happen when a
+nonexistent hash or array element was passed to a subroutine:
-=head2 New Modules and Pragmata
+ sub { $_[0] = *foo }->($hash{key});
+ # $_[0] would have been the string "*main::foo"
-=over 4
+It also happened when a glob was assigned to, or returned from, an element
+of a tied array or hash [perl #36051].
+
+=item *
+
+When trying to report C<Use of uninitialized value $Foo::BAR>, crashes could
+occur if the glob holding the global variable in question had been detached
+from its original stash by, for example, C<delete $::{'Foo::'}>. This has
+been fixed by disabling the reporting of variable names in those
+cases.
=item *
-XXX
+During the restoration of a localised typeglob on scope exit, any
+destructors called as a result would be able to see the typeglob in an
+inconsistent state, containing freed entries, which could result in a
+crash. This would affect code like this:
+
+ local *@;
+ eval { die bless [] }; # puts an object in $@
+ sub DESTROY {
+ local $@; # boom
+ }
+
+Now the glob entries are cleared before any destructors are called. This
+also means that destructors can vivify entries in the glob. So perl tries
+again and, if the entries are re-created too many times, dies with a
+'panic: gp_free...' error message.
=back
-=head2 Updated Modules and Pragmata
+=head2 Unicode
-=over 4
+=over
=item *
-C<base> has been upgraded from version 2.15 to 2.16.
+What has become known as the "Unicode Bug" is mostly resolved in this release.
+Under C<use feature 'unicode_strings'>, the internal storage format of a
+string no longer affects the external semantics. There are two known
+exceptions. User-defined case changing functions, which are planned to
+be deprecated in 5.14, require utf8-encoded strings to function; and the
+character C<LATIN SMALL LETTER SHARP S> in regular expression
+case-insensitive matching has a somewhat different set of bugs depending
+on the internal storage format. Case-insensitive matching of all
+characters that have multi-character matches, as this one does, is
+problematical in Perl [perl #58182].
=item *
-C<CPAN> has been upgraded from version 1.94_65 to 1.9600.
+The handling of Unicode non-characters has changed.
+Previously they were mostly considered illegal, except that only one of
+the 66 of them was known about in places. The Unicode standard
+considers them legal, but forbids the "open interchange" of them.
+This is part of the change to allow the internal use of any code point
+(see L</Core Enhancements>). Together, these changes resolve
+[perl #38722], [perl #51918], [perl #51936], [perl #63446].
=item *
-C<CPANPLUS> has been upgraded from version 0.9101 to 0.9102
+Naming a deprecated character in \N{...} no longer leaks memory.
=item *
-C<CPANPLUS::Dist::Build> has been upgraded from version 0.52 to 0.54
+We fixed a bug that could cause \N{} constructs followed by a single . to
+be parsed incorrectly [perl #74978] (5.12.1).
=item *
-C<Cwd> has been downgraded from version 3.37 to 3.36.
+C<chop> now correctly handles characters above "\x{7fffffff}"
+[perl #73246].
+
+=item *
-An optimisation that recent core changes have rendered unnecessary has been
-reverted.
+Passing to C<index> an offset beyond the end of the string when the string
+is encoded internally in UTF8 no longer causes panics [perl #75898].
=item *
-C<Devel::DProf> has been upgraded from version 20110225.01 to 20110228.00.
+C<warn()> and C<die()> now respect utf8-encoded scalars [perl #45549].
=item *
-C<Digest::SHA> has been upgraded from version 5.50 to 5.61
+Sometimes the UTF8 length cache would not be reset on a value
+returned by substr, causing C<length(substr($uni_string,...))> to give
+wrong answers. With C<${^UTF8CACHE}> set to -1, it would produce a 'panic'
+error message, too [perl #77692].
+
+=back
+
+=head2 Ties, Overloading and Other Magic
-New SHA-512/224 and SHA-512/256 transforms ref. NIST Draft FIPS 180-4 (February 2011)
+=over
=item *
-C<ExtUtils::Command> has been upgraded from version 1.16 to 1.17.
+Overloading now works properly in conjunction with tied
+variables. What formerly happened was that most ops checked their
+arguments for overloading I<before> checking for magic, so for example
+an overloaded object returned by a tied array access would usually be
+treated as not overloaded [RT #57012].
=item *
-C<File::Copy> has been downgraded from version 2.22 to 2.21.
+Various cases of magic (e.g., tie methods) being called on tied variables
+too many or too few times have been fixed:
-An optimisation that recent core changes have rendered unnecessary has been
-reverted.
+=over
=item *
-C<IO> has been upgraded from version 1.25_03 to 1.25_04.
+FETCH is no longer called on tied variables in void context.
=item *
-C<JSON::PP> has been upgraded from version 2.27103 to 2.27105
+C<$tied-E<gt>()> did not always call FETCH [perl #8438].
=item *
-C<Locale::Codes> has been upgraded from version 3.15 to 3.16
+Filetest operators and C<y///> and C<tr///> were calling FETCH too
+many times.
=item *
-C<Math::BigInt> has been upgraded from version 1.992 to 1.994
+The C<=> operator used to ignore magic on its right-hand side if the
+scalar happened to hold a typeglob (if a typeglob was the last thing
+returned from or assigned to a tied scalar) [perl #77498].
=item *
-C<Math::BigInt::FastCalc> has been upgraded from version 0.24_02 to 0.28
+Dereference operators used to ignore magic if the argument was a
+reference already (e.g., from a previous FETCH) [perl #72144].
=item *
-C<Module::Build> has been upgraded from version 0.37_05 to 0.3800
+C<splice> now calls set-magic (so changes made
+by C<splice @ISA> are respected by method calls) [perl #78400].
-=item
+=item *
+
+In-memory files created by C<open $fh, 'E<gt>' \$buffer> were not calling
+FETCH/STORE at all [perl #43789] (5.12.2).
+
+=back
-C<Module::CoreList> has been upgraded from version 2.45 to 2.46.
+=item *
+
+String C<eval> now detects taintedness of overloaded or tied
+arguments [perl #75716].
=item *
-C<parent> has been upgraded from version 0.224 to 0.225
+String C<eval> and regular expression matches against objects with string
+overloading no longer cause memory corruption or crashes [perl 77084].
=item *
-C<Pod::Simple> has been upgraded from version 3.15 to 3.16
+L<readline|perlfunc/"readline EXPR"> now honors C<< <> >> overloading on tied
+arguments.
=item *
-C<Storable> has been upgraded from version 2.26 to 2.27.
+C<< E<lt>exprE<gt> >> always respects overloading now if the expression is
+overloaded.
+
+Due to the way that 'E<lt>E<gt> as glob' was parsed differently from
+'E<lt>E<gt> as filehandle' from 5.6 onwards, something like C<< E<lt>$foo[0]E<gt> >> did
+not handle overloading, even if C<$foo[0]> was an overloaded object. This
+was contrary to the documentation for overload, and meant that C<< E<lt>E<gt> >>
+could not be used as a general overloaded iterator operator.
=item *
-C<Test::Harness> has been upgraded from version 3.22 to 3.23
+The fallback behaviour of overloading on binary operators was asymmetric
+[perl #71286].
=item *
-C<Test::Simple> has been upgraded from version 0.97_01 to 0.98
+Magic applied to variables in the main package no longer affects other packages.
+See L</Magic variables outside the main package> above [perl #76138].
=item *
-C<Tie::Hash::NamedCapture> has been upgraded from version 0.07 to 0.08.
+Sometimes magic (ties, taintedness, etc.) attached to variables could cause
+an object to last longer than it should, or cause a crash if a tied
+variable were freed from within a tie method. These have been fixed
+[perl #81230].
+
+=item *
-Some of the Perl code has been converted to XS for efficency's sake.
+DESTROY methods of objects implementing ties are no longer able to crash by
+accessing the tied variable through a weak reference [perl #86328].
=item *
-C<Tie::RefHash> has been upgraded from version 1.38 to 1.39.
+Fixed a regression of kill() when a match variable is used for the
+process ID to kill [perl #75812].
=item *
-C<Unicode::Collate> has been upgraded from version 0.72 to 0.73
+C<$AUTOLOAD> used to remain tainted forever if it ever became tainted. Now
+it is correctly untainted if an autoloaded method is called and the method
+name was not tainted.
+
+=item *
-DUCET has been updated for Unicode 6.0.0 as Collate/allkeys.txt and
-the default UCA_Version is 22.
+C<sprintf> now dies when passed a tainted scalar for the format. It did
+already die for arbitrary expressions, but not for simple scalars
+[perl #82250].
=item *
-C<Unicode::UCD> has been upgraded from version 0.31 to 0.32.
-This includes a number of bug fixes:
+utf8::is_utf8 now respects get-magic (e.g. $1) (5.12.1).
-=over 4
+=back
-=item charinfo()
+=head2 The Debugger
-=over 4
+=over
=item *
-It is now updated to Unicode Version 6 with Corrigendum #8, except,
-as with Perl 5.14, the code point at U+1F514 has no name.
+The Perl debugger now also works in taint mode [perl #76872].
=item *
-The Hangul syllable code points have the correct names, and their
-decompositions are always output without requiring L<Lingua::KO::Hangul::Util>
-to be installed.
+Subroutine redefinition works once more in the debugger [perl #48332].
=item *
-The CJK (Chinese-Japanese-Korean) code points U+2A700 - U+2B734
-and U+2B740 - 2B81D are now properly handled.
+When C<-d> is used on the shebang (C<#!>) line, the debugger now has access
+to the lines of the main program. In the past, this sometimes worked and
+sometimes did not, depending on what order things happened to be arranged
+in memory [perl #71806].
=item *
-The numeric values are now output for those CJK code points that have them.
+A possible memory leak when using L<caller()|perlfunc/"caller EXPR"> to set
+C<@DB::args> has been fixed (5.12.2).
=item *
-The names that are output for code points with multiple aliases are now the
-corrected ones.
+Perl no longer stomps on $DB::single, $DB::trace and $DB::signal if they
+already have values when $^P is assigned to [perl #72422].
+
+=item *
+
+C<#line> directives in string evals were not properly updating the arrays
+of lines of code (C<< @{"_<..."} >>) that the debugger (or any debugging or
+profiling module) uses. In threaded builds, they were not being updated at
+all. In non-threaded builds, the line number was ignored, so any change to
+the existing line number would cause the lines to be misnumbered
+[perl #79442].
=back
-=item charscript()
+=head2 Threads
-This now correctly returns "Unknown" instead of C<undef> for the script
-of a code point that hasn't been assigned another one.
+=over
-=item charblock()
+=item *
-This now correctly returns "No_Block" instead of C<undef> for the block
-of a code point that hasn't been assigned to another one.
+Perl no longer accidentally clones lexicals in scope within active stack
+frames in the parent when creating a child thread [perl #73086].
-=back
+=item *
-=back
+Several memory leaks in cloning and freeing threaded Perl interpreters have been
+fixed [perl #77352].
-=head2 Removed Modules and Pragmata
+=item *
-=over 4
+Creating a new thread when directory handles were open used to cause a
+crash, because the handles were not cloned, but simply passed to the new
+thread, resulting in a double free.
+
+Now directory handles are cloned properly, on systems that have a C<fchdir>
+function. On other systems, new threads simply do not inherit directory
+handles from their parent threads [perl #75154].
=item *
-XXX
+The typeglob C<*,>, which holds the scalar variable C<$,> (output field
+separator), had the wrong reference count in child threads.
-=back
+=item *
-=head1 Documentation
+[perl #78494] When pipes are shared between threads, the C<close> function
+(and any implicit close, such as on thread exit) no longer blocks.
-XXX Changes to files in F<pod/> go here. Consider grouping entries by
-file and be sure to link to the appropriate page, e.g. L<perlfunc>.
+=item *
-=head2 New Documentation
+Perl now does a timely cleanup of SVs that are cloned into a new thread but
+then discovered to be orphaned (i.e., their owners are I<not> cloned). This
+eliminates several "scalars leaked" warnings when joining threads.
-XXX Changes which create B<new> files in F<pod/> go here.
+=back
-=head3 L<XXX>
+=head2 Scoping and Subroutines
-XXX Description of the purpose of the new file here
+=over
-=head2 Changes to Existing Documentation
+=item *
-XXX Changes which significantly change existing files in F<pod/> go here.
-However, any changes to F<pod/perldiag.pod> should go in the L</Diagnostics>
-section.
+Lvalue subroutines are again able to return copy-on-write scalars. This
+had been broken since version 5.10.0 [perl #75656] (5.12.3).
-=head3 L<XXX>
+=item *
-=over 4
+C<require> no longer causes C<caller> to return the wrong file name for
+the scope that called C<require> and other scopes higher up that had the
+same file name [perl #68712].
=item *
-XXX Description of the change here
+C<sort> with a ($$)-prototyped comparison routine used to cause the value
+of @_ to leak out of the sort. Taking a reference to @_ within the
+sorting routine could cause a crash [perl #72334].
-=back
+=item *
-=head1 Diagnostics
+Match variables (e.g., C<$1>) no longer persist between calls to a sort
+subroutine [perl #76026].
-The following additions or changes have been made to diagnostic output,
-including warnings and fatal error messages. For the complete list of
-diagnostic messages, see L<perldiag>.
+=item *
-XXX New or changed warnings emitted by the core's C<C> code go here. Also
-include any changes in L<perldiag> that reconcile it to the C<C> code.
+Iterating with C<foreach> over an array returned by an lvalue sub now works
+[perl #23790].
-[ Within each section, list entries as a =item entry ]
+=item *
-=head2 New Diagnostics
+C<$@> is now localised during calls to C<binmode> to prevent action at a
+distance [perl #78844].
-XXX Newly added diagnostic messages go here
+=item *
-=over 4
+Calling a closure prototype (what is passed to an attribute handler for a
+closure) now results in a "Closure prototype called" error message instead
+of a crash [perl #68560].
=item *
-Regexp modifier "/%c" may not appear twice
+Mentioning a read-only lexical variable from the enclosing scope in a
+string C<eval> no longer causes the variable to become writable
+[perl #19135].
+
+=back
-(F syntax) The regular expression pattern had one of the mutually exclusive
-modifiers repeated. Remove all but one of the occurrences.
+=head2 Signals
-=item *
+=over
-Regexp modifiers "/%c" and "/%c" are mutually exclusive
+=item *
-(F syntax) The regular expression pattern had more than one of the mutually
-exclusive modifiers. Retain only the modifier that is supposed to be there.
+Within signal handlers, C<$!> is now implicitly localized.
=item *
-Insecure user-defined property %s
+CHLD signals are no longer unblocked after a signal handler is called if
+they were blocked before by C<POSIX::sigprocmask> [perl #82040].
-(F) Perl detected tainted data when trying to compile a regular
-expression that contains a call to a user-defined character property
-function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
-See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
+=item *
+
+A signal handler called within a signal handler could cause leaks or
+double-frees. Now fixed. [perl #76248].
=back
-=head2 Changes to Existing Diagnostics
+=head2 Miscellaneous Memory Leaks
-XXX Changes (i.e. rewording) of diagnostic messages go here
+=over
-=over 4
+=item *
+
+Several memory leaks when loading XS modules were fixed (5.12.2).
=item *
-XXX
+L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT">,
+L<pos()|perlfunc/"index STR,SUBSTR,POSITION">, L<keys()|perlfunc/"keys HASH">,
+and L<vec()|perlfunc/"vec EXPR,OFFSET,BITS"> could, when used in combination
+with lvalues, result in leaking the scalar value they operate on, and cause its
+destruction to happen too late. This has now been fixed.
-=back
+=item *
-=head1 Utility Changes
+The postincrement and postdecrement operators, C<++> and C<-->, used to cause
+leaks when being used on references. This has now been fixed.
-XXX Changes to installed programs such as F<perlbug> and F<xsubpp> go
-here. Most of these are built within the directories F<utils> and F<x2p>.
+=item *
-[ List utility changes as a =head3 entry for each utility and =item
-entries for each change
-Use L<XXX> with program names to get proper documentation linking. ]
+Nested C<map> and C<grep> blocks no longer leak memory when processing
+large lists [perl #48004].
-=head3 L<XXX>
+=item *
-=over 4
+C<use I<VERSION>> and C<no I<VERSION>> no longer leak memory [perl #78436]
+[perl #69050].
=item *
-XXX
+C<.=> followed by C<< <> >> or C<readline> would leak memory if C<$/>
+contained characters beyond the octet range and the scalar assigned to
+happened to be encoded as UTF8 internally [perl #72246].
-=back
+=item *
-=head1 Configuration and Compilation
+C<eval "BEGIN{die}"> no longer leaks memory on non-threaded builds.
-XXX Changes to F<Configure>, F<installperl>, F<installman>, and analogous tools
-go here. Any other changes to the Perl build process should be listed here.
-However, any platform-specific changes should be listed in the
-L</Platform Support> section, instead.
+=back
-[ List changes as a =item entry ].
+=head2 Memory Corruption and Crashes
-=over 4
+=over
=item *
-XXX
+glob() no longer crashes when %File::Glob:: is empty and
+CORE::GLOBAL::glob isn't present [perl #75464] (5.12.2).
-=back
+=item *
+
+readline() has been fixed when interrupted by signals so it no longer
+returns the "same thing" as before or random memory.
-=head1 Testing
+=item *
-XXX Any significant changes to the testing of a freshly built perl should be
-listed here. Changes which create B<new> files in F<t/> go here as do any
-large changes to the testing harness (e.g. when parallel testing was added).
-Changes to existing files in F<t/> aren't worth summarising, although the bugs
-that they represent may be covered elsewhere.
+When assigning a list with duplicated keys to a hash, the assignment used to
+return garbage and/or freed values:
-Many of the tests have been refactored to use testing libraries more
-consistently. In some cases test files were created or deleted:
+ @a = %h = (list with some duplicate keys);
-=over 4
+This has now been fixed [perl #31865].
=item *
-The tests for C<split /\s/> and Unicode have been moved from
-F<t/op/split.t> to the new F<t/op/split_unicode.t>.
+The mechanism for freeing objects in globs used to leave dangling
+pointers to freed SVs, meaning Perl users could see corrupted state
+during destruction.
+
+Perl now only frees the affected slots of the GV, rather than freeing
+the GV itself. This makes sure that there are no dangling refs or
+corrupted state during destruction.
=item *
-F<t/re/re.t> has been moved to F<ext/re/t/re_funcs_u.t>.
+The interpreter no longer crashes when freeing deeply-nested arrays of
+arrays. Hashes have not been fixed yet [perl #44225].
=item *
-The tests for [perl #72922] have been moved from F<t/re/qr.t> to the new
-F<t/re/qr-72922.t>.
+Concatenating long strings under C<use encoding> no longer causes perl to
+crash [perl #78674].
=item *
-F<t/re/reg_unsafe.t> has been deleted and its only test moved to
-F<t/re/pat_advanced.t>.
+Calling C<< ->import >> on a class lacking an import method could corrupt
+the stack, resulting in strange behaviour. For instance,
-=back
+ push @a, "foo", $b = bar->import;
-=head1 Platform Support
+would assign 'foo' to C<$b> [perl #63790].
-XXX Any changes to platform support should be listed in the sections below.
+=item *
-[ Within the sections, list each platform as a =item entry with specific
-changes as paragraphs below it. ]
+The C<recv> function could crash when called with the MSG_TRUNC flag
+[perl #75082].
-=head2 New Platforms
+=item *
-XXX List any platforms that this version of perl compiles on, that previous
-versions did not. These will either be enabled by new files in the F<hints/>
-directories, or new subdirectories and F<README> files at the top level of the
-source tree.
+C<formline> no longer crashes when passed a tainted format picture. It also
+taints C<$^A> now if its arguments are tainted [perl #79138].
-=over 4
+=item *
-=item XXX-some-platform
+A bug in how we process filetest operations could cause a segfault.
+Filetests don't always expect an op on the stack, so we now use
+TOPs only if we're sure that we're not stat'ing the _ filehandle.
+This is indicated by OPf_KIDS (as checked in ck_ftst) [perl #74542]
+(5.12.1).
-XXX
+=item *
+
+C<unpack()> now handles scalar context correctly for C<%32H> and C<%32u>,
+fixing a potential crash. C<split()> would crash because the third item
+on the stack wasn't the regular expression it expected. C<unpack("%2H",
+...)> would return both the unpacked result and the checksum on the stack,
+as would C<unpack("%2u", ...)> [perl #73814] (5.12.2).
=back
-=head2 Discontinued Platforms
+=head2 Fixes to Various Perl Operators
-XXX List any platforms that this version of perl no longer compiles on.
+=over
-=over 4
+=item *
-=item XXX-some-platform
+The C<&> C<|> C<^> bitwise operators no longer coerce read-only arguments
+[perl #20661].
-XXX
+=item *
-=back
+Stringifying a scalar containing -0.0 no longer has the affect of turning
+false into true [perl #45133].
-=head2 Platform-Specific Notes
+=item *
-XXX List any changes for specific platforms. This could include configuration
-and compilation changes or changes in portability/compatibility. However,
-changes within modules for platforms should generally be listed in the
-L</Modules and Pragmata> section.
+Some numeric operators were converting integers to floating point,
+resulting in loss of precision on 64-bit platforms [perl #77456].
-=over 4
+=item *
+
+C<sprintf> was ignoring locales when called with constant arguments
+[perl #78632].
-=item XXX-some-platform
+=item *
-XXX
+Combining the vector (%v) flag and dynamic precision would
+cause sprintf to confuse the order of its arguments, making it treat the
+string as the precision and vice versa [perl #83194].
=back
-=head1 Internal Changes
+=head2 Bugs Relating to the C API
-XXX Changes which affect the interface available to C<XS> code go here.
-Other significant internal changes for future core maintainers should
-be noted as well.
+=over
-[ List each test improvement as a =item entry ]
+=item *
-=over 4
+The C-level C<lex_stuff_pvn> function would sometimes cause a spurious
+syntax error on the last line of the file if it lacked a final semicolon
+[perl #74006] (5.12.1).
=item *
-XXX
+The C<eval_sv> and C<eval_pv> C functions now set C<$@> correctly when
+there is a syntax error and no C<G_KEEPERR> flag, and never set it if the
+C<G_KEEPERR> flag is present [perl #3719].
-=back
+=item *
-=head1 Selected Bug Fixes
+The XS multicall API no longer causes subroutines to lose reference counts
+if called via the multicall interface from within those very subroutines.
+This affects modules like List::Util. Calling one of its functions with an
+active subroutine as the first argument could cause a crash [perl #78070].
-XXX Important bug fixes in the core language are summarised here.
-Bug fixes in files in F<ext/> and F<lib/> are best summarised in
-L</Modules and Pragmata>.
+=item *
-=over 4
+The C<SvPVbyte> function available to XS modules now calls magic before
+downgrading the SV, to avoid warnings about wide characters [perl #72398].
=item *
-A fix for a bug in C<length(undef)> in 5.13.4 introduced a regression that
-meant C<print length undef> did not warn when warnings were enabled. It now
-correctly warns [perl #85508].
+The ref types in the typemap for XS bindings now support magical variables
+[perl #72684].
=item *
-The C<(?|...)> regular expression construct no longer crashes if the final
-branch has more sets of capturing parentheses than any other branch. This
-was fixed in Perl 5.10.1 for the case of a single branch, but that fix did
-not take multiple branches into account [perl #84746].
+C<sv_catsv_flags> no longer calls C<mg_get> on its second argument (the
+source string) if the flags passed to it do not include SV_GMAGIC. So it
+now matches the documentation.
=item *
-Accessing an element of a package array with a hard-coded number (as
-opposed to an arbitrary expression) would crash if the array did not exist.
-Usually the array would be autovivified during compilation, but typeglob
-manipulation could remove it, as in these two cases which used to crash:
+C<my_strftime> no longer leaks memory. This fixes a memory leak in
+C<POSIX::strftime> [perl #73520].
- *d = *a; print $d[0];
- undef *d; print $d[0];
+=item *
+
+XSUB.h now correctly redefines fgets under PERL_IMPLICIT_SYS [perl #55049]
+(5.12.1).
=item *
-C<#line> directives in string evals were not properly updating the arrays
-of lines of code (C<< @{"_<..."} >>) that the debugger (or any debugging or
-profiling module) uses. In threaded builds, they were not being updated at
-all. In non-threaded builds, the line number was ignored, so any change to
-the existing line number would cause the lines to be misnumbered
-[perl #79442].
+XS code using C<fputc()> or C<fputs()>: on Windows could cause an error
+due to their arguments being swapped [perl #72704] (5.12.1).
=item *
-C<$AUTOLOAD> used to remain tainted forever if it ever became tainted. Now
-it is correctly untainted if an autoloaded method is called and the method
-name was not tainted.
+A possible segfault in the C<T_PRTOBJ> default typemap has been fixed
+(5.12.2).
=item *
-A bug has been fixed in the implementation of C<{...}> quantifiers in
-regular expressions that prevented the code block in
-C</((\w+)(?{ print $2 })){2}/> from seeing the C<$2> sometimes
-[perl #84294].
+A bug that could cause "Unknown error" messages when
+C<call_sv(code, G_EVAL)> is called from an XS destructor has been fixed
+(5.12.2).
+
+=back
+
+=head1 Known Problems
+
+XXX Many of these have probably already been solved. There are also
+unresolved BBC articles linked to #77718 that are awaiting CPAN
+releases. These may need to be listed here.
+See also #84444. Enbugger may also need to be listed if there is no new
+release in time (see #82152).
+JJORE/overload-eval-0.08.tar.gz appears to be broken, too. See
+http://www.nntp.perl.org/group/perl.perl5.porters/2010/11/msg165773.html
+
+=over 4
=item *
-C<sprintf> now dies when passed a tainted scalar for the format. It did
-already die for arbitrary expressions, but not for simple scalars
-[perl #82250].
+C<List::Util::first> misbehaves in the presence of a lexical C<$_>
+(typically introduced by C<my $_> or implicitly by C<given>). The variable
+which gets set for each iteration is the package variable C<$_>, not the
+lexical C<$_>.
+
+A similar issue may occur in other modules that provide functions which
+take a block as their first argument, like
+
+ foo { ... $_ ...} list
+
+See also: L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=67694>
=item *
-DESTROY methods of objects implementing ties are no longer able to crash by
-accessing the tied variable through a weak reference [perl #86328].
+readline() returns an empty string instead of undef when it is
+interrupted by a signal
=item *
-On Windows, calling kill(9, $child) on a pseudo-process created by the fork()
-emulation is inherently unstable. It can also be responsible for overriding
-the parent process exit code with a value of '9' if the parent terminates
-right after killing the child. This condition will now happen a lot less
-often than before.
+Test-Harness was updated from 3.17 to 3.21 for this release. A rewrite
+in how it handles non-Perl tests (in 3.17_01) broke argument passing to
+non-Perl tests with L<prove> (RT #59186), and required that non-Perl
+tests be run as C<prove ./test.sh> instead of C<prove test.sh> These
+issues are being solved upstream, but didn't make it into this release.
+They're expected to be fixed in time for perl v5.13.4. (RT #59457)
-See also L</"fork() emulation will not wait for signalled children"> for a
-better way to terminate child processes that avoids deadlocks altogether.
+=item *
-=back
+C<version> now prevents object methods from being called as class methods
+(d808b68)
-=head1 Known Problems
+=item *
-XXX Descriptions of platform agnostic bugs we know we can't fix go here. Any
-tests that had to be C<TODO>ed for the release would be noted here, unless
-they were specific to a particular platform (see below).
+The changes in L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT">
+broke C<HTML::Parser> <= 3.66. A fixed C<HTML::Parser> is available as versions
+3.67 on CPAN.
-This is a list of some significant unfixed bugs, which are regressions
-from either 5.XXX.XXX or 5.XXX.XXX.
+=item *
-[ List each fix as a =item entry ]
+The changes in prototype handling break C<Switch>. A patch has been sent
+upstream and will hopefully appear on CPAN soon.
-=over 4
+=item *
+
+The upgrade to Encode-2.40 has caused some tests in the libwww-perl distribution
+on CPAN to fail. (Specifically, F<base/message-charset.t> tests 33-36 in version
+5.836 of that distribution now fail.)
=item *
-XXX
+The upgrade to ExtUtils-MakeMaker-6.57_05 has caused some tests in the
+Module-Install distribution on CPAN to fail. (Specifically, F<02_mymeta.t> tests
+5 and 21, F<18_all_from.t> tests 6 and 15, F<19_authors.t> tests 5, 13, 21 and
+29, and F<20_authors_with_special_characters.t> tests 6, 15 and 23 in version
+1.00 of that distribution now fail.)
=back
+=head1 Errata
+
+=head2 C<keys>, C<values> and C<each> work on arrays
+
+You can now use the C<keys>, C<values>, C<each> builtin functions on arrays
+(previously you could only use them on hashes). See L<perlfunc> for details.
+This is actually a change introduced in perl 5.12.0, but it was missed from
+that release's perldelta.
+
=head1 Obituary
-XXX If any significant core contributor has died, we've added a short obituary
-here.
+Randy Kobes, creator of the kobesearch alternative to search.cpan.org and
+contributor/maintainer to several core Perl toolchain modules, passed away
+on September 18, 2010 after a battle with lung cancer. His contributions
+to the Perl community will be missed.
=head1 Acknowledgements
https://perl5.git.perl.org / perl5.git / blobdiff