create perl5161delta
authorRicardo Signes <rjbs@cpan.org>
Thu, 21 Jun 2012 00:47:43 +0000 (20:47 -0400)
committerRicardo Signes <rjbs@cpan.org>
Sun, 24 Jun 2012 22:28:57 +0000 (18:28 -0400)
MANIFEST
Makefile.SH
pod/.gitignore
pod/perl.pod
pod/perl5160delta.pod [new file with mode: 0644]
pod/perldelta.pod
vms/descrip_mms.template
win32/Makefile
win32/makefile.mk
win32/pod.mak

index 877212e..9186648 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -4622,6 +4622,7 @@ pod/perl5124delta.pod             Perl changes in version 5.12.4
 pod/perl5140delta.pod          Perl changes in version 5.14.0
 pod/perl5141delta.pod          Perl changes in version 5.14.1
 pod/perl5142delta.pod          Perl changes in version 5.14.2
+pod/perl5160delta.pod          Perl changes in version 5.16.0
 pod/perl561delta.pod           Perl changes in version 5.6.1
 pod/perl56delta.pod            Perl changes in version 5.6
 pod/perl581delta.pod           Perl changes in version 5.8.1
index 2b50033..ecca810 100755 (executable)
@@ -482,7 +482,7 @@ mini_obj = $(minindt_obj) $(MINIDTRACE_O)
 ndt_obj = $(obj0) $(obj1) $(obj2) $(obj3) $(ARCHOBJS)
 obj = $(ndt_obj) $(DTRACE_O)
 
-perltoc_pod_prereqs = extra.pods pod/perl5160delta.pod pod/perlapi.pod pod/perlintern.pod pod/perlmodlib.pod pod/perluniprops.pod
+perltoc_pod_prereqs = extra.pods pod/perl5161delta.pod pod/perlapi.pod pod/perlintern.pod pod/perlmodlib.pod pod/perluniprops.pod
 generated_pods = pod/perltoc.pod $(perltoc_pod_prereqs)
 generated_headers = uudmap.h bitcount.h mg_data.h
 
@@ -1058,8 +1058,8 @@ pod/perlintern.pod: $(MINIPERL_EXE) autodoc.pl embed.fnc
 pod/perlmodlib.pod: $(MINIPERL_EXE) pod/perlmodlib.PL MANIFEST
        $(MINIPERL) $(Icwd) pod/perlmodlib.PL -q
 
-pod/perl5160delta.pod: pod/perldelta.pod
-       $(LNS) perldelta.pod pod/perl5160delta.pod
+pod/perl5161delta.pod: pod/perldelta.pod
+       $(LNS) perldelta.pod pod/perl5161delta.pod
 
 extra.pods: $(MINIPERL_EXE)
        -@test ! -f extra.pods || rm -f `cat extra.pods`
index ed94f1e..cbc71eb 100644 (file)
@@ -59,7 +59,7 @@
 /roffitall
 
 # generated
-/perl5160delta.pod
+/perl5161delta.pod
 /perlapi.pod
 /perlintern.pod
 *.html
index ce39999..e7052b7 100644 (file)
@@ -178,6 +178,7 @@ aux a2p c2ph h2ph h2xs perlbug pl2pm pod2html pod2man s2p splain xsubpp
     perlhist           Perl history records
     perldelta          Perl changes since previous version
     perl5160delta      Perl changes in version 5.16.0
+    perl5160delta      Perl changes in version 5.16.0
     perl5142delta      Perl changes in version 5.14.2
     perl5141delta      Perl changes in version 5.14.1
     perl5140delta      Perl changes in version 5.14.0
diff --git a/pod/perl5160delta.pod b/pod/perl5160delta.pod
new file mode 100644 (file)
index 0000000..9b67d17
--- /dev/null
@@ -0,0 +1,4314 @@
+=encoding utf8
+
+=head1 NAME
+
+perl5160delta - what is new for perl v5.16.0
+
+=head1 DESCRIPTION
+
+This document describes differences between the 5.14.0 release and
+the 5.16.0 release.
+
+If you are upgrading from an earlier release such as 5.12.0, first read
+L<perl5140delta>, which describes differences between 5.12.0 and
+5.14.0.
+
+Some bug fixes in this release have been backported to later
+releases of 5.14.x.  Those are indicated with the 5.14.x version in
+parentheses.
+
+=head1 Notice
+
+With the release of Perl 5.16.0, the 5.12.x series of releases is now out of
+its support period.  There may be future 5.12.x releases, but only in the
+event of a critical security issue.  Users of Perl 5.12 or earlier should
+consider upgrading to a more recent release of Perl.
+
+This policy is described in greater detail in
+L<perlpolicy|perlpolicy/MAINTENANCE AND SUPPORT>.
+
+=head1 Core Enhancements
+
+=head2 C<use I<VERSION>>
+
+As of this release, version declarations like C<use v5.16> now disable
+all features before enabling the new feature bundle.  This means that
+the following holds true:
+
+    use 5.016;
+    # only 5.16 features enabled here
+    use 5.014;
+    # only 5.14 features enabled here (not 5.16)
+
+C<use v5.12> and higher continue to enable strict, but explicit C<use
+strict> and C<no strict> now override the version declaration, even
+when they come first:
+
+    no strict;
+    use 5.012;
+    # no strict here
+
+There is a new ":default" feature bundle that represents the set of
+features enabled before any version declaration or C<use feature> has
+been seen.  Version declarations below 5.10 now enable the ":default"
+feature set.  This does not actually change the behavior of C<use
+v5.8>, because features added to the ":default" set are those that were
+traditionally enabled by default, before they could be turned off.
+
+C<< no feature >> now resets to the default feature set.  To disable all
+features (which is likely to be a pretty special-purpose request, since
+it presumably won't match any named set of semantics) you can now  
+write C<< no feature ':all' >>.
+
+C<$[> is now disabled under C<use v5.16>.  It is part of the default
+feature set and can be turned on or off explicitly with C<use feature
+'array_base'>.
+
+=head2 C<__SUB__>
+
+The new C<__SUB__> token, available under the C<current_sub> feature
+(see L<feature>) or C<use v5.16>, returns a reference to the current
+subroutine, making it easier to write recursive closures.
+
+=head2 New and Improved Built-ins
+
+=head3 More consistent C<eval>
+
+The C<eval> operator sometimes treats a string argument as a sequence of
+characters and sometimes as a sequence of bytes, depending on the
+internal encoding.  The internal encoding is not supposed to make any
+difference, but there is code that relies on this inconsistency.
+
+The new C<unicode_eval> and C<evalbytes> features (enabled under C<use
+5.16.0>) resolve this.  The C<unicode_eval> feature causes C<eval
+$string> to treat the string always as Unicode.  The C<evalbytes>
+features provides a function, itself called C<evalbytes>, which
+evaluates its argument always as a string of bytes.
+
+These features also fix oddities with source filters leaking to outer
+dynamic scopes.
+
+See L<feature> for more detail.
+
+=head3 C<substr> lvalue revamp
+
+=for comment Does this belong here, or under Incompatible Changes?
+
+When C<substr> is called in lvalue or potential lvalue context with two
+or three arguments, a special lvalue scalar is returned that modifies
+the original string (the first argument) when assigned to.
+
+Previously, the offsets (the second and third arguments) passed to
+C<substr> would be converted immediately to match the string, negative
+offsets being translated to positive and offsets beyond the end of the
+string being truncated.
+
+Now, the offsets are recorded without modification in the special
+lvalue scalar that is returned, and the original string is not even
+looked at by C<substr> itself, but only when the returned lvalue is
+read or modified.
+
+These changes result in an incompatible change:
+
+If the original string changes length after the call to C<substr> but
+before assignment to its return value, negative offsets will remember
+their position from the end of the string, affecting code like this:
+
+    my $string = "string";
+    my $lvalue = \substr $string, -4, 2;
+    print $$lvalue, "\n"; # prints "ri"
+    $string = "bailing twine";
+    print $$lvalue, "\n"; # prints "wi"; used to print "il"
+
+The same thing happens with an omitted third argument.  The returned
+lvalue will always extend to the end of the string, even if the string
+becomes longer.
+
+Since this change also allowed many bugs to be fixed (see
+L</The C<substr> operator>), and since the behavior
+of negative offsets has never been specified, the
+change was deemed acceptable.
+
+=head3 Return value of C<tied>
+
+The value returned by C<tied> on a tied variable is now the actual
+scalar that holds the object to which the variable is tied.  This
+lets ties be weakened with C<Scalar::Util::weaken(tied
+$tied_variable)>.
+
+=head2 Unicode Support
+
+=head3 Supports (I<almost>) Unicode 6.1
+
+Besides the addition of whole new scripts, and new characters in
+existing scripts, this new version of Unicode, as always, makes some
+changes to existing characters.  One change that may trip up some
+applications is that the General Category of two characters in the
+Latin-1 range, PILCROW SIGN and SECTION SIGN, has been changed from
+Other_Symbol to Other_Punctuation.  The same change has been made for
+a character in each of Tibetan, Ethiopic, and Aegean.
+The code points U+3248..U+324F (CIRCLED NUMBER TEN ON BLACK SQUARE
+through CIRCLED NUMBER EIGHTY ON BLACK SQUARE) have had their General
+Category changed from Other_Symbol to Other_Numeric.  The Line Break
+property has changes for Hebrew and Japanese; and because of
+other changes in 6.1, the Perl regular expression construct C<\X> now
+works differently for some characters in Thai and Lao.
+
+New aliases (synonyms) have been defined for many property values;
+these, along with the previously existing ones, are all cross-indexed in
+L<perluniprops>.
+
+The return value of C<charnames::viacode()> is affected by other
+changes:
+
+ Code point      Old Name             New Name
+   U+000A    LINE FEED (LF)        LINE FEED
+   U+000C    FORM FEED (FF)        FORM FEED
+   U+000D    CARRIAGE RETURN (CR)  CARRIAGE RETURN
+   U+0085    NEXT LINE (NEL)       NEXT LINE
+   U+008E    SINGLE-SHIFT 2        SINGLE-SHIFT-2
+   U+008F    SINGLE-SHIFT 3        SINGLE-SHIFT-3
+   U+0091    PRIVATE USE 1         PRIVATE USE-1
+   U+0092    PRIVATE USE 2         PRIVATE USE-2
+   U+2118    SCRIPT CAPITAL P      WEIERSTRASS ELLIPTIC FUNCTION
+
+Perl will accept any of these names as input, but
+C<charnames::viacode()> now returns the new name of each pair.  The
+change for U+2118 is considered by Unicode to be a correction, that is
+the original name was a mistake (but again, it will remain forever valid
+to use it to refer to U+2118).  But most of these changes are the
+fallout of the mistake Unicode 6.0 made in naming a character used in
+Japanese cell phones to be "BELL", which conflicts with the longstanding
+industry use of (and Unicode's recommendation to use) that name
+to mean the ASCII control character at U+0007.  Therefore, that name
+has been deprecated in Perl since v5.14, and any use of it will raise a
+warning message (unless turned off).  The name "ALERT" is now the
+preferred name for this code point, with "BEL" an acceptable short
+form.  The name for the new cell phone character, at code point U+1F514,
+remains undefined in this version of Perl (hence we don't 
+implement quite all of Unicode 6.1), but starting in v5.18, BELL will mean
+this character, and not U+0007.
+
+Unicode has taken steps to make sure that this sort of mistake does not
+happen again.  The Standard now includes all generally accepted
+names and abbreviations for control characters, whereas previously it
+didn't (though there were recommended names for most of them, which Perl
+used).  This means that most of those recommended names are now
+officially in the Standard.  Unicode did not recommend names for the
+four code points listed above between U+008E and U+008F, and in
+standardizing them Unicode subtly changed the names that Perl had
+previously given them, by replacing the final blank in each name by a
+hyphen.  Unicode also officially accepts names that Perl had deprecated,
+such as FILE SEPARATOR.  Now the only deprecated name is BELL.
+Finally, Perl now uses the new official names instead of the old
+(now considered obsolete) names for the first four code points in the
+list above (the ones which have the parentheses in them).
+
+Now that the names have been placed in the Unicode standard, these kinds
+of changes should not happen again, though corrections, such as to
+U+2118, are still possible.
+
+Unicode also added some name abbreviations, which Perl now accepts:
+SP for SPACE;
+TAB for CHARACTER TABULATION;
+NEW LINE, END OF LINE, NL, and EOL for LINE FEED;
+LOCKING-SHIFT ONE for SHIFT OUT;
+LOCKING-SHIFT ZERO for SHIFT IN;
+and ZWNBSP for ZERO WIDTH NO-BREAK SPACE.
+
+More details on this version of Unicode are provided in
+L<http://www.unicode.org/versions/Unicode6.1.0/>.
+
+=head3 C<use charnames> is no longer needed for C<\N{I<name>}>
+
+When C<\N{I<name>}> is encountered, the C<charnames> module is now
+automatically loaded when needed as if the C<:full> and C<:short>
+options had been specified.  See L<charnames> for more information.
+
+=head3 C<\N{...}> can now have Unicode loose name matching
+
+This is described in the C<charnames> item in
+L</Updated Modules and Pragmata> below.
+
+=head3 Unicode Symbol Names
+
+Perl now has proper support for Unicode in symbol names.  It used to be
+that C<*{$foo}> would ignore the internal UTF8 flag and use the bytes of
+the underlying representation to look up the symbol.  That meant that
+C<*{"\x{100}"}> and C<*{"\xc4\x80"}> would return the same thing.  All
+these parts of Perl have been fixed to account for Unicode:
+
+=over
+
+=item *
+
+Method names (including those passed to C<use overload>)
+
+=item *
+
+Typeglob names (including names of variables, subroutines, and filehandles)
+
+=item *
+
+Package names
+
+=item *
+
+C<goto>
+
+=item *
+
+Symbolic dereferencing
+
+=item *
+
+Second argument to C<bless()> and C<tie()>
+
+=item *
+
+Return value of C<ref()>
+
+=item *
+
+Subroutine prototypes
+
+=item *
+
+Attributes
+
+=item *
+
+Various warnings and error messages that mention variable names or values,
+methods, etc.
+
+=back
+
+In addition, a parsing bug has been fixed that prevented C<*{é}> from
+implicitly quoting the name, but instead interpreted it as C<*{+é}>, which
+would cause a strict violation.
+
+C<*{"*a::b"}> automatically strips off the * if it is followed by an ASCII
+letter.  That has been extended to all Unicode identifier characters.
+
+One-character non-ASCII non-punctuation variables (like C<$é>) are now
+subject to "Used only once" warnings.  They used to be exempt, as they
+were treated as punctuation variables.
+
+Also, single-character Unicode punctuation variables (like C<$‰>) are now
+supported [perl #69032].
+
+=head3 Improved ability to mix locales and Unicode, including UTF-8 locales
+
+An optional parameter has been added to C<use locale>
+
+ use locale ':not_characters';
+
+which tells Perl to use all but the C<LC_CTYPE> and C<LC_COLLATE>
+portions of the current locale.  Instead, the character set is assumed
+to be Unicode.  This lets locales and Unicode be seamlessly mixed,
+including the increasingly frequent UTF-8 locales.  When using this
+hybrid form of locales, the C<:locale> layer to the L<open> pragma can
+be used to interface with the file system, and there are CPAN modules
+available for ARGV and environment variable conversions.
+
+Full details are in L<perllocale>.
+
+=head3 New function C<fc> and corresponding escape sequence C<\F> for Unicode foldcase
+
+Unicode foldcase is an extension to lowercase that gives better results
+when comparing two strings case-insensitively.  It has long been used
+internally in regular expression C</i> matching.  Now it is available
+explicitly through the new C<fc> function call (enabled by
+S<C<"use feature 'fc'">>, or C<use v5.16>, or explicitly callable via
+C<CORE::fc>) or through the new C<\F> sequence in double-quotish
+strings.
+
+Full details are in L<perlfunc/fc>.
+
+=head3 The Unicode C<Script_Extensions> property is now supported.
+
+New in Unicode 6.0, this is an improved C<Script> property.  Details
+are in L<perlunicode/Scripts>.
+
+=head2 XS Changes
+
+=head3 Improved typemaps for Some Builtin Types
+
+Most XS authors will know there is a longstanding bug in the
+OUTPUT typemap for T_AVREF (C<AV*>), T_HVREF (C<HV*>), T_CVREF (C<CV*>),
+and T_SVREF (C<SVREF> or C<\$foo>) that requires manually decrementing
+the reference count of the return value instead of the typemap taking
+care of this.  For backwards-compatibility, this cannot be changed in the
+default typemaps.  But we now provide additional typemaps
+C<T_AVREF_REFCOUNT_FIXED>, etc. that do not exhibit this bug.  Using
+them in your extension is as simple as having one line in your
+C<TYPEMAP> section:
+
+  HV*  T_HVREF_REFCOUNT_FIXED
+
+=head3 C<is_utf8_char()>
+
+The XS-callable function C<is_utf8_char()>, when presented with
+malformed UTF-8 input, can read up to 12 bytes beyond the end of the
+string.  This cannot be fixed without changing its API, and so its
+use is now deprecated.  Use C<is_utf8_char_buf()> (described just below)
+instead.
+
+=head3 Added C<is_utf8_char_buf()>
+
+This function is designed to replace the deprecated L</is_utf8_char()>
+function.  It includes an extra parameter to make sure it doesn't read
+past the end of the input buffer.
+
+=head3 Other C<is_utf8_foo()> functions, as well as C<utf8_to_foo()>, etc.
+
+Most other XS-callable functions that take UTF-8 encoded input
+implicitly assume that the UTF-8 is valid (not malformed) with respect to
+buffer length.  Do not do things such as change a character's case or
+see if it is alphanumeric without first being sure that it is valid
+UTF-8.  This can be safely done for a whole string by using one of the
+functions C<is_utf8_string()>, C<is_utf8_string_loc()>, and
+C<is_utf8_string_loclen()>.
+
+=head3 New Pad API
+
+Many new functions have been added to the API for manipulating lexical
+pads.  See L<perlapi/Pad Data Structures> for more information.
+
+=head2 Changes to Special Variables
+
+=head3 C<$$> can be assigned to
+
+C<$$> was made read-only in Perl 5.8.0.  But only sometimes: C<local $$>
+would make it writable again.  Some CPAN modules were using C<local $$> or
+XS code to bypass the read-only check, so there is no reason to keep C<$$>
+read-only.  (This change also allowed a bug to be fixed while maintaining
+backward compatibility.)
+
+=head3 C<$^X> converted to an absolute path on FreeBSD, OS X and Solaris
+
+C<$^X> is now converted to an absolute path on OS X, FreeBSD (without
+needing F</proc> mounted) and Solaris 10 and 11.  This augments the
+previous approach of using F</proc> on Linux, FreeBSD, and NetBSD
+(in all cases, where mounted).
+
+This makes relocatable perl installations more useful on these platforms.
+(See "Relocatable @INC" in F<INSTALL>)
+
+=head2 Debugger Changes
+
+=head3 Features inside the debugger
+
+The current Perl's L<feature> bundle is now enabled for commands entered
+in the interactive debugger.
+
+=head3 New option for the debugger's B<t> command
+
+The B<t> command in the debugger, which toggles tracing mode, now
+accepts a numeric argument that determines how many levels of subroutine
+calls to trace.
+
+=head3 C<enable> and C<disable>
+
+The debugger now has C<disable> and C<enable> commands for disabling
+existing breakpoints and re-enabling them.  See L<perldebug>.
+
+=head3 Breakpoints with file names
+
+The debugger's "b" command for setting breakpoints now lets a line
+number be prefixed with a file name.  See
+L<perldebug/"b [file]:[line] [condition]">.
+
+=head2 The C<CORE> Namespace
+
+=head3 The C<CORE::> prefix
+
+The C<CORE::> prefix can now be used on keywords enabled by
+L<feature.pm|feature>, even outside the scope of C<use feature>.
+
+=head3 Subroutines in the C<CORE> namespace
+
+Many Perl keywords are now available as subroutines in the CORE namespace.
+This lets them be aliased:
+
+    BEGIN { *entangle = \&CORE::tie }
+    entangle $variable, $package, @args;
+
+And for prototypes to be bypassed:
+
+    sub mytie(\[%$*@]$@) {
+       my ($ref, $pack, @args) = @_;
+       ... do something ...
+       goto &CORE::tie;
+    }
+
+Some of these cannot be called through references or via C<&foo> syntax,
+but must be called as barewords.
+
+See L<CORE> for details.
+
+=head2 Other Changes
+
+=head3 Anonymous handles
+
+Automatically generated file handles are now named __ANONIO__ when the
+variable name cannot be determined, rather than $__ANONIO__.
+
+=head3 Autoloaded sort Subroutines
+
+Custom sort subroutines can now be autoloaded [perl #30661]:
+
+    sub AUTOLOAD { ... }
+    @sorted = sort foo @list; # uses AUTOLOAD
+
+=head3 C<continue> no longer requires the "switch" feature
+
+The C<continue> keyword has two meanings.  It can introduce a C<continue>
+block after a loop, or it can exit the current C<when> block.  Up to now,
+the latter meaning was valid only with the "switch" feature enabled, and
+was a syntax error otherwise.  Since the main purpose of feature.pm is to
+avoid conflicts with user-defined subroutines, there is no reason for
+C<continue> to depend on it.
+
+=head3 DTrace probes for interpreter phase change
+
+The C<phase-change> probes will fire when the interpreter's phase
+changes, which tracks the C<${^GLOBAL_PHASE}> variable.  C<arg0> is
+the new phase name; C<arg1> is the old one.  This is useful 
+for limiting your instrumentation to one or more of: compile time,
+run time, or destruct time.
+
+=head3 C<__FILE__()> Syntax
+
+The C<__FILE__>, C<__LINE__> and C<__PACKAGE__> tokens can now be written
+with an empty pair of parentheses after them.  This makes them parse the
+same way as C<time>, C<fork> and other built-in functions.
+
+=head3 The C<\$> prototype accepts any scalar lvalue
+
+The C<\$> and C<\[$]> subroutine prototypes now accept any scalar lvalue
+argument.  Previously they accepted only scalars beginning with C<$> and
+hash and array elements.  This change makes them consistent with the way
+the built-in C<read> and C<recv> functions (among others) parse their
+arguments.  This means that one can override the built-in functions with
+custom subroutines that parse their arguments the same way.
+
+=head3 C<_> in subroutine prototypes
+
+The C<_> character in subroutine prototypes is now allowed before C<@> or
+C<%>.
+
+=head1 Security
+
+=head2 Use C<is_utf8_char_buf()> and not C<is_utf8_char()>
+
+The latter function is now deprecated because its API is insufficient to
+guarantee that it doesn't read (up to 12 bytes in the worst case) beyond
+the end of its input string.  See
+L<is_utf8_char_buf()|/Added is_utf8_char_buf()>.
+
+=head2 Malformed UTF-8 input could cause attempts to read beyond the end of the buffer
+
+Two new XS-accessible functions, C<utf8_to_uvchr_buf()> and
+C<utf8_to_uvuni_buf()> are now available to prevent this, and the Perl
+core has been converted to use them.
+See L</Internal Changes>.
+
+=head2 C<File::Glob::bsd_glob()> memory error with GLOB_ALTDIRFUNC (CVE-2011-2728).
+
+Calling C<File::Glob::bsd_glob> with the unsupported flag
+GLOB_ALTDIRFUNC would cause an access violation / segfault.  A Perl
+program that accepts a flags value from an external source could expose
+itself to denial of service or arbitrary code execution attacks.  There
+are no known exploits in the wild.  The problem has been corrected by
+explicitly disabling all unsupported flags and setting unused function
+pointers to null.  Bug reported by Clément Lecigne. (5.14.2)
+
+=head2 Privileges are now set correctly when assigning to C<$(>
+
+A hypothetical bug (probably unexploitable in practice) because the
+incorrect setting of the effective group ID while setting C<$(> has been
+fixed.  The bug would have affected only systems that have C<setresgid()>
+but not C<setregid()>, but no such systems are known to exist.
+
+=head1 Deprecations
+
+=head2 Don't read the Unicode data base files in F<lib/unicore>
+
+It is now deprecated to directly read the Unicode data base files.
+These are stored in the F<lib/unicore> directory.  Instead, you should
+use the new functions in L<Unicode::UCD>.  These provide a stable API,
+and give complete information.
+
+Perl may at some point in the future change or remove these files.  The
+file which applications were most likely to have used is
+F<lib/unicore/ToDigit.pl>.  L<Unicode::UCD/prop_invmap()> can be used to
+get at its data instead.
+
+=head2 XS functions C<is_utf8_char()>, C<utf8_to_uvchr()> and
+C<utf8_to_uvuni()>
+
+This function is deprecated because it could read beyond the end of the
+input string.  Use the new L<is_utf8_char_buf()|/Added is_utf8_char_buf()>,
+C<utf8_to_uvchr_buf()> and C<utf8_to_uvuni_buf()> instead.
+
+=head1 Future Deprecations
+
+This section serves as a notice of features that are I<likely> to be
+removed or L<deprecated|perlpolicy/deprecated> in the next release of
+perl (5.18.0).  If your code depends on these features, you should
+contact the Perl 5 Porters via the L<mailing
+list|http://lists.perl.org/list/perl5-porters.html> or L<perlbug> to
+explain your use case and inform the deprecation process.
+
+=head2 Core Modules
+
+These modules may be marked as deprecated I<from the core>.  This only
+means that they will no longer be installed by default with the core
+distribution, but will remain available on the CPAN.
+
+=over
+
+=item *
+
+CPANPLUS
+
+=item *
+
+Filter::Simple
+
+=item *
+
+PerlIO::mmap
+
+=item *
+
+Pod::LaTeX
+
+=item *
+
+Pod::Parser
+
+=item *
+
+SelfLoader
+
+=item *
+
+Text::Soundex
+
+=item *
+
+Thread.pm
+
+=back
+
+=head2 Platforms with no supporting programmers:
+
+These platforms will probably have their
+special build support removed during the
+5.17.0 development series.
+
+=over
+
+=item *
+
+BeOS
+
+=item *
+
+djgpp
+
+=item *
+
+dgux
+
+=item *
+
+EPOC
+
+=item *
+
+MPE/iX
+
+=item *
+
+Rhapsody
+
+=item *
+
+UTS
+
+=item *
+
+VM/ESA
+
+=back
+
+=head2 Other Future Deprecations
+
+=over
+
+=item *
+
+Swapping of $< and $>
+
+For more information about this future deprecation, see L<the relevant RT
+ticket|https://rt.perl.org/rt3/Ticket/Display.html?id=96212>.
+
+=item *
+
+sfio, stdio
+
+Perl supports being built without PerlIO proper, using a stdio or sfio
+wrapper instead.  A perl build like this will not support IO layers and
+thus Unicode IO, making it rather handicapped.
+
+PerlIO supports a C<stdio> layer if stdio use is desired, and similarly a
+sfio layer could be produced.
+
+=item *
+
+Unescaped literal C<< "{" >> in regular expressions.
+
+Starting with v5.20, it is planned to require a literal C<"{"> to be
+escaped, for example by preceding it with a backslash.  In v5.18, a
+deprecated warning message will be emitted for all such uses.  
+This affects only patterns that are to match a literal C<"{">.  Other
+uses of this character, such as part of a quantifier or sequence as in
+those below, are completely unaffected:
+
+    /foo{3,5}/
+    /\p{Alphabetic}/
+    /\N{DIGIT ZERO}
+
+Removing this will permit extensions to Perl's pattern syntax and better
+error checking for existing syntax.  See L<perlre/Quantifiers> for an
+example.
+
+=item *
+
+Revamping C<< "\Q" >> semantics in double-quotish strings when combined with other escapes.
+
+There are several bugs and inconsistencies involving combinations
+of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair.
+These need to be fixed, and doing so will necessarily change current
+behavior.  The changes have not yet been settled.
+
+=back
+
+=head1 Incompatible Changes
+
+=head2 Special blocks called in void context
+
+Special blocks (C<BEGIN>, C<CHECK>, C<INIT>, C<UNITCHECK>, C<END>) are now
+called in void context.  This avoids wasteful copying of the result of the
+last statement [perl #108794].
+
+=head2 The C<overloading> pragma and regexp objects
+
+With C<no overloading>, regular expression objects returned by C<qr//> are
+now stringified as "Regexp=REGEXP(0xbe600d)" instead of the regular
+expression itself [perl #108780].
+
+=head2 Two XS typemap Entries removed
+
+Two presumably unused XS typemap entries have been removed from the
+core typemap: T_DATAUNIT and T_CALLBACK.  If you are, against all odds,
+a user of these, please see the instructions on how to restore them
+in L<perlxstypemap>.
+
+=head2 Unicode 6.1 has incompatibilities with Unicode 6.0
+
+These are detailed in L</Supports (almost) Unicode 6.1> above.
+You can compile this version of Perl to use Unicode 6.0.  See
+L<perlunicode/Hacking Perl to work on earlier Unicode versions (for very serious hackers only)>.
+
+=head2 Borland compiler
+
+All support for the Borland compiler has been dropped.  The code had not
+worked for a long time anyway.
+
+=head2 Certain deprecated Unicode properties are no longer supported by default
+
+Perl should never have exposed certain Unicode properties that are used
+by Unicode internally and not meant to be publicly available.  Use of
+these has generated deprecated warning messages since Perl 5.12.  The
+removed properties are Other_Alphabetic,
+Other_Default_Ignorable_Code_Point, Other_Grapheme_Extend,
+Other_ID_Continue, Other_ID_Start, Other_Lowercase, Other_Math, and
+Other_Uppercase.
+
+Perl may be recompiled to include any or all of them; instructions are
+given in
+L<perluniprops/Unicode character properties that are NOT accepted by Perl>.
+
+=head2 Dereferencing IO thingies as typeglobs
+
+The C<*{...}> operator, when passed a reference to an IO thingy (as in
+C<*{*STDIN{IO}}>), creates a new typeglob containing just that IO object.
+Previously, it would stringify as an empty string, but some operators would
+treat it as undefined, producing an "uninitialized" warning.
+Now it stringifies as __ANONIO__ [perl #96326].
+
+=head2 User-defined case-changing operations
+
+This feature was deprecated in Perl 5.14, and has now been removed.
+The CPAN module L<Unicode::Casing> provides better functionality without
+the drawbacks that this feature had, as are detailed in the 5.14
+documentation:
+L<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
+
+=head2 XSUBs are now 'static'
+
+XSUB C functions are now 'static', that is, they are not visible from
+outside the compilation unit.  Users can use the new C<XS_EXTERNAL(name)>
+and C<XS_INTERNAL(name)> macros to pick the desired linking behavior.
+The ordinary C<XS(name)> declaration for XSUBs will continue to declare
+non-'static' XSUBs for compatibility, but the XS compiler,
+L<ExtUtils::ParseXS> (C<xsubpp>) will emit 'static' XSUBs by default.
+L<ExtUtils::ParseXS>'s behavior can be reconfigured from XS using the
+C<EXPORT_XSUB_SYMBOLS> keyword.  See L<perlxs> for details.
+
+=head2 Weakening read-only references
+
+Weakening read-only references is no longer permitted.  It should never
+have worked anyway, and could sometimes result in crashes.
+
+=head2 Tying scalars that hold typeglobs
+
+Attempting to tie a scalar after a typeglob was assigned to it would
+instead tie the handle in the typeglob's IO slot.  This meant that it was
+impossible to tie the scalar itself.  Similar problems affected C<tied> and
+C<untie>: C<tied $scalar> would return false on a tied scalar if the last
+thing returned was a typeglob, and C<untie $scalar> on such a tied scalar
+would do nothing.
+
+We fixed this problem before Perl 5.14.0, but it caused problems with some
+CPAN modules, so we put in a deprecation cycle instead.
+
+Now the deprecation has been removed and this bug has been fixed.  So
+C<tie $scalar> will always tie the scalar, not the handle it holds.  To tie
+the handle, use C<tie *$scalar> (with an explicit asterisk).  The same
+applies to C<tied *$scalar> and C<untie *$scalar>.
+
+=head2 IPC::Open3 no longer provides C<xfork()>, C<xclose_on_exec()>
+and C<xpipe_anon()>
+
+All three functions were private, undocumented, and unexported.  They do
+not appear to be used by any code on CPAN.  Two have been inlined and one
+deleted entirely.
+
+=head2 C<$$> no longer caches PID
+
+Previously, if one called fork(3) from C, Perl's
+notion of C<$$> could go out of sync with what getpid() returns.  By always
+fetching the value of C<$$> via getpid(), this potential bug is eliminated.
+Code that depends on the caching behavior will break.  As described in
+L<Core Enhancements|/C<$$> can be assigned to>,
+C<$$> is now writable, but it will be reset during a
+fork.
+
+=head2 C<$$> and C<getppid()> no longer emulate POSIX semantics under LinuxThreads
+
+The POSIX emulation of C<$$> and C<getppid()> under the obsolete
+LinuxThreads implementation has been removed.
+This only impacts users of Linux 2.4 and
+users of Debian GNU/kFreeBSD up to and including 6.0, not the vast
+majority of Linux installations that use NPTL threads.
+
+This means that C<getppid()>, like C<$$>, is now always guaranteed to
+return the OS's idea of the current state of the process, not perl's
+cached version of it.
+
+See the documentation for L<$$|perlvar/$$> for details.
+
+=head2 C<< $< >>, C<< $> >>, C<$(> and C<$)> are no longer cached
+
+Similarly to the changes to C<$$> and C<getppid()>, the internal
+caching of C<< $< >>, C<< $> >>, C<$(> and C<$)> has been removed.
+
+When we cached these values our idea of what they were would drift out
+of sync with reality if someone (e.g., someone embedding perl) called
+C<sete?[ug]id()> without updating C<PL_e?[ug]id>.  Having to deal with
+this complexity wasn't worth it given how cheap the C<gete?[ug]id()>
+system call is.
+
+This change will break a handful of CPAN modules that use the XS-level
+C<PL_uid>, C<PL_gid>, C<PL_euid> or C<PL_egid> variables.
+
+The fix for those breakages is to use C<PerlProc_gete?[ug]id()> to
+retrieve them (e.g., C<PerlProc_getuid()>), and not to assign to
+C<PL_e?[ug]id> if you change the UID/GID/EUID/EGID.  There is no longer
+any need to do so since perl will always retrieve the up-to-date
+version of those values from the OS.
+
+=head2 Which Non-ASCII characters get quoted by C<quotemeta> and C<\Q> has changed
+
+This is unlikely to result in a real problem, as Perl does not attach
+special meaning to any non-ASCII character, so it is currently
+irrelevant which are quoted or not.  This change fixes bug [perl #77654] and
+brings Perl's behavior more into line with Unicode's recommendations.
+See L<perlfunc/quotemeta>.
+
+=head1 Performance Enhancements
+
+=over
+
+=item *
+
+Improved performance for Unicode properties in regular expressions
+
+=for comment Can this be compacted some? -- rjbs, 2012-02-20
+
+Matching a code point against a Unicode property is now done via a
+binary search instead of linear.  This means for example that the worst
+case for a 1000 item property is 10 probes instead of 1000.  This
+inefficiency has been compensated for in the past by permanently storing
+in a hash the results of a given probe plus the results for the adjacent
+64 code points, under the theory that near-by code points are likely to
+be searched for.  A separate hash was used for each mention of a Unicode
+property in each regular expression.  Thus, C<qr/\p{foo}abc\p{foo}/>
+would generate two hashes.  Any probes in one instance would be unknown
+to the other, and the hashes could expand separately to be quite large
+if the regular expression were used on many different widely-separated
+code points.
+Now, however, there is just one hash shared by all instances of a given
+property.  This means that if C<\p{foo}> is matched against "A" in one
+regular expression in a thread, the result will be known immediately to
+all regular expressions, and the relentless march of using up memory is
+slowed considerably.
+
+=item *
+
+Version declarations with the C<use> keyword (e.g., C<use 5.012>) are now
+faster, as they enable features without loading F<feature.pm>.
+
+=item *
+
+C<local $_> is faster now, as it no longer iterates through magic that it
+is not going to copy anyway.
+
+=item *
+
+Perl 5.12.0 sped up the destruction of objects whose classes define
+empty C<DESTROY> methods (to prevent autoloading), by simply not
+calling such empty methods.  This release takes this optimization a
+step further, by not calling any C<DESTROY> method that begins with a
+C<return> statement.  This can be useful for destructors that are only
+used for debugging:
+
+    use constant DEBUG => 1;
+    sub DESTROY { return unless DEBUG; ... }
+
+Constant-folding will reduce the first statement to C<return;> if DEBUG
+is set to 0, triggering this optimization.
+
+=item *
+
+Assigning to a variable that holds a typeglob or copy-on-write scalar
+is now much faster.  Previously the typeglob would be stringified or
+the copy-on-write scalar would be copied before being clobbered.
+
+=item *
+
+Assignment to C<substr> in void context is now more than twice its
+previous speed.  Instead of creating and returning a special lvalue
+scalar that is then assigned to, C<substr> modifies the original string
+itself.
+
+=item *
+
+C<substr> no longer calculates a value to return when called in void
+context.
+
+=item *
+
+Due to changes in L<File::Glob>, Perl's C<glob> function and its C<<
+<...> >> equivalent are now much faster.  The splitting of the pattern
+into words has been rewritten in C, resulting in speed-ups of 20% for
+some cases.
+
+This does not affect C<glob> on VMS, as it does not use File::Glob.
+
+=item *
+
+The short-circuiting operators C<&&>, C<||>, and C<//>, when chained
+(such as C<$a || $b || $c>), are now considerably faster to short-circuit,
+due to reduced optree traversal.
+
+=item *
+
+The implementation of C<s///r> makes one fewer copy of the scalar's value.
+
+=item *
+
+Recursive calls to lvalue subroutines in lvalue scalar context use less
+memory.
+
+=back
+
+=head1 Modules and Pragmata
+
+=head2 Deprecated Modules
+
+=over
+
+=item L<Version::Requirements>
+
+Version::Requirements is now DEPRECATED, use L<CPAN::Meta::Requirements>,
+which is a drop-in replacement.  It will be deleted from perl.git blead
+in v5.17.0.
+
+=back
+
+=head2 New Modules and Pragmata
+
+=over 4
+
+=item *
+
+L<arybase> -- this new module implements the C<$[> variable.
+
+=item *
+
+L<PerlIO::mmap> 0.010 has been added to the Perl core.
+
+The C<mmap> PerlIO layer is no longer implemented by perl itself, but has
+been moved out into the new L<PerlIO::mmap> module.
+
+=back
+
+=head2 Updated Modules and Pragmata
+
+This is only an overview of selected module updates.  For a complete list of
+updates, run:
+
+    $ corelist --diff 5.14.0 5.16.0
+
+You can substitute your favorite version in place of 5.14.0, too.
+
+=over 4
+
+=item *
+
+L<Archive::Extract> has been upgraded from version 0.48 to 0.58.
+
+Includes a fix for FreeBSD to only use C<unzip> if it is located in
+C</usr/local/bin>, as FreeBSD 9.0 will ship with a limited C<unzip> in
+C</usr/bin>.
+
+=item *
+
+L<Archive::Tar> has been upgraded from version 1.76 to 1.82.
+
+Adjustments to handle files >8gb (>0777777777777 octal) and a feature
+to return the MD5SUM of files in the archive.
+
+=item *
+
+L<base> has been upgraded from version 2.16 to 2.18.
+
+C<base> no longer sets a module's C<$VERSION> to "-1" when a module it
+loads does not define a C<$VERSION>.  This change has been made because
+"-1" is not a valid version number under the new "lax" criteria used
+internally by C<UNIVERSAL::VERSION>.  (See L<version> for more on "lax"
+version criteria.)
+
+C<base> no longer internally skips loading modules it has already loaded
+and instead relies on C<require> to inspect C<%INC>.  This fixes a bug
+when C<base> is used with code that clear C<%INC> to force a module to
+be reloaded.
+
+=item *
+
+L<Carp> has been upgraded from version 1.20 to 1.26.
+
+It now includes last read filehandle info and puts a dot after the file
+and line number, just like errors from C<die> [perl #106538].
+
+=item *
+
+L<charnames> has been updated from version 1.18 to 1.30.
+
+C<charnames> can now be invoked with a new option, C<:loose>,
+which is like the existing C<:full> option, but enables Unicode loose
+name matching.  Details are in L<charnames/LOOSE MATCHES>.
+
+=item *
+
+L<B::Deparse> has been upgraded from version 1.03 to 1.14.  This fixes
+numerous deparsing bugs.
+
+=item *
+
+L<CGI> has been upgraded from version 3.52 to 3.59.
+
+It uses the public and documented FCGI.pm API in CGI::Fast.  CGI::Fast was
+using an FCGI API that was deprecated and removed from documentation
+more than ten years ago.  Usage of this deprecated API with FCGI E<gt>=
+0.70 or FCGI E<lt>= 0.73 introduces a security issue.
+L<https://rt.cpan.org/Public/Bug/Display.html?id=68380>
+L<http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-2766>
+
+Things that may break your code:
+
+C<url()> was fixed to return C<PATH_INFO> when it is explicitly requested
+with either the C<path=E<gt>1> or C<path_info=E<gt>1> flag.
+
+If your code is running under mod_rewrite (or compatible) and you are
+calling C<self_url()> or you are calling C<url()> and passing
+C<path_info=E<gt>1>, these methods will actually be returning
+C<PATH_INFO> now, as you have explicitly requested or C<self_url()>
+has requested on your behalf.
+
+The C<PATH_INFO> has been omitted in such URLs since the issue was
+introduced in the 3.12 release in December, 2005.
+
+This bug is so old your application may have come to depend on it or
+workaround it. Check for application before upgrading to this release.
+
+Examples of affected method calls:
+
+  $q->url(-absolute => 1, -query => 1, -path_info => 1);
+  $q->url(-path=>1);
+  $q->url(-full=>1,-path=>1);
+  $q->url(-rewrite=>1,-path=>1);
+  $q->self_url();
+
+We no longer read from STDIN when the Content-Length is not set,
+preventing requests with no Content-Length from sometimes freezing.
+This is consistent with the CGI RFC 3875, and is also consistent with
+CGI::Simple.  However, the old behavior may have been expected by some
+command-line uses of CGI.pm.
+
+In addition, the DELETE HTTP verb is now supported.
+
+=item *
+
+L<Compress::Zlib> has been upgraded from version 2.035 to 2.048.
+
+IO::Compress::Zip and IO::Uncompress::Unzip now have support for LZMA
+(method 14).  There is a fix for a CRC issue in IO::Compress::Unzip and
+it supports Streamed Stored context now.  And fixed a Zip64 issue in
+IO::Compress::Zip when the content size was exactly 0xFFFFFFFF.
+
+=item *
+
+L<Digest::SHA> has been upgraded from version 5.61 to 5.71.
+
+Added BITS mode to the addfile method and shasum.  This makes
+partial-byte inputs possible via files/STDIN and lets shasum check
+all 8074 NIST Msg vectors, where previously special programming was
+required to do this.
+
+=item *
+
+L<Encode> has been upgraded from version 2.42 to 2.44.
+
+Missing aliases added, a deep recursion error fixed and various
+documentation updates.
+
+Addressed 'decode_xs n-byte heap-overflow' security bug in Unicode.xs
+(CVE-2011-2939). (5.14.2)
+
+=item *
+
+L<ExtUtils::CBuilder> updated from version 0.280203 to 0.280206.
+
+The new version appends CFLAGS and LDFLAGS to their Config.pm
+counterparts.
+
+=item *
+
+L<ExtUtils::ParseXS> has been upgraded from version 2.2210 to 3.16.
+
+Much of L<ExtUtils::ParseXS>, the module behind the XS compiler C<xsubpp>,
+was rewritten and cleaned up.  It has been made somewhat more extensible
+and now finally uses strictures.
+
+The typemap logic has been moved into a separate module,
+L<ExtUtils::Typemaps>.  See L</New Modules and Pragmata>, above.
+
+For a complete set of changes, please see the ExtUtils::ParseXS
+changelog, available on the CPAN.
+
+=item *
+
+L<File::Glob> has been upgraded from version 1.12 to 1.17.
+
+On Windows, tilde (~) expansion now checks the C<USERPROFILE> environment
+variable, after checking C<HOME>.
+
+It has a new C<:bsd_glob> export tag, intended to replace C<:glob>.  Like
+C<:glob> it overrides C<glob> with a function that does not split the glob
+pattern into words, but, unlike C<:glob>, it iterates properly in scalar
+context, instead of returning the last file.
+
+There are other changes affecting Perl's own C<glob> operator (which uses
+File::Glob internally, except on VMS).  See L</Performance Enhancements>
+and L</Selected Bug Fixes>.
+
+=item *
+
+L<FindBin> updated from version 1.50 to 1.51.
+
+It no longer returns a wrong result if a script of the same name as the
+current one exists in the path and is executable.
+
+=item *
+
+L<HTTP::Tiny> has been upgraded from version 0.012 to 0.017.
+
+Added support for using C<$ENV{http_proxy}> to set the default proxy host.
+
+Adds additional shorthand methods for all common HTTP verbs,
+a C<post_form()> method for POST-ing x-www-form-urlencoded data and
+a C<www_form_urlencode()> utility method.
+
+=item *
+
+L<IO> has been upgraded from version 1.25_04 to 1.25_06, and L<IO::Handle>
+from version 1.31 to 1.33.
+
+Together, these upgrades fix a problem with IO::Handle's C<getline> and
+C<getlines> methods.  When these methods are called on the special ARGV
+handle, the next file is automatically opened, as happens with the built-in
+C<E<lt>E<gt>> and C<readline> functions.  But, unlike the built-ins, these
+methods were not respecting the caller's use of the L<open> pragma and
+applying the appropriate I/O layers to the newly-opened file
+[rt.cpan.org #66474].
+
+=item *
+
+L<IPC::Cmd> has been upgraded from version 0.70 to 0.76.
+
+Capturing of command output (both C<STDOUT> and C<STDERR>) is now supported
+using L<IPC::Open3> on MSWin32 without requiring L<IPC::Run>.
+
+=item *
+
+L<IPC::Open3> has been upgraded from version 1.09 to 1.12.
+
+Fixes a bug which prevented use of C<open3> on Windows when C<*STDIN>,
+C<*STDOUT> or C<*STDERR> had been localized.
+
+Fixes a bug which prevented duplicating numeric file descriptors on Windows.
+
+C<open3> with "-" for the program name works once more.  This was broken in
+version 1.06 (and hence in Perl 5.14.0) [perl #95748].
+
+=item *
+
+L<Locale::Codes> has been upgraded from version 3.16 to 3.21.
+
+Added Language Extension codes (langext) and Language Variation codes (langvar)
+as defined in the IANA language registry.
+
+Added language codes from ISO 639-5
+
+Added language/script codes from the IANA language subtag registry
+
+Fixed an uninitialized value warning [rt.cpan.org #67438].
+
+Fixed the return value for the all_XXX_codes and all_XXX_names functions
+[rt.cpan.org #69100].
+
+Reorganized modules to move Locale::MODULE to Locale::Codes::MODULE to allow
+for cleaner future additions.  The original four modules (Locale::Language,
+Locale::Currency, Locale::Country, Locale::Script) will continue to work, but
+all new sets of codes will be added in the Locale::Codes namespace.
+
+The code2XXX, XXX2code, all_XXX_codes, and all_XXX_names functions now
+support retired codes.  All codesets may be specified by a constant or
+by their name now.  Previously, they were specified only by a constant.
+
+The alias_code function exists for backward compatibility.  It has been
+replaced by rename_country_code.  The alias_code function will be
+removed some time after September, 2013.
+
+All work is now done in the central module (Locale::Codes).  Previously,
+some was still done in the wrapper modules (Locale::Codes::*).  Added
+Language Family codes (langfam) as defined in ISO 639-5.
+
+=item *
+
+L<Math::BigFloat> has been upgraded from version 1.993 to 1.997.
+
+The C<numify> method has been corrected to return a normalized Perl number
+(the result of C<0 + $thing>), instead of a string [rt.cpan.org #66732].
+
+=item *
+
+L<Math::BigInt> has been upgraded from version 1.994 to 1.998.
+
+It provides a new C<bsgn> method that complements the C<babs> method.
+
+It fixes the internal C<objectify> function's handling of "foreign objects"
+so they are converted to the appropriate class (Math::BigInt or
+Math::BigFloat).
+
+=item *
+
+L<Math::BigRat> has been upgraded from version 0.2602 to 0.2603.
+
+C<int()> on a Math::BigRat object containing -1/2 now creates a
+Math::BigInt containing 0, rather than -0.  L<Math::BigInt> does not even
+support negative zero, so the resulting object was actually malformed
+[perl #95530].
+
+=item *
+
+L<Math::Complex> has been upgraded from version 1.56 to 1.59
+and L<Math::Trig> from version 1.2 to 1.22.
+
+Fixes include: correct copy constructor usage; fix polarwise formatting with
+numeric format specifier; and more stable C<great_circle_direction> algorithm.
+
+=item *
+
+L<Module::CoreList> has been upgraded from version 2.51 to 2.66.
+
+The C<corelist> utility now understands the C<-r> option for displaying
+Perl release dates and the C<--diff> option to print the set of modlib
+changes between two perl distributions.
+
+=item *
+
+L<Module::Metadata> has been upgraded from version 1.000004 to 1.000009.
+
+Adds C<provides> method to generate a CPAN META provides data structure
+correctly; use of C<package_versions_from_directory> is discouraged.
+
+=item *
+
+L<ODBM_File> has been upgraded from version 1.10 to 1.12.
+
+The XS code is now compiled with C<PERL_NO_GET_CONTEXT>, which will aid
+performance under ithreads.
+
+=item *
+
+L<open> has been upgraded from version 1.08 to 1.10.
+
+It no longer turns off layers on standard handles when invoked without the
+":std" directive.  Similarly, when invoked I<with> the ":std" directive, it
+now clears layers on STDERR before applying the new ones, and not just on
+STDIN and STDOUT [perl #92728].
+
+=item *
+
+L<overload> has been upgraded from version 1.13 to 1.18.
+
+C<overload::Overloaded> no longer calls C<can> on the class, but uses
+another means to determine whether the object has overloading.  It was
+never correct for it to call C<can>, as overloading does not respect
+AUTOLOAD.  So classes that autoload methods and implement C<can> no longer
+have to account for overloading [perl #40333].
+
+A warning is now produced for invalid arguments.  See L</New Diagnostics>.
+
+=item *
+
+L<PerlIO::scalar> has been upgraded from version 0.11 to 0.14.
+
+(This is the module that implements C<< open $fh, '>', \$scalar >>.)
+
+It fixes a problem with C<< open my $fh, ">", \$scalar >> not working if
+C<$scalar> is a copy-on-write scalar. (5.14.2)
+
+It also fixes a hang that occurs with C<readline> or C<< <$fh> >> if a
+typeglob has been assigned to $scalar [perl #92258].
+
+It no longer assumes during C<seek> that $scalar is a string internally.
+If it didn't crash, it was close to doing so [perl #92706].  Also, the
+internal print routine no longer assumes that the position set by C<seek>
+is valid, but extends the string to that position, filling the intervening
+bytes (between the old length and the seek position) with nulls
+[perl #78980].
+
+Printing to an in-memory handle now works if the $scalar holds a reference,
+stringifying the reference before modifying it.  References used to be
+treated as empty strings.
+
+Printing to an in-memory handle no longer crashes if the $scalar happens to
+hold a number internally, but no string buffer.
+
+Printing to an in-memory handle no longer creates scalars that confuse
+the regular expression engine [perl #108398].
+
+=item *
+
+L<Pod::Functions> has been upgraded from version 1.04 to 1.05.
+
+F<Functions.pm> is now generated at perl build time from annotations in
+F<perlfunc.pod>.  This will ensure that L<Pod::Functions> and L<perlfunc>
+remain in synchronisation.
+
+=item *
+
+L<Pod::Html> has been upgraded from version 1.11 to 1.1502.
+
+This is an extensive rewrite of Pod::Html to use L<Pod::Simple> under
+the hood.  The output has changed significantly.
+
+=item *
+
+L<Pod::Perldoc> has been upgraded from version 3.15_03 to 3.17.
+
+It corrects the search paths on VMS [perl #90640]. (5.14.1)
+
+The B<-v> option now fetches the right section for C<$0>.
+
+This upgrade has numerous significant fixes.  Consult its changelog on
+the CPAN for more information.
+
+=item *
+
+L<POSIX> has been upgraded from version 1.24 to 1.30.
+
+L<POSIX> no longer uses L<AutoLoader>.  Any code which was relying on this
+implementation detail was buggy, and may fail because of this change.
+The module's Perl code has been considerably simplified, roughly halving
+the number of lines, with no change in functionality.  The XS code has
+been refactored to reduce the size of the shared object by about 12%,
+with no change in functionality.  More POSIX functions now have tests.
+
+C<sigsuspend> and C<pause> now run signal handlers before returning, as the
+whole point of these two functions is to wait until a signal has
+arrived, and then return I<after> it has been triggered.  Delayed, or
+"safe", signals were preventing that from happening, possibly resulting in
+race conditions [perl #107216].
+
+C<POSIX::sleep> is now a direct call into the underlying OS C<sleep>
+function, instead of being a Perl wrapper on C<CORE::sleep>.
+C<POSIX::dup2> now returns the correct value on Win32 (I<i.e.>, the file
+descriptor).  C<POSIX::SigSet> C<sigsuspend> and C<sigpending> and
+C<POSIX::pause> now dispatch safe signals immediately before returning to
+their caller.
+
+C<POSIX::Termios::setattr> now defaults the third argument to C<TCSANOW>,
+instead of 0. On most platforms C<TCSANOW> is defined to be 0, but on some
+0 is not a valid parameter, which caused a call with defaults to fail.
+
+=item *
+
+L<Socket> has been upgraded from version 1.94 to 2.001.
+
+It has new functions and constants for handling IPv6 sockets:
+
+    pack_ipv6_mreq
+    unpack_ipv6_mreq
+    IPV6_ADD_MEMBERSHIP
+    IPV6_DROP_MEMBERSHIP
+    IPV6_MTU
+    IPV6_MTU_DISCOVER
+    IPV6_MULTICAST_HOPS
+    IPV6_MULTICAST_IF
+    IPV6_MULTICAST_LOOP
+    IPV6_UNICAST_HOPS
+    IPV6_V6ONLY
+
+=item *
+
+L<Storable> has been upgraded from version 2.27 to 2.34.
+
+It no longer turns copy-on-write scalars into read-only scalars when
+freezing and thawing.
+
+=item *
+
+L<Sys::Syslog> has been upgraded from version 0.27 to 0.29.
+
+This upgrade closes many outstanding bugs.
+
+=item *
+
+L<Term::ANSIColor> has been upgraded from version 3.00 to 3.01.
+
+Only interpret an initial array reference as a list of colors, not any initial
+reference, allowing the colored function to work properly on objects with
+stringification defined.
+
+=item *
+
+L<Term::ReadLine> has been upgraded from version 1.07 to 1.09.
+
+Term::ReadLine now supports any event loop, including unpublished ones and
+simple L<IO::Select>, loops without the need to rewrite existing code for
+any particular framework [perl #108470].
+
+=item *
+
+L<threads::shared> has been upgraded from version 1.37 to 1.40.
+
+Destructors on shared objects used to be ignored sometimes if the objects
+were referenced only by shared data structures.  This has been mostly
+fixed, but destructors may still be ignored if the objects still exist at
+global destruction time [perl #98204].
+
+=item *
+
+L<Unicode::Collate> has been upgraded from version 0.73 to 0.89.
+
+Updated to CLDR 1.9.1
+
+Locales updated to CLDR 2.0: mk, mt, nb, nn, ro, ru, sk, sr, sv, uk,
+zh__pinyin, zh__stroke
+
+Newly supported locales: bn, fa, ml, mr, or, pa, sa, si, si__dictionary,
+sr_Latn, sv__reformed, ta, te, th, ur, wae.
+
+Tailored compatibility ideographs as well as unified ideographs for the
+locales: ja, ko, zh__big5han, zh__gb2312han, zh__pinyin, zh__stroke.
+
+Locale/*.pl files are now searched for in @INC.
+
+=item *
+
+L<Unicode::Normalize> has been upgraded from version 1.10 to 1.14.
+
+Fixes for the removal of F<unicore/CompositionExclusions.txt> from core.
+
+=item *
+
+L<Unicode::UCD> has been upgraded from version 0.32 to 0.43.
+
+This adds four new functions:  C<prop_aliases()> and
+C<prop_value_aliases()>, which are used to find all Unicode-approved
+synonyms for property names, or to convert from one name to another;
+C<prop_invlist> which returns all code points matching a given
+Unicode binary property; and C<prop_invmap> which returns the complete
+specification of a given Unicode property.
+
+=item *
+
+L<Win32API::File> has been upgraded from version 0.1101 to 0.1200.
+
+Added SetStdHandle and GetStdHandle functions
+
+=back
+
+=head2 Removed Modules and Pragmata
+
+As promised in Perl 5.14.0's release notes, the following modules have
+been removed from the core distribution, and if needed should be installed
+from CPAN instead.
+
+=over
+
+=item *
+
+L<Devel::DProf> has been removed from the Perl core.  Prior version was
+20110228.00.
+
+=item *
+
+L<Shell> has been removed from the Perl core.  Prior version was 0.72_01.
+
+=item *
+
+Several old perl4-style libraries which have been deprecated with 5.14
+are now removed:
+
+    abbrev.pl assert.pl bigfloat.pl bigint.pl bigrat.pl cacheout.pl
+    complete.pl ctime.pl dotsh.pl exceptions.pl fastcwd.pl flush.pl
+    getcwd.pl getopt.pl getopts.pl hostname.pl importenv.pl
+    lib/find{,depth}.pl look.pl newgetopt.pl open2.pl open3.pl
+    pwd.pl shellwords.pl stat.pl tainted.pl termcap.pl timelocal.pl
+
+They can be found on CPAN as L<Perl4::CoreLibs>.
+
+=back
+
+=head1 Documentation
+
+=head2 New Documentation
+
+=head3 L<perldtrace>
+
+L<perldtrace> describes Perl's DTrace support, listing the provided probes
+and gives examples of their use.
+
+=head3 L<perlexperiment>
+
+This document is intended to provide a list of experimental features in
+Perl.  It is still a work in progress.
+
+=head3 L<perlootut>
+
+This a new OO tutorial.  It focuses on basic OO concepts, and then recommends
+that readers choose an OO framework from CPAN.
+
+=head3 L<perlxstypemap>
+
+The new manual describes the XS typemapping mechanism in unprecedented
+detail and combines new documentation with information extracted from
+L<perlxs> and the previously unofficial list of all core typemaps.
+
+=head2 Changes to Existing Documentation
+
+=head3 L<perlapi>
+
+=over 4
+
+=item *
+
+The HV API has long accepted negative lengths to show that the key is
+in UTF8.  This is now documented.
+
+=item *
+
+The C<boolSV()> macro is now documented.
+
+=back
+
+=head3 L<perlfunc>
+
+=over 4
+
+=item *
+
+C<dbmopen> treats a 0 mode as a special case, that prevents a nonexistent
+file from being created.  This has been the case since Perl 5.000, but was
+never documented anywhere.  Now the perlfunc entry mentions it
+[perl #90064].
+
+=item *
+
+As an accident of history, C<open $fh, '<:', ...> applies the default
+layers for the platform (C<:raw> on Unix, C<:crlf> on Windows), ignoring
+whatever is declared by L<open.pm|open>.  This seems such a useful feature
+it has been documented in L<perlfunc|perlfunc/open> and L<open>.
+
+=item *
+
+The entry for C<split> has been rewritten.  It is now far clearer than
+before.
+
+=back
+
+=head3 L<perlguts>
+
+=over 4
+
+=item *
+
+A new section, L<Autoloading with XSUBs|perlguts/Autoloading with XSUBs>,
+has been added, which explains the two APIs for accessing the name of the
+autoloaded sub.
+
+=item *
+
+Some function descriptions in L<perlguts> were confusing, as it was
+not clear whether they referred to the function above or below the
+description.  This has been clarified [perl #91790].
+
+=back
+
+=head3 L<perlobj>
+
+=over 4
+
+=item *
+
+This document has been rewritten from scratch, and its coverage of various OO
+concepts has been expanded.
+
+=back
+
+=head3 L<perlop>
+
+=over 4
+
+=item *
+
+Documentation of the smartmatch operator has been reworked and moved from
+perlsyn to perlop where it belongs.
+
+It has also been corrected for the case of C<undef> on the left-hand
+side.  The list of different smart match behaviors had an item in the
+wrong place.
+
+=item *
+
+Documentation of the ellipsis statement (C<...>) has been reworked and
+moved from perlop to perlsyn.
+
+=item *
+
+The explanation of bitwise operators has been expanded to explain how they
+work on Unicode strings (5.14.1).
+
+=item *
+
+More examples for C<m//g> have been added (5.14.1).
+
+=item *
+
+The C<<< <<\FOO >>> here-doc syntax has been documented (5.14.1).
+
+=back
+
+=head3 L<perlpragma>
+
+=over 4
+
+=item *
+
+There is now a standard convention for naming keys in the C<%^H>,
+documented under L<Key naming|perlpragma/Key naming>.
+
+=back
+
+=head3 L<perlsec/Laundering and Detecting Tainted Data>
+
+=over 4
+
+=item *
+
+The example function for checking for taintedness contained a subtle
+error.  C<$@> needs to be localized to prevent its changing this
+global's value outside the function.  The preferred method to check for
+this remains L<Scalar::Util/tainted>.
+
+=back
+
+=head3 L<perllol>
+
+=over
+
+=item *
+
+L<perllol> has been expanded with examples using the new C<push $scalar>
+syntax introduced in Perl 5.14.0 (5.14.1).
+
+=back
+
+=head3 L<perlmod>
+
+=over
+
+=item *
+
+L<perlmod> now states explicitly that some types of explicit symbol table
+manipulation are not supported.  This codifies what was effectively already
+the case [perl #78074].
+
+=back
+
+=head3 L<perlpodstyle>
+
+=over 4
+
+=item *
+
+The tips on which formatting codes to use have been corrected and greatly
+expanded.
+
+=item *
+
+There are now a couple of example one-liners for previewing POD files after
+they have been edited.
+
+=back
+
+=head3 L<perlre>
+
+=over
+
+=item *
+
+The C<(*COMMIT)> directive is now listed in the right section
+(L<Verbs without an argument|perlre/Verbs without an argument>).
+
+=back
+
+=head3 L<perlrun>
+
+=over
+
+=item *
+
+L<perlrun> has undergone a significant clean-up.  Most notably, the
+B<-0x...> form of the B<-0> flag has been clarified, and the final section
+on environment variables has been corrected and expanded (5.14.1).
+
+=back
+
+=head3 L<perlsub>
+
+=over
+
+=item *
+
+The ($;) prototype syntax, which has existed for rather a long time, is now
+documented in L<perlsub>.  It lets a unary function have the same
+precedence as a list operator.
+
+=back
+
+=head3 L<perltie>
+
+=over
+
+=item *
+
+The required syntax for tying handles has been documented.
+
+=back
+
+=head3 L<perlvar>
+
+=over
+
+=item *
+
+The documentation for L<$!|perlvar/$!> has been corrected and clarified.
+It used to state that $! could be C<undef>, which is not the case.  It was
+also unclear whether system calls set C's C<errno> or Perl's C<$!>
+[perl #91614].
+
+=item *
+
+Documentation for L<$$|perlvar/$$> has been amended with additional
+cautions regarding changing the process ID.
+
+=back
+
+=head3 Other Changes
+
+=over 4
+
+=item *
+
+L<perlxs> was extended with documentation on inline typemaps.
+
+=item *
+
+L<perlref> has a new L<Circular References|perlref/Circular References>
+section explaining how circularities may not be freed and how to solve that
+with weak references.
+
+=item *
+
+Parts of L<perlapi> were clarified, and Perl equivalents of some C
+functions have been added as an additional mode of exposition.
+
+=item *
+
+A few parts of L<perlre> and L<perlrecharclass> were clarified.
+
+=back
+
+=head2 Removed Documentation
+
+=head3 Old OO Documentation
+
+The old OO tutorials, perltoot, perltooc, and perlboot, have been
+removed.  The perlbot (bag of object tricks) document has been removed
+as well.
+
+=head3 Development Deltas
+
+The perldelta files for development releases are no longer packaged with
+perl.  These can still be found in the perl source code repository.
+
+=head1 Diagnostics
+
+The following additions or changes have been made to diagnostic output,
+including warnings and fatal error messages.  For the complete list of
+diagnostic messages, see L<perldiag>.
+
+=head2 New Diagnostics
+
+=head3 New Errors
+
+=over 4
+
+=item *
+
+L<Cannot set tied @DB::args|perldiag/"Cannot set tied @DB::args">
+
+This error occurs when C<caller> tries to set C<@DB::args> but finds it
+tied.  Before this error was added, it used to crash instead.
+
+=item *
+
+L<Cannot tie unreifiable array|perldiag/"Cannot tie unreifiable array">
+
+This error is part of a safety check that the C<tie> operator does before
+tying a special array like C<@_>.  You should never see this message.
+
+=item *
+
+L<&CORE::%s cannot be called directly|perldiag/"&CORE::%s cannot be called directly">
+
+This occurs when a subroutine in the C<CORE::> namespace is called
+with C<&foo> syntax or through a reference.  Some subroutines
+in this package cannot yet be called that way, but must be
+called as barewords.  See L</Subroutines in the C<CORE> namespace>, above.
+
+=item *
+
+L<Source filters apply only to byte streams|perldiag/"Source filters apply only to byte streams">
+
+This new error occurs when you try to activate a source filter (usually by
+loading a source filter module) within a string passed to C<eval> under the
+C<unicode_eval> feature.
+
+=back
+
+=head3 New Warnings
+
+=over 4
+
+=item *
+
+L<defined(@array) is deprecated|perldiag/"defined(@array) is deprecated">
+
+The long-deprecated C<defined(@array)> now also warns for package variables.
+Previously it issued a warning for lexical variables only.
+
+=item *
+
+L<length() used on %s|perldiag/length() used on %s>
+
+This new warning occurs when C<length> is used on an array or hash, instead
+of C<scalar(@array)> or C<scalar(keys %hash)>.
+
+=item *
+
+L<lvalue attribute %s already-defined subroutine|perldiag/"lvalue attribute %s already-defined subroutine">
+
+L<attributes.pm|attributes> now emits this warning when the :lvalue
+attribute is applied to a Perl subroutine that has already been defined, as
+doing so can have unexpected side-effects.
+
+=item *
+
+L<overload arg '%s' is invalid|perldiag/"overload arg '%s' is invalid">
+
+This warning, in the "overload" category, is produced when the overload
+pragma is given an argument it doesn't recognize, presumably a mistyped
+operator.
+
+=item *
+
+L<$[ used in %s (did you mean $] ?)|perldiag/"$[ used in %s (did you mean $] ?)">
+
+This new warning exists to catch the mistaken use of C<$[> in version
+checks.  C<$]>, not C<$[>, contains the version number.
+
+=item *
+
+L<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
+
+Assigning to a temporary scalar returned
+from an lvalue subroutine now produces this
+warning [perl #31946].
+
+=item *
+
+L<Useless use of \E|perldiag/"Useless use of \E">
+
+C<\E> does nothing unless preceded by C<\Q>, C<\L> or C<\U>.
+
+=back
+
+=head2 Removed Errors
+
+=over
+
+=item *
+
+"sort is now a reserved word"
+
+This error used to occur when C<sort> was called without arguments,
+followed by C<;> or C<)>.  (E.g., C<sort;> would die, but C<{sort}> was
+OK.)  This error message was added in Perl 3 to catch code like
+C<close(sort)> which would no longer work.  More than two decades later,
+this message is no longer appropriate.  Now C<sort> without arguments is
+always allowed, and returns an empty list, as it did in those cases
+where it was already allowed [perl #90030].
+
+=back
+
+=head2 Changes to Existing Diagnostics
+
+=over 4
+
+=item *
+
+The "Applying pattern match..." or similar warning produced when an
+array or hash is on the left-hand side of the C<=~> operator now
+mentions the name of the variable.
+
+=item *
+
+The "Attempt to free non-existent shared string" has had the spelling
+of "non-existent" corrected to "nonexistent".  It was already listed
+with the correct spelling in L<perldiag>.
+
+=item *
+
+The error messages for using C<default> and C<when> outside a
+topicalizer have been standardized to match the messages for C<continue>
+and loop controls.  They now read 'Can't "default" outside a
+topicalizer' and 'Can't "when" outside a topicalizer'.  They both used
+to be 'Can't use when() outside a topicalizer' [perl #91514].
+
+=item *
+
+The message, "Code point 0x%X is not Unicode, no properties match it;
+all inverse properties do" has been changed to "Code point 0x%X is not
+Unicode, all \p{} matches fail; all \P{} matches succeed".
+
+=item *
+
+Redefinition warnings for constant subroutines used to be mandatory,
+even occurring under C<no warnings>.  Now they respect the L<warnings>
+pragma.
+
+=item *
+
+The "glob failed" warning message is now suppressible via C<no warnings>
+[perl #111656].
+
+=item *
+
+The L<Invalid version format|perldiag/"Invalid version format (%s)">
+error message now says "negative version number" within the parentheses,
+rather than "non-numeric data", for negative numbers.
+
+=item *
+
+The two warnings
+L<Possible attempt to put comments in qw() list|perldiag/"Possible attempt to put comments in qw() list">
+and
+L<Possible attempt to separate words with commas|perldiag/"Possible attempt to separate words with commas">
+are no longer mutually exclusive: the same C<qw> construct may produce
+both.
+
+=item *
+
+The uninitialized warning for C<y///r> when C<$_> is implicit and
+undefined now mentions the variable name, just like the non-/r variation
+of the operator.
+
+=item *
+
+The 'Use of "foo" without parentheses is ambiguous' warning has been
+extended to apply also to user-defined subroutines with a (;$)
+prototype, and not just to built-in functions.
+
+=item *
+
+Warnings that mention the names of lexical (C<my>) variables with
+Unicode characters in them now respect the presence or absence of the
+C<:utf8> layer on the output handle, instead of outputting UTF8
+regardless.  Also, the correct names are included in the strings passed
+to C<$SIG{__WARN__}> handlers, rather than the raw UTF8 bytes.
+
+=back
+
+=head1 Utility Changes
+
+=head3 L<h2ph>
+
+=over 4
+
+=item *
+
+L<h2ph> used to generate code of the form
+
+  unless(defined(&FOO)) {
+    sub FOO () {42;}
+  }
+
+But the subroutine is a compile-time declaration, and is hence unaffected
+by the condition.  It has now been corrected to emit a string C<eval>
+around the subroutine [perl #99368].
+
+=back
+
+=head3 L<splain>
+
+=over 4
+
+=item *
+
+F<splain> no longer emits backtraces with the first line number repeated.
+
+This:
+
+    Uncaught exception from user code:
+            Cannot fwiddle the fwuddle at -e line 1.
+     at -e line 1
+            main::baz() called at -e line 1
+            main::bar() called at -e line 1
+            main::foo() called at -e line 1
+
+has become this:
+
+    Uncaught exception from user code:
+            Cannot fwiddle the fwuddle at -e line 1.
+            main::baz() called at -e line 1
+            main::bar() called at -e line 1
+            main::foo() called at -e line 1
+
+=item *
+
+Some error messages consist of multiple lines that are listed as separate
+entries in L<perldiag>.  splain has been taught to find the separate
+entries in these cases, instead of simply failing to find the message.
+
+=back
+
+=head3 L<zipdetails>
+
+=over 4
+
+=item *
+
+This is a new utility, included as part of an
+L<IO::Compress::Base> upgrade.
+
+L<zipdetails> displays information about the internal record structure
+of the zip file.  It is not concerned with displaying any details of
+the compressed data stored in the zip file.
+
+=back
+
+=head1 Configuration and Compilation
+
+=over 4
+
+=item *
+
+F<regexp.h> has been modified for compatibility with GCC's B<-Werror>
+option, as used by some projects that include perl's header files (5.14.1).
+
+=item *
+
+C<USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}> have been added the output of perl -V
+as they have affect the behavior of the interpreter binary (albeit
+in only a small area).
+
+=item *
+
+The code and tests for L<IPC::Open2> have been moved from F<ext/IPC-Open2>
+into F<ext/IPC-Open3>, as C<IPC::Open2::open2()> is implemented as a thin
+wrapper around C<IPC::Open3::_open3()>, and hence is very tightly coupled to
+it.
+
+=item *
+
+The magic types and magic vtables are now generated from data in a new script
+F<regen/mg_vtable.pl>, instead of being maintained by hand.  As different
+EBCDIC variants can't agree on the code point for '~', the character to code
+point conversion is done at build time by F<generate_uudmap> to a new generated
+header F<mg_data.h>.  C<PL_vtbl_bm> and C<PL_vtbl_fm> are now defined by the
+pre-processor as C<PL_vtbl_regexp>, instead of being distinct C variables.
+C<PL_vtbl_sig> has been removed.
+
+=item *
+
+Building with C<-DPERL_GLOBAL_STRUCT> works again.  This configuration is not
+generally used.
+
+=item *
+
+Perl configured with I<MAD> now correctly frees C<MADPROP> structures when
+OPs are freed.  C<MADPROP>s are now allocated with C<PerlMemShared_malloc()>
+
+=item *
+
+F<makedef.pl> has been refactored.  This should have no noticeable affect on
+any of the platforms that use it as part of their build (AIX, VMS, Win32).
+
+=item *
+
+C<useperlio> can no longer be disabled.
+
+=item *
+
+The file F<global.sym> is no longer needed, and has been removed.  It
+contained a list of all exported functions, one of the files generated by
+F<regen/embed.pl> from data in F<embed.fnc> and F<regen/opcodes>.  The code
+has been refactored so that the only user of F<global.sym>, F<makedef.pl>,
+now reads F<embed.fnc> and F<regen/opcodes> directly, removing the need to
+store the list of exported functions in an intermediate file.
+
+As F<global.sym> was never installed, this change should not be visible
+outside the build process.
+
+=item *
+
+F<pod/buildtoc>, used by the build process to build L<perltoc>, has been
+refactored and simplified.  It now contains only code to build L<perltoc>;
+the code to regenerate Makefiles has been moved to F<Porting/pod_rules.pl>.
+It's a bug if this change has any material effect on the build process.
+
+=item *
+
+F<pod/roffitall> is now built by F<pod/buildtoc>, instead of being
+shipped with the distribution.  Its list of manpages is now generated
+(and therefore current).  See also RT #103202 for an unresolved related
+issue.
+
+=item *
+
+The man page for C<XS::Typemap> is no longer installed.  C<XS::Typemap>
+is a test module which is not installed, hence installing its
+documentation makes no sense.
+
+=item *
+
+The -Dusesitecustomize and -Duserelocatableinc options now work
+together properly.
+
+=back
+
+=head1 Platform Support
+
+=head2 Platform-Specific Notes
+
+=head3 Cygwin
+
+=over 4
+
+=item *
+
+Since version 1.7, Cygwin supports native UTF-8 paths.  If Perl is built
+under that environment, directory and filenames will be UTF-8 encoded.
+
+=item *
+
+Cygwin does not initialize all original Win32 environment variables.  See
+F<README.cygwin> for a discussion of the newly-added
+C<Cygwin::sync_winenv()> function [perl #110190] and for
+further links.
+
+=back
+
+=head3 HP-UX
+
+=over 4
+
+=item *
+
+HP-UX PA-RISC/64 now supports gcc-4.x
+
+A fix to correct the socketsize now makes the test suite pass on HP-UX
+PA-RISC for 64bitall builds. (5.14.2)
+
+=back
+
+=head3 VMS
+
+=over 4
+
+=item *
+
+Remove unnecessary includes, fix miscellaneous compiler warnings and
+close some unclosed comments on F<vms/vms.c>.
+
+=item *
+
+Remove sockadapt layer from the VMS build.
+
+=item *
+
+Explicit support for VMS versions before v7.0 and DEC C versions
+before v6.0 has been removed.
+
+=item *
+
+Since Perl 5.10.1, the home-grown C<stat> wrapper has been unable to
+distinguish between a directory name containing an underscore and an
+otherwise-identical filename containing a dot in the same position
+(e.g., t/test_pl as a directory and t/test.pl as a file).  This problem
+has been corrected.
+
+=item *
+
+The build on VMS now permits names of the resulting symbols in C code for
+Perl longer than 31 characters.  Symbols like
+C<Perl__it_was_the_best_of_times_it_was_the_worst_of_times> can now be
+created freely without causing the VMS linker to seize up.
+
+=back
+
+=head3 GNU/Hurd
+
+=over 4
+
+=item *
+
+Numerous build and test failures on GNU/Hurd have been resolved with hints
+for building DBM modules, detection of the library search path, and enabling
+of large file support.
+
+=back
+
+=head3 OpenVOS
+
+=over 4
+
+=item *
+
+Perl is now built with dynamic linking on OpenVOS, the minimum supported
+version of which is now Release 17.1.0.
+
+=back
+
+=head3 SunOS
+
+The CC workshop C++ compiler is now detected and used on systems that ship
+without cc.
+
+=head1 Internal Changes
+
+=over 4
+
+=item *
+
+The compiled representation of formats is now stored via the C<mg_ptr> of
+their C<PERL_MAGIC_fm>.  Previously it was stored in the string buffer,
+beyond C<SvLEN()>, the regular end of the string.  C<SvCOMPILED()> and
+C<SvCOMPILED_{on,off}()> now exist solely for compatibility for XS code.
+The first is always 0, the other two now no-ops. (5.14.1)
+
+=item *
+
+Some global variables have been marked C<const>, members in the interpreter
+structure have been re-ordered, and the opcodes have been re-ordered.  The
+op C<OP_AELEMFAST> has been split into C<OP_AELEMFAST> and C<OP_AELEMFAST_LEX>.
+
+=item *
+
+When empting a hash of its elements (e.g., via undef(%h), or %h=()), HvARRAY
+field is no longer temporarily zeroed.  Any destructors called on the freed
+elements see the remaining elements.  Thus, %h=() becomes more like
+C<delete $h{$_} for keys %h>.
+
+=item *
+
+Boyer-Moore compiled scalars are now PVMGs, and the Boyer-Moore tables are now
+stored via the mg_ptr of their C<PERL_MAGIC_bm>.
+Previously they were PVGVs, with the tables stored in
+the string buffer, beyond C<SvLEN()>.  This eliminates
+the last place where the core stores data beyond C<SvLEN()>.
+
+=item *
+
+Simplified logic in C<Perl_sv_magic()> introduces a small change of
+behavior for error cases involving unknown magic types.  Previously, if
+C<Perl_sv_magic()> was passed a magic type unknown to it, it would
+
+=over
+
+=item 1.
+
+Croak "Modification of a read-only value attempted" if read only
+
+=item 2.
+
+Return without error if the SV happened to already have this magic
+
+=item 3.
+
+otherwise croak "Don't know how to handle magic of type \\%o"
+
+=back
+
+Now it will always croak "Don't know how to handle magic of type \\%o", even
+on read-only values, or SVs which already have the unknown magic type.
+
+=item *
+
+The experimental C<fetch_cop_label> function has been renamed to
+C<cop_fetch_label>.
+
+=item *
+
+The C<cop_store_label> function has been added to the API, but is
+experimental.
+
+=item *
+
+F<embedvar.h> has been simplified, and one level of macro indirection for
+PL_* variables has been removed for the default (non-multiplicity)
+configuration.  PERLVAR*() macros now directly expand their arguments to
+tokens such as C<PL_defgv>, instead of expanding to C<PL_Idefgv>, with
+F<embedvar.h> defining a macro to map C<PL_Idefgv> to C<PL_defgv>.  XS code
+which has unwarranted chumminess with the implementation may need updating.
+
+=item *
+
+An API has been added to explicitly choose whether to export XSUB
+symbols.  More detail can be found in the comments for commit e64345f8.
+
+=item *
+
+The C<is_gv_magical_sv> function has been eliminated and merged with
+C<gv_fetchpvn_flags>.  It used to be called to determine whether a GV
+should be autovivified in rvalue context.  Now it has been replaced with a
+new C<GV_ADDMG> flag (not part of the API).
+
+=item *
+
+The returned code point from the function C<utf8n_to_uvuni()>
+when the input is malformed UTF-8, malformations are allowed, and
+C<utf8> warnings are off is now the Unicode REPLACEMENT CHARACTER
+whenever the malformation is such that no well-defined code point can be
+computed.  Previously the returned value was essentially garbage.  The
+only malformations that have well-defined values are a zero-length
+string (0 is the return), and overlong UTF-8 sequences.
+
+=item *
+
+Padlists are now marked C<AvREAL>; i.e., reference-counted.  They have
+always been reference-counted, but were not marked real, because F<pad.c>
+did its own clean-up, instead of using the usual clean-up code in F<sv.c>.
+That caused problems in thread cloning, so now the C<AvREAL> flag is on,
+but is turned off in F<pad.c> right before the padlist is freed (after
+F<pad.c> has done its custom freeing of the pads).
+
+=item *
+
+All C files that make up the Perl core have been converted to UTF-8.
+
+=item *
+
+These new functions have been added as part of the work on Unicode symbols:
+
+    HvNAMELEN
+    HvNAMEUTF8
+    HvENAMELEN
+    HvENAMEUTF8
+    gv_init_pv
+    gv_init_pvn
+    gv_init_pvsv
+    gv_fetchmeth_pv
+    gv_fetchmeth_pvn
+    gv_fetchmeth_sv
+    gv_fetchmeth_pv_autoload
+    gv_fetchmeth_pvn_autoload
+    gv_fetchmeth_sv_autoload
+    gv_fetchmethod_pv_flags
+    gv_fetchmethod_pvn_flags
+    gv_fetchmethod_sv_flags
+    gv_autoload_pv
+    gv_autoload_pvn
+    gv_autoload_sv
+    newGVgen_flags
+    sv_derived_from_pv
+    sv_derived_from_pvn
+    sv_derived_from_sv
+    sv_does_pv
+    sv_does_pvn
+    sv_does_sv
+    whichsig_pv
+    whichsig_pvn
+    whichsig_sv
+    newCONSTSUB_flags
+
+The gv_fetchmethod_*_flags functions, like gv_fetchmethod_flags, are
+experimental and may change in a future release.
+
+=item *
+
+The following functions were added.  These are I<not> part of the API:
+
+    GvNAMEUTF8
+    GvENAMELEN
+    GvENAME_HEK
+    CopSTASH_flags
+    CopSTASH_flags_set
+    PmopSTASH_flags
+    PmopSTASH_flags_set
+    sv_sethek
+    HEKfARG
+
+There is also a C<HEKf> macro corresponding to C<SVf>, for
+interpolating HEKs in formatted strings.
+
+=item *
+
+C<sv_catpvn_flags> takes a couple of new internal-only flags,
+C<SV_CATBYTES> and C<SV_CATUTF8>, which tell it whether the char array to
+be concatenated is UTF8.  This allows for more efficient concatenation than
+creating temporary SVs to pass to C<sv_catsv>.
+
+=item *
+
+For XS AUTOLOAD subs, $AUTOLOAD is set once more, as it was in 5.6.0.  This
+is in addition to setting C<SvPVX(cv)>, for compatibility with 5.8 to 5.14.
+See L<perlguts/Autoloading with XSUBs>.
+
+=item *
+
+Perl now checks whether the array (the linearized isa) returned by a MRO
+plugin begins with the name of the class itself, for which the array was
+created, instead of assuming that it does.  This prevents the first element
+from being skipped during method lookup.  It also means that
+C<mro::get_linear_isa> may return an array with one more element than the
+MRO plugin provided [perl #94306].
+
+=item *
+
+C<PL_curstash> is now reference-counted.
+
+=item *
+
+There are now feature bundle hints in C<PL_hints> (C<$^H>) that version
+declarations use, to avoid having to load F<feature.pm>.  One setting of
+the hint bits indicates a "custom" feature bundle, which means that the
+entries in C<%^H> still apply.  F<feature.pm> uses that.
+
+The C<HINT_FEATURE_MASK> macro is defined in F<perl.h> along with other
+hints.  Other macros for setting and testing features and bundles are in
+the new F<feature.h>.  C<FEATURE_IS_ENABLED> (which has moved to
+F<feature.h>) is no longer used throughout the codebase, but more specific
+macros, e.g., C<FEATURE_SAY_IS_ENABLED>, that are defined in F<feature.h>.
+
+=item *
+
+F<lib/feature.pm> is now a generated file, created by the new
+F<regen/feature.pl> script, which also generates F<feature.h>.
+
+=item *
+
+Tied arrays are now always C<AvREAL>.  If C<@_> or C<DB::args> is tied, it
+is reified first, to make sure this is always the case.
+
+=item *
+
+Two new functions C<utf8_to_uvchr_buf()> and C<utf8_to_uvuni_buf()> have
+been added.  These are the same as C<utf8_to_uvchr> and
+C<utf8_to_uvuni> (which are now deprecated), but take an extra parameter
+that is used to guard against reading beyond the end of the input
+string.
+See L<perlapi/utf8_to_uvchr_buf> and L<perlapi/utf8_to_uvuni_buf>.
+
+=item *
+
+The regular expression engine now does TRIE case insensitive matches
+under Unicode. This may change the output of C<< use re 'debug'; >>,
+and will speed up various things.
+
+=item *
+
+There is a new C<wrap_op_checker()> function, which provides a thread-safe
+alternative to writing to C<PL_check> directly.
+
+=back
+
+=head1 Selected Bug Fixes
+
+=head2 Array and hash
+
+=over
+
+=item *
+
+A bug has been fixed that would cause a "Use of freed value in iteration"
+error if the next two hash elements that would be iterated over are
+deleted [perl #85026]. (5.14.1)
+
+=item *
+
+Deleting the current hash iterator (the hash element that would be returned
+by the next call to C<each>) in void context used not to free it
+[perl #85026].
+
+=item *
+
+Deletion of methods via C<delete $Class::{method}> syntax used to update
+method caches if called in void context, but not scalar or list context.
+
+=item *
+
+When hash elements are deleted in void context, the internal hash entry is
+now freed before the value is freed, to prevent destructors called by that
+latter freeing from seeing the hash in an inconsistent state.  It was
+possible to cause double-frees if the destructor freed the hash itself
+[perl #100340].
+
+=item *
+
+A C<keys> optimization in Perl 5.12.0 to make it faster on empty hashes
+caused C<each> not to reset the iterator if called after the last element
+was deleted.
+
+=item *
+
+Freeing deeply nested hashes no longer crashes [perl #44225].
+
+=item *
+
+It is possible from XS code to create hashes with elements that have no
+values.  The hash element and slice operators used to crash
+when handling these in lvalue context.  They now
+produce a "Modification of non-creatable hash value attempted" error
+message.
+
+=item *
+
+If list assignment to a hash or array triggered destructors that freed the
+hash or array itself, a crash would ensue.  This is no longer the case
+[perl #107440].
+
+=item *
+
+It used to be possible to free the typeglob of a localized array or hash
+(e.g., C<local @{"x"}; delete $::{x}>), resulting in a crash on scope exit.
+
+=item *
+
+Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
+element that is a glob copy no longer causes the next assignment to it to
+corrupt the glob (5.14.2), and unlocking a hash element that holds a
+copy-on-write scalar no longer causes modifications to that scalar to
+modify other scalars that were sharing the same string buffer.
+
+=back
+
+=head2 C API fixes
+
+=over
+
+=item *
+
+The C<newHVhv> XS function now works on tied hashes, instead of crashing or
+returning an empty hash.
+
+=item *
+
+The C<SvIsCOW> C macro now returns false for read-only copies of typeglobs,
+such as those created by:
+
+  $hash{elem} = *foo;
+  Hash::Util::lock_value %hash, 'elem';
+
+It used to return true.
+
+=item *
+
+The C<SvPVutf8> C function no longer tries to modify its argument,
+resulting in errors [perl #108994].
+
+=item *
+
+C<SvPVutf8> now works properly with magical variables.
+
+=item *
+
+C<SvPVbyte> now works properly non-PVs.
+
+=item *
+
+When presented with malformed UTF-8 input, the XS-callable functions
+C<is_utf8_string()>, C<is_utf8_string_loc()>, and
+C<is_utf8_string_loclen()> could read beyond the end of the input
+string by up to 12 bytes.  This no longer happens.  [perl #32080].
+However, currently, C<is_utf8_char()> still has this defect, see
+L</is_utf8_char()> above.
+
+=item *
+
+The C-level C<pregcomp> function could become confused about whether the
+pattern was in UTF8 if the pattern was an overloaded, tied, or otherwise
+magical scalar [perl #101940].
+
+=back
+
+=head2 Compile-time hints
+
+=over
+
+=item *
+
+Tying C<%^H> no longer causes perl to crash or ignore the contents of
+C<%^H> when entering a compilation scope [perl #106282].
+
+=item *
+
+C<eval $string> and C<require> used not to
+localize C<%^H> during compilation if it
+was empty at the time the C<eval> call itself was compiled.  This could
+lead to scary side effects, like C<use re "/m"> enabling other flags that
+the surrounding code was trying to enable for its caller [perl #68750].
+
+=item *
+
+C<eval $string> and C<require> no longer localize hints (C<$^H> and C<%^H>)
+at run time, but only during compilation of the $string or required file.
+This makes C<BEGIN { $^H{foo}=7 }> equivalent to
+C<BEGIN { eval '$^H{foo}=7' }> [perl #70151].
+
+=item *
+
+Creating a BEGIN block from XS code (via C<newXS> or C<newATTRSUB>) would,
+on completion, make the hints of the current compiling code the current
+hints.  This could cause warnings to occur in a non-warning scope.
+
+=back
+
+=head2 Copy-on-write scalars
+
+Copy-on-write or shared hash key scalars
+were introduced in 5.8.0, but most Perl code
+did not encounter them (they were used mostly internally).  Perl
+5.10.0 extended them, such that assigning C<__PACKAGE__> or a
+hash key to a scalar would make it copy-on-write.  Several parts
+of Perl were not updated to account for them, but have now been fixed.
+
+=over
+
+=item *
+
+C<utf8::decode> had a nasty bug that would modify copy-on-write scalars'
+string buffers in place (i.e., skipping the copy).  This could result in
+hashes having two elements with the same key [perl #91834]. (5.14.2)
+
+=item *
+
+Lvalue subroutines were not allowing COW scalars to be returned.  This was
+fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0, but list context
+was not fixed until this release.
+
+=item *
+
+Elements of restricted hashes (see the L<fields> pragma) containing
+copy-on-write values couldn't be deleted, nor could such hashes be cleared
+(C<%hash = ()>). (5.14.2)
+
+=item *
+
+Localizing a tied variable used to make it read-only if it contained a
+copy-on-write string. (5.14.2)
+
+=item *
+
+Assigning a copy-on-write string to a stash
+element no longer causes a double free.  Regardless of this change, the
+results of such assignments are still undefined.
+
+=item *
+
+Assigning a copy-on-write string to a tied variable no longer stops that
+variable from being tied if it happens to be a PVMG or PVLV internally.
+
+=item *
+
+Doing a substitution on a tied variable returning a copy-on-write
+scalar used to cause an assertion failure or an "Attempt to free
+nonexistent shared string" warning.
+
+=item *
+
+This one is a regression from 5.12: In 5.14.0, the bitwise assignment
+operators C<|=>, C<^=> and C<&=> started leaving the left-hand side
+undefined if it happened to be a copy-on-write string [perl #108480].
+
+=item *
+
+L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
+See L</Updated Modules and Pragmata>, above.
+
+=back
+
+=head2 The debugger
+
+=over
+
+=item *
+
+F<dumpvar.pl>, and therefore the C<x> command in the debugger, have been
+fixed to handle objects blessed into classes whose names contain "=".  The
+contents of such objects used not to be dumped [perl #101814].
+
+=item *
+
+The "R" command for restarting a debugger session has been fixed to work on
+Windows, or any other system lacking a C<POSIX::_SC_OPEN_MAX> constant
+[perl #87740].
+
+=item *
+
+The C<#line 42 foo> directive used not to update the arrays of lines used
+by the debugger if it occurred in a string eval.  This was partially fixed
+in 5.14, but it worked only for a single C<#line 42 foo> in each eval.  Now
+it works for multiple.
+
+=item *
+
+When subroutine calls are intercepted by the debugger, the name of the
+subroutine or a reference to it is stored in C<$DB::sub>, for the debugger
+to access.  Sometimes (such as C<$foo = *bar; undef *bar; &$foo>)
+C<$DB::sub> would be set to a name that could not be used to find the
+subroutine, and so the debugger's attempt to call it would fail.  Now the
+check to see whether a reference is needed is more robust, so those
+problems should not happen anymore [rt.cpan.org #69862].
+
+=item *
+
+Every subroutine has a filename associated with it that the debugger uses.
+The one associated with constant subroutines used to be misallocated when
+cloned under threads.  Consequently, debugging threaded applications could
+result in memory corruption [perl #96126].
+
+=back
+
+=head2 Dereferencing operators
+
+=over
+
+=item *
+
+C<defined(${"..."})>, C<defined(*{"..."})>, etc., used to
+return true for most, but not all built-in variables, if
+they had not been used yet.  This bug affected C<${^GLOBAL_PHASE}> and
+C<${^UTF8CACHE}>, among others.  It also used to return false if the
+package name was given as well (C<${"::!"}>) [perl #97978, #97492].
+
+=item *
+
+Perl 5.10.0 introduced a similar bug: C<defined(*{"foo"})> where "foo"
+represents the name of a built-in global variable used to return false if
+the variable had never been used before, but only on the I<first> call.
+This, too, has been fixed.
+
+=item *
+
+Since 5.6.0, C<*{ ... }> has been inconsistent in how it treats undefined
+values.  It would die in strict mode or lvalue context for most undefined
+values, but would be treated as the empty string (with a warning) for the
+specific scalar return by C<undef()> (C<&PL_sv_undef> internally).  This
+has been corrected.  C<undef()> is now treated like other undefined
+scalars, as in Perl 5.005.
+
+=back
+
+=head2 Filehandle, last-accessed
+
+Perl has an internal variable that stores the last filehandle to be
+accessed.  It is used by C<$.> and by C<tell> and C<eof> without
+arguments.
+
+=over
+
+=item *
+
+It used to be possible to set this internal variable to a glob copy and
+then modify that glob copy to be something other than a glob, and still
+have the last-accessed filehandle associated with the variable after
+assigning a glob to it again:
+
+    my $foo = *STDOUT;  # $foo is a glob copy
+    <$foo>;             # $foo is now the last-accessed handle
+    $foo = 3;           # no longer a glob
+    $foo = *STDERR;     # still the last-accessed handle
+
+Now the C<$foo = 3> assignment unsets that internal variable, so there
+is no last-accessed filehandle, just as if C<< <$foo> >> had never
+happened.
+
+This also prevents some unrelated handle from becoming the last-accessed
+handle if $foo falls out of scope and the same internal SV gets used for
+another handle [perl #97988].
+
+=item *
+
+A regression in 5.14 caused these statements not to set that internal
+variable:
+
+    my $fh = *STDOUT;
+    tell $fh;
+    eof  $fh;
+    seek $fh, 0,0;
+    tell     *$fh;
+    eof      *$fh;
+    seek     *$fh, 0,0;
+    readline *$fh;
+
+This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
+is not clear how to fix it [perl #106536].
+
+=back
+
+=head2 Filetests and C<stat>
+
+The term "filetests" refers to the operators that consist of a hyphen
+followed by a single letter: C<-r>, C<-x>, C<-M>, etc.  The term "stacked"
+when applied to filetests means followed by another filetest operator
+sharing the same operand, as in C<-r -x -w $fooo>.
+
+=over
+
+=item *
+
+C<stat> produces more consistent warnings.  It no longer warns for "_"
+[perl #71002] and no longer skips the warning at times for other unopened
+handles.  It no longer warns about an unopened handle when the operating
+system's C<fstat> function fails.
+
+=item *
+
+C<stat> would sometimes return negative numbers for large inode numbers,
+because it was using the wrong internal C type. [perl #84590]
+
+=item *
+
+C<lstat> is documented to fall back to C<stat> (with a warning) when given
+a filehandle.  When passed an IO reference, it was actually doing the
+equivalent of S<C<stat _>> and ignoring the handle.
+
+=item *
+
+C<-T _> with no preceding C<stat> used to produce a
+confusing "uninitialized" warning, even though there
+is no visible uninitialized value to speak of.
+
+=item *
+
+C<-T>, C<-B>, C<-l> and C<-t> now work
+when stacked with other filetest operators
+[perl #77388].
+
+=item *
+
+In 5.14.0, filetest ops (C<-r>, C<-x>, etc.) started calling FETCH on a
+tied argument belonging to the previous argument to a list operator, if
+called with a bareword argument or no argument at all.  This has been
+fixed, so C<push @foo, $tied, -r> no longer calls FETCH on C<$tied>.
+
+=item *
+
+In Perl 5.6, C<-l> followed by anything other than a bareword would treat
+its argument as a file name.  That was changed in 5.8 for glob references
+(C<\*foo>), but not for globs themselves (C<*foo>).  C<-l> started
+returning C<undef> for glob references without setting the last
+stat buffer that the "_" handle uses, but only if warnings
+were turned on.  With warnings off, it was the same as 5.6.
+In other words, it was simply buggy and inconsistent.  Now the 5.6
+behavior has been restored.
+
+=item *
+
+C<-l> followed by a bareword no longer "eats" the previous argument to
+the list operator in whose argument list it resides.  Hence,
+C<print "bar", -l foo> now actually prints "bar", because C<-l>
+on longer eats it.
+
+=item *
+
+Perl keeps several internal variables to keep track of the last stat
+buffer, from which file(handle) it originated, what type it was, and
+whether the last stat succeeded.
+
+There were various cases where these could get out of synch, resulting in
+inconsistent or erratic behavior in edge cases (every mention of C<-T>
+applies to C<-B> as well):
+
+=over
+
+=item *
+
+C<-T I<HANDLE>>, even though it does a C<stat>, was not resetting the last
+stat type, so an C<lstat _> following it would merrily return the wrong
+results.  Also, it was not setting the success status.
+
+=item *
+
+Freeing the handle last used by C<stat> or a filetest could result in
+S<C<-T _>> using an unrelated handle.
+
+=item *
+
+C<stat> with an IO reference would not reset the stat type or record the
+filehandle for S<C<-T _>> to use.
+
+=item *
+
+Fatal warnings could cause the stat buffer not to be reset
+for a filetest operator on an unopened filehandle or C<-l> on any handle.
+Fatal warnings also stopped C<-T> from setting C<$!>.
+
+=item *
+
+When the last stat was on an unreadable file, C<-T _> is supposed to
+return C<undef>, leaving the last stat buffer unchanged.  But it was
+setting the stat type, causing C<lstat _> to stop working.
+
+=item *
+
+C<-T I<FILENAME>> was not resetting the internal stat buffers for
+unreadable files.
+
+=back
+
+These have all been fixed.
+
+=back
+
+=head2 Formats
+
+=over
+
+=item *
+
+Several edge cases have been fixed with formats and C<formline>;
+in particular, where the format itself is potentially variable (such as
+with ties and overloading), and where the format and data differ in their
+encoding.  In both these cases, it used to possible for the output to be
+corrupted [perl #91032].
+
+=item *
+
+C<formline> no longer converts its argument into a string in-place.  So
+passing a reference to C<formline> no longer destroys the reference
+[perl #79532].
+
+=item *
+
+Assignment to C<$^A> (the format output accumulator) now recalculates
+the number of lines output.
+
+=back
+
+=head2 C<given> and C<when>
+
+=over
+
+=item *
+
+C<given> was not scoping its implicit $_ properly, resulting in memory
+leaks or "Variable is not available" warnings [perl #94682].
+
+=item *
+
+C<given> was not calling set-magic on the implicit lexical C<$_> that it
+uses.  This meant, for example, that C<pos> would be remembered from one
+execution of the same C<given> block to the next, even if the input were a
+different variable [perl #84526].
+
+=item *
+
+C<when> blocks are now capable of returning variables declared inside the
+enclosing C<given> block [perl #93548].
+
+=back
+
+=head2 The C<glob> operator
+
+=over
+
+=item *
+
+On OSes other than VMS, Perl's C<glob> operator (and the C<< <...> >> form)
+use L<File::Glob> underneath.  L<File::Glob> splits the pattern into words,
+before feeding each word to its C<bsd_glob> function.
+
+There were several inconsistencies in the way the split was done.  Now
+quotation marks (' and ") are always treated as shell-style word delimiters
+(that allow whitespace as part of a word) and backslashes are always
+preserved, unless they exist to escape quotation marks.  Before, those
+would only sometimes be the case, depending on whether the pattern
+contained whitespace.  Also, escaped whitespace at the end of the pattern
+is no longer stripped [perl #40470].
+
+=item *
+
+C<CORE::glob> now works as a way to call the default globbing function.  It
+used to respect overrides, despite the C<CORE::> prefix.
+
+=item *
+
+Under miniperl (used to configure modules when perl itself is built),
+C<glob> now clears %ENV before calling csh, since the latter croaks on some
+systems if it does not like the contents of the LS_COLORS environment
+variable [perl #98662].
+
+=back
+
+=head2 Lvalue subroutines
+
+=over
+
+=item *
+
+Explicit return now returns the actual argument passed to return, instead
+of copying it [perl #72724, #72706].
+
+=item *
+
+Lvalue subroutines used to enforce lvalue syntax (i.e., whatever can go on
+the left-hand side of C<=>) for the last statement and the arguments to
+return.  Since lvalue subroutines are not always called in lvalue context,
+this restriction has been lifted.
+
+=item *
+
+Lvalue subroutines are less restrictive about what values can be returned.
+It used to croak on values returned by C<shift> and C<delete> and from
+other subroutines, but no longer does so [perl #71172].
+
+=item *
+
+Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
+context.  All subroutines used to do this, but regular subs were fixed in
+Perl 5.8.2.  Now lvalue subroutines have been likewise fixed.
+
+=item *
+
+Autovivification now works on values returned from lvalue subroutines
+[perl #7946], as does returning C<keys> in lvalue context.
+
+=item *
+
+Lvalue subroutines used to copy their return values in rvalue context.  Not
+only was this a waste of CPU cycles, but it also caused bugs.  A C<($)>
+prototype would cause an lvalue sub to copy its return value [perl #51408],
+and C<while(lvalue_sub() =~ m/.../g) { ... }> would loop endlessly
+[perl #78680].
+
+=item *
+
+When called in potential lvalue context
+(e.g., subroutine arguments or a list
+passed to C<for>), lvalue subroutines used to copy
+any read-only value that was returned.  E.g., C< sub :lvalue { $] } >
+would not return C<$]>, but a copy of it.
+
+=item *
+
+When called in potential lvalue context, an lvalue subroutine returning
+arrays or hashes used to bind the arrays or hashes to scalar variables,
+resulting in bugs.  This was fixed in 5.14.0 if an array were the first
+thing returned from the subroutine (but not for C<$scalar, @array> or
+hashes being returned).  Now a more general fix has been applied
+[perl #23790].
+
+=item *
+
+Method calls whose arguments were all surrounded with C<my()> or C<our()>
+(as in C<< $object->method(my($a,$b)) >>) used to force lvalue context on
+the subroutine.  This would prevent lvalue methods from returning certain
+values.
+
+=item *
+
+Lvalue sub calls that are not determined to be such at compile time
+(C<&$name> or &{"name"}) are no longer exempt from strict refs if they
+occur in the last statement of an lvalue subroutine [perl #102486].
+
+=item *
+
+Sub calls whose subs are not visible at compile time, if
+they occurred in the last statement of an lvalue subroutine,
+would reject non-lvalue subroutines and die with "Can't modify non-lvalue
+subroutine call" [perl #102486].
+
+Non-lvalue sub calls whose subs I<are> visible at compile time exhibited
+the opposite bug.  If the call occurred in the last statement of an lvalue
+subroutine, there would be no error when the lvalue sub was called in
+lvalue context.  Perl would blindly assign to the temporary value returned
+by the non-lvalue subroutine.
+
+=item *
+
+C<AUTOLOAD> routines used to take precedence over the actual sub being
+called (i.e., when autoloading wasn't needed), for sub calls in lvalue or
+potential lvalue context, if the subroutine was not visible at compile
+time.
+
+=item *
+
+Applying the C<:lvalue> attribute to an XSUB or to an aliased subroutine
+stub with C<< sub foo :lvalue; >> syntax stopped working in Perl 5.12.
+This has been fixed.
+
+=item *
+
+Applying the :lvalue attribute to subroutine that is already defined does
+not work properly, as the attribute changes the way the sub is compiled.
+Hence, Perl 5.12 began warning when an attempt is made to apply the
+attribute to an already defined sub.  In such cases, the attribute is
+discarded.
+
+But the change in 5.12 missed the case where custom attributes are also
+present: that case still silently and ineffectively applied the attribute.
+That omission has now been corrected.  C<sub foo :lvalue :Whatever> (when
+C<foo> is already defined) now warns about the :lvalue attribute, and does
+not apply it.
+
+=item *
+
+A bug affecting lvalue context propagation through nested lvalue subroutine
+calls has been fixed.  Previously, returning a value in nested rvalue
+context would be treated as lvalue context by the inner subroutine call,
+resulting in some values (such as read-only values) being rejected.
+
+=back
+
+=head2 Overloading
+
+=over
+
+=item *
+
+Arithmetic assignment (C<$left += $right>) involving overloaded objects
+that rely on the 'nomethod' override no longer segfault when the left
+operand is not overloaded.
+
+=item *
+
+Errors that occur when methods cannot be found during overloading now
+mention the correct package name, as they did in 5.8.x, instead of
+erroneously mentioning the "overload" package, as they have since 5.10.0.
+
+=item *
+
+Undefining C<%overload::> no longer causes a crash.
+
+=back
+
+=head2 Prototypes of built-in keywords
+
+=over
+
+=item *
+
+The C<prototype> function no longer dies for the C<__FILE__>, C<__LINE__>
+and C<__PACKAGE__> directives.  It now returns an empty-string prototype
+for them, because they are syntactically indistinguishable from nullary
+functions like C<time>.
+
+=item *
+
+C<prototype> now returns C<undef> for all overridable infix operators,
+such as C<eq>, which are not callable in any way resembling functions.
+It used to return incorrect prototypes for some and die for others
+[perl #94984].
+
+=item *
+
+The prototypes of several built-in functions--C<getprotobynumber>, C<lock>,
+C<not> and C<select>--have been corrected, or at least are now closer to
+reality than before.
+
+=back
+
+=head2 Regular expressions
+
+=for comment Is it possible to merge some of these items?
+
+=over 4
+
+=item *
+
+C</[[:ascii:]]/> and C</[[:blank:]]/> now use locale rules under
+C<use locale> when the platform supports that.  Previously, they used
+the platform's native character set.
+
+=item *
+
+C<m/[[:ascii:]]/i> and C</\p{ASCII}/i> now match identically (when not
+under a differing locale).  This fixes a regression introduced in 5.14
+in which the first expression could match characters outside of ASCII,
+such as the KELVIN SIGN.
+
+=item *
+
+C</.*/g> would sometimes refuse to match at the end of a string that ends
+with "\n".  This has been fixed [perl #109206].
+
+=item *
+
+Starting with 5.12.0, Perl used to get its internal bookkeeping muddled up
+after assigning C<${ qr// }> to a hash element and locking it with
+L<Hash::Util>.  This could result in double frees, crashes, or erratic
+behavior.
+
+=item *
+
+The new (in 5.14.0) regular expression modifier C</a> when repeated like
+C</aa> forbids the characters outside the ASCII range that match
+characters inside that range from matching under C</i>.  This did not
+work under some circumstances, all involving alternation, such as:
+
+ "\N{KELVIN SIGN}" =~ /k|foo/iaa;
+
+succeeded inappropriately.  This is now fixed.
+
+=item *
+
+5.14.0 introduced some memory leaks in regular expression character
+classes such as C<[\w\s]>, which have now been fixed. (5.14.1)
+
+=item *
+
+An edge case in regular expression matching could potentially loop.
+This happened only under C</i> in bracketed character classes that have
+characters with multi-character folds, and the target string to match
+against includes the first portion of the fold, followed by another
+character that has a multi-character fold that begins with the remaining
+portion of the fold, plus some more.
+
+ "s\N{U+DF}" =~ /[\x{DF}foo]/i
+
+is one such case.  C<\xDF> folds to C<"ss">. (5.14.1)
+
+=item *
+
+A few characters in regular expression pattern matches did not
+match correctly in some circumstances, all involving C</i>.  The
+affected characters are:
+COMBINING GREEK YPOGEGRAMMENI,
+GREEK CAPITAL LETTER IOTA,
+GREEK CAPITAL LETTER UPSILON,
+GREEK PROSGEGRAMMENI,
+GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
+GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
+GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA,
+GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
+LATIN SMALL LETTER LONG S,
+LATIN SMALL LIGATURE LONG S T,
+and
+LATIN SMALL LIGATURE ST.
+
+=item *
+
+A memory leak regression in regular expression compilation
+under threading has been fixed.
+
+=item *
+
+A regression introduced in 5.14.0 has
+been fixed.  This involved an inverted
+bracketed character class in a regular expression that consisted solely
+of a Unicode property.  That property wasn't getting inverted outside the
+Latin1 range.
+
+=item *
+
+Three problematic Unicode characters now work better in regex pattern matching under C</i>.
+
+In the past, three Unicode characters:
+LATIN SMALL LETTER SHARP S,
+GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
+and
+GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
+along with the sequences that they fold to
+(including "ss" for LATIN SMALL LETTER SHARP S),
+did not properly match under C</i>.  5.14.0 fixed some of these cases,
+but introduced others, including a panic when one of the characters or
+sequences was used in the C<(?(DEFINE)> regular expression predicate.
+The known bugs that were introduced in 5.14 have now been fixed; as well
+as some other edge cases that have never worked until now.  These all
+involve using the characters and sequences outside bracketed character
+classes under C</i>.  This closes [perl #98546].
+
+There remain known problems when using certain characters with
+multi-character folds inside bracketed character classes, including such
+constructs as C<qr/[\N{LATIN SMALL LETTER SHARP}a-z]/i>.  These
+remaining bugs are addressed in [perl #89774].
+
+=item *
+
+RT #78266: The regex engine has been leaking memory when accessing
+named captures that weren't matched as part of a regex ever since 5.10
+when they were introduced; e.g., this would consume over a hundred MB of
+memory:
+
+    for (1..10_000_000) {
+        if ("foo" =~ /(foo|(?<capture>bar))?/) {
+            my $capture = $+{capture}
+        }
+    }
+    system "ps -o rss $$"'
+
+=item *
+
+In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
+opposite case.  This has been fixed [perl #101970].
+
+=item *
+
+A regular expression match with an overloaded object on the right-hand side
+would sometimes stringify the object too many times.
+
+=item *
+
+A regression has been fixed that was introduced in 5.14, in C</i>
+regular expression matching, in which a match improperly fails if the
+pattern is in UTF-8, the target string is not, and a Latin-1 character
+precedes a character in the string that should match the pattern.
+[perl #101710]
+
+=item *
+
+In case-insensitive regular expression pattern matching, no longer on
+UTF-8 encoded strings does the scan for the start of match look only at
+the first possible position.  This caused matches such as
+C<"f\x{FB00}" =~ /ff/i> to fail.
+
+=item *
+
+The regexp optimizer no longer crashes on debugging builds when merging
+fixed-string nodes with inconvenient contents.
+
+=item *
+
+A panic involving the combination of the regular expression modifiers
+C</aa> and the C<\b> escape sequence introduced in 5.14.0 has been
+fixed [perl #95964]. (5.14.2)
+
+=item *
+
+The combination of the regular expression modifiers C</aa> and the C<\b>
+and C<\B> escape sequences did not work properly on UTF-8 encoded
+strings.  All non-ASCII characters under C</aa> should be treated as
+non-word characters, but what was happening was that Unicode rules were
+used to determine wordness/non-wordness for non-ASCII characters.  This
+is now fixed [perl #95968].
+
+=item *
+
+C<< (?foo: ...) >> no longer loses passed in character set.
+
+=item *
+
+The trie optimization used to have problems with alternations containing
+an empty C<(?:)>, causing C<< "x" =~ /\A(?>(?:(?:)A|B|C?x))\z/ >> not to
+match, whereas it should [perl #111842].
+
+=item *
+
+Use of lexical (C<my>) variables in code blocks embedded in regular
+expressions will no longer result in memory corruption or crashes.
+
+Nevertheless, these code blocks are still experimental, as there are still
+problems with the wrong variables being closed over (in loops for instance)
+and with abnormal exiting (e.g., C<die>) causing memory corruption.
+
+=item *
+
+The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
+cause a panic error message when trying to match at the end of the
+string [perl #96354].
+
+=item *
+
+The abbreviations for four C1 control characters C<MW> C<PM>, C<RI>, and
+C<ST> were previously unrecognized by C<\N{}>, vianame(), and
+string_vianame().
+
+=item *
+
+Mentioning a variable named "&" other than C<$&> (i.e., C<@&> or C<%&>) no
+longer stops C<$&> from working.  The same applies to variables named "'"
+and "`" [perl #24237].
+
+=item *
+
+Creating a C<UNIVERSAL::AUTOLOAD> sub no longer stops C<%+>, C<%-> and
+C<%!> from working some of the time [perl #105024].
+
+=back
+
+=head2 Smartmatching
+
+=over
+
+=item *
+
+C<~~> now correctly handles the precedence of Any~~Object, and is not tricked
+by an overloaded object on the left-hand side.
+
+=item *
+
+In Perl 5.14.0, C<$tainted ~~ @array> stopped working properly.  Sometimes
+it would erroneously fail (when C<$tainted> contained a string that occurs
+in the array I<after> the first element) or erroneously succeed (when
+C<undef> occurred after the first element) [perl #93590].
+
+=back
+
+=head2 The C<sort> operator
+
+=over
+
+=item *
+
+C<sort> was not treating C<sub {}> and C<sub {()}> as equivalent when
+such a sub was provided as the comparison routine.  It used to croak on
+C<sub {()}>.
+
+=item *
+
+C<sort> now works once more with custom sort routines that are XSUBs.  It
+stopped working in 5.10.0.
+
+=item *
+
+C<sort> with a constant for a custom sort routine, although it produces
+unsorted results, no longer crashes.  It started crashing in 5.10.0.
+
+=item *
+
+Warnings emitted by C<sort> when a custom comparison routine returns a
+non-numeric value now contain "in sort" and show the line number of the
+C<sort> operator, rather than the last line of the comparison routine.  The
+warnings also now occur only if warnings are enabled in the scope where
+C<sort> occurs.  Previously the warnings would occur if enabled in the
+comparison routine's scope.
+
+=item *
+
+C<< sort { $a <=> $b } >>, which is optimized internally, now produces
+"uninitialized" warnings for NaNs (not-a-number values), since C<< <=> >>
+returns C<undef> for those.  This brings it in line with
+S<C<< sort { 1; $a <=> $b } >>> and other more complex cases, which are not
+optimized [perl #94390].
+
+=back
+
+=head2 The C<substr> operator
+
+=over
+
+=item *
+
+Tied (and otherwise magical) variables are no longer exempt from the
+"Attempt to use reference as lvalue in substr" warning.
+
+=item *
+
+That warning now occurs when the returned lvalue is assigned to, not
+when C<substr> itself is called.  This makes a difference only if the
+return value of C<substr> is referenced and later assigned to.
+
+=item *
+
+Passing a substring of a read-only value or a typeglob to a function
+(potential lvalue context) no longer causes an immediate "Can't coerce"
+or "Modification of a read-only value" error.  That error occurs only 
+if the passed value is assigned to.
+
+The same thing happens with the "substr outside of string" error.  If
+the lvalue is only read from, not written to, it is now just a warning, as
+with rvalue C<substr>.
+
+=item *
+
+C<substr> assignments no longer call FETCH twice if the first argument
+is a tied variable, just once.
+
+=back
+
+=head2 Support for embedded nulls
+
+Some parts of Perl did not work correctly with nulls (C<chr 0>) embedded in
+strings.  That meant that, for instance, C<< $m = "a\0b"; foo->$m >> would
+call the "a" method, instead of the actual method name contained in $m.
+These parts of perl have been fixed to support nulls:
+
+=over
+
+=item *
+
+Method names
+
+=item *
+
+Typeglob names (including filehandle and subroutine names)
+
+=item *
+
+Package names, including the return value of C<ref()>
+
+=item *
+
+Typeglob elements (C<*foo{"THING\0stuff"}>)
+
+=item *
+
+Signal names
+
+=item *
+
+Various warnings and error messages that mention variable names or values,
+methods, etc.
+
+=back
+
+One side effect of these changes is that blessing into "\0" no longer
+causes C<ref()> to return false.
+
+=head2 Threading bugs
+
+=over
+
+=item *
+
+Typeglobs returned from threads are no longer cloned if the parent thread
+already has a glob with the same name.  This means that returned
+subroutines will now assign to the right package variables [perl #107366].
+
+=item *
+
+Some cases of threads crashing due to memory allocation during cloning have
+been fixed [perl #90006].
+
+=item *
+
+Thread joining would sometimes emit "Attempt to free unreferenced scalar"
+warnings if C<caller> had been used from the C<DB> package before thread
+creation [perl #98092].
+
+=item *
+
+Locking a subroutine (via C<lock &sub>) is no longer a compile-time error
+for regular subs.  For lvalue subroutines, it no longer tries to return the
+sub as a scalar, resulting in strange side effects like C<ref \$_>
+returning "CODE" in some instances.
+
+C<lock &sub> is now a run-time error if L<threads::shared> is loaded (a
+no-op otherwise), but that may be rectified in a future version.
+
+=back
+
+=head2 Tied variables
+
+=over
+
+=item *
+
+Various cases in which FETCH was being ignored or called too many times
+have been fixed:
+
+=over
+
+=item *
+
+C<PerlIO::get_layers> [perl #97956]
+
+=item *
+
+C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> when $tied holds a
+reference.
+
+=item *
+
+When calling C<local $_> [perl #105912]
+
+=item *
+
+Four-argument C<select>
+
+=item *
+
+A tied buffer passed to C<sysread>
+
+=item *
+
+C<< $tied .= <> >>
+
+=item *
+
+Three-argument C<open>, the third being a tied file handle
+(as in C<< open $fh, ">&", $tied >>)
+
+=item *
+
+C<sort> with a reference to a tied glob for the comparison routine.
+
+=item *
+
+C<..> and C<...> in list context [perl #53554].
+
+=item *
+
+C<${$tied}>, C<@{$tied}>, C<%{$tied}> and C<*{$tied}> where the tied
+variable returns a string (C<&{}> was unaffected)
+
+=item *
+
+C<defined ${ $tied_variable }>
+
+=item *
+
+Various functions that take a filehandle argument in rvalue context
+(C<close>, C<readline>, etc.) [perl #97482]
+
+=item *
+
+Some cases of dereferencing a complex expression, such as
+C<${ (), $tied } = 1>, used to call C<FETCH> multiple times, but now call
+it once.
+
+=item *
+
+C<$tied-E<gt>method> where $tied returns a package name--even resulting in
+a failure to call the method, due to memory corruption
+
+=item *
+
+Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied>
+
+=item *
+
+C<chdir>, C<chmod>, C<chown>, C<utime>, C<truncate>, C<stat>, C<lstat> and
+the filetest ops (C<-r>, C<-x>, etc.)
+
+=back
+
+=item *
+
+C<caller> sets C<@DB::args> to the subroutine arguments when called from
+the DB package.  It used to crash when doing so if C<@DB::args> happened to
+be tied.  Now it croaks instead.
+
+=item *
+
+Tying an element of %ENV or C<%^H> and then deleting that element would
+result in a call to the tie object's DELETE method, even though tying the
+element itself is supposed to be equivalent to tying a scalar (the element
+is, of course, a scalar) [perl #67490].
+
+=item *
+
+When Perl autovivifies an element of a tied array or hash (which entails
+calling STORE with a new reference), it now calls FETCH immediately after
+the STORE, instead of assuming that FETCH would have returned the same
+reference.  This can make it easier to implement tied objects [perl #35865, #43011].
+
+=item *
+
+Four-argument C<select> no longer produces its "Non-string passed as
+bitmask" warning on tied or tainted variables that are strings.
+
+=item *
+
+Localizing a tied scalar that returns a typeglob no longer stops it from
+being tied till the end of the scope.
+
+=item *
+
+Attempting to C<goto> out of a tied handle method used to cause memory
+corruption or crashes.  Now it produces an error message instead
+[perl #8611].
+
+=item *
+
+A bug has been fixed that occurs when a tied variable is used as a
+subroutine reference:  if the last thing assigned to or returned from the
+variable was a reference or typeglob, the C<\&$tied> could either crash or
+return the wrong subroutine.  The reference case is a regression introduced
+in Perl 5.10.0.  For typeglobs, it has probably never worked till now.
+
+=back
+
+=head2 Version objects and vstrings
+
+=over
+
+=item *
+
+The bitwise complement operator (and possibly other operators, too) when
+passed a vstring would leave vstring magic attached to the return value,
+even though the string had changed.  This meant that
+C<< version->new(~v1.2.3) >> would create a version looking like "v1.2.3"
+even though the string passed to C<< version->new >> was actually
+"\376\375\374".  This also caused L<B::Deparse> to deparse C<~v1.2.3>
+incorrectly, without the C<~> [perl #29070].
+
+=item *
+
+Assigning a vstring to a magic (e.g., tied, C<$!>) variable and then
+assigning something else used to blow away all magic.  This meant that
+tied variables would come undone, C<$!> would stop getting updated on
+failed system calls, C<$|> would stop setting autoflush, and other
+mischief would take place.  This has been fixed.
+
+=item *
+
+C<< version->new("version") >> and C<printf "%vd", "version"> no longer
+crash [perl #102586].
+
+=item *
+
+Version comparisons, such as those that happen implicitly with C<use
+v5.43>, no longer cause locale settings to change [perl #105784].
+
+=item *
+
+Version objects no longer cause memory leaks in boolean context
+[perl #109762].
+
+=back
+
+=head2 Warnings, redefinition
+
+=over
+
+=item *
+
+Subroutines from the C<autouse> namespace are once more exempt from
+redefinition warnings.  This used to work in 5.005, but was broken in
+5.6 for most subroutines.  For subs created via XS that redefine
+subroutines from the C<autouse> package, this stopped working in 5.10.
+
+=item *
+
+New XSUBs now produce redefinition warnings if they overwrite existing
+subs, as they did in 5.8.x.  (The C<autouse> logic was reversed in
+5.10-14.  Only subroutines from the C<autouse> namespace would warn
+when clobbered.)
+
+=item *
+
+C<newCONSTSUB> used to use compile-time warning hints, instead of
+run-time hints.  The following code should never produce a redefinition
+warning, but it used to, if C<newCONSTSUB> redefined an existing
+subroutine:
+
+    use warnings;
+    BEGIN {
+        no warnings;
+        some_XS_function_that_calls_new_CONSTSUB();
+    }
+
+=item *
+
+Redefinition warnings for constant subroutines are on by default (what
+are known as severe warnings in L<perldiag>).  This occurred only
+when it was a glob assignment or declaration of a Perl subroutine that
+caused the warning.  If the creation of XSUBs triggered the warning, it
+was not a default warning.  This has been corrected.
+
+=item *
+
+The internal check to see whether a redefinition warning should occur
+used to emit "uninitialized" warnings in cases like this:
+
+    use warnings "uninitialized";
+    use constant {u => undef, v => undef};
+    sub foo(){u}
+    sub foo(){v}
+
+=back
+
+=head2 Warnings, "Uninitialized"
+
+=over
+
+=item *
+
+Various functions that take a filehandle argument in rvalue context
+(C<close>, C<readline>, etc.) used to warn twice for an undefined handle
+[perl #97482].
+
+=item *
+
+C<dbmopen> now only warns once, rather than three times, if the mode
+argument is C<undef> [perl #90064].
+
+=item *
+
+The C<+=> operator does not usually warn when the left-hand side is
+C<undef>, but it was doing so for tied variables.  This has been fixed
+[perl #44895].
+
+=item *
+
+A bug fix in Perl 5.14 introduced a new bug, causing "uninitialized"
+warnings to report the wrong variable if the operator in question had
+two operands and one was C<%{...}> or C<@{...}>.  This has been fixed
+[perl #103766].
+
+=item *
+
+C<..> and C<...> in list context now mention the name of the variable in
+"uninitialized" warnings for string (as opposed to numeric) ranges.
+
+=back
+
+=head2 Weak references
+
+=over
+
+=item *
+
+Weakening the first argument to an automatically-invoked C<DESTROY> method
+could result in erroneous "DESTROY created new reference" errors or
+crashes.  Now it is an error to weaken a read-only reference.
+
+=item *
+
+Weak references to lexical hashes going out of scope were not going stale
+(becoming undefined), but continued to point to the hash.
+
+=item *
+
+Weak references to lexical variables going out of scope are now broken
+before any magical methods (e.g., DESTROY on a tie object) are called.
+This prevents such methods from modifying the variable that will be seen
+the next time the scope is entered.
+
+=item *
+
+Creating a weak reference to an @ISA array or accessing the array index
+(C<$#ISA>) could result in confused internal bookkeeping for elements
+later added to the @ISA array.  For instance, creating a weak
+reference to the element itself could push that weak reference on to @ISA;
+and elements added after use of C<$#ISA> would be ignored by method lookup
+[perl #85670].
+
+=back
+
+=head2 Other notable fixes
+
+=over
+
+=item *
+
+C<quotemeta> now quotes consistently the same non-ASCII characters under
+C<use feature 'unicode_strings'>, regardless of whether the string is
+encoded in UTF-8 or not, hence fixing the last vestiges (we hope) of the
+notorious L<perlunicode/The "Unicode Bug">.  [perl #77654].
+
+Which of these code points is quoted has changed, based on Unicode's
+recommendations.  See L<perlfunc/quotemeta> for details.
+
+=item *
+
+C<study> is now a no-op, presumably fixing all outstanding bugs related to
+study causing regex matches to behave incorrectly!
+
+=item *
+
+When one writes C<open foo || die>, which used to work in Perl 4, a
+"Precedence problem" warning is produced.  This warning used erroneously to
+apply to fully-qualified bareword handle names not followed by C<||>.  This
+has been corrected.
+
+=item *
+
+After package aliasing (C<*foo:: = *bar::>), C<select> with 0 or 1 argument
+would sometimes return a name that could not be used to refer to the
+filehandle, or sometimes it would return C<undef> even when a filehandle
+was selected.  Now it returns a typeglob reference in such cases.
+
+=item *
+
+C<PerlIO::get_layers> no longer ignores some arguments that it thinks are
+numeric, while treating others as filehandle names.  It is now consistent
+for flat scalars (i.e., not references).
+
+=item *
+
+Unrecognized switches on C<#!> line
+
+If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
+there, perl dies with "Can't emulate...".
+
+It used to produce the same message for switches that perl did not
+recognize at all, whether on the command line or the C<#!> line.
+
+Now it produces the "Unrecognized switch" error message [perl #104288].
+
+=item *
+
+C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
+signal handler from stealing the exit status [perl #105700].
+
+=item *
+
+The %n formatting code for C<printf> and C<sprintf>, which causes the number
+of characters to be assigned to the next argument, now actually
+assigns the number of characters, instead of the number of bytes.
+
+It also works now with special lvalue functions like C<substr> and with
+nonexistent hash and array elements [perl #3471, #103492].
+
+=item *
+
+Perl skips copying values returned from a subroutine, for the sake of
+speed, if doing so would make no observable difference.  Because of faulty
+logic, this would happen with the
+result of C<delete>, C<shift> or C<splice>, even if the result was
+referenced elsewhere.  It also did so with tied variables about to be freed
+[perl #91844, #95548].
+
+=item *
+
+C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
+
+=item *
+
+Freeing $_ inside a C<grep> or C<map> block, a code block embedded in a
+regular expression, or an @INC filter (a subroutine returned by a
+subroutine in @INC) used to result in double frees or crashes
+[perl #91880, #92254, #92256].
+
+=item *
+
+C<eval> returns C<undef> in scalar context or an empty list in list
+context when there is a run-time error.  When C<eval> was passed a
+string in list context and a syntax error occurred, it used to return a
+list containing a single undefined element.  Now it returns an empty
+list in list context for all errors [perl #80630].
+
+=item *
+
+C<goto &func> no longer crashes, but produces an error message, when
+the unwinding of the current subroutine's scope fires a destructor that
+undefines the subroutine being "goneto" [perl #99850].
+
+=item *
+
+Perl now holds an extra reference count on the package that code is
+currently compiling in.  This means that the following code no longer
+crashes [perl #101486]:
+
+    package Foo;
+    BEGIN {*Foo:: = *Bar::}
+    sub foo;
+
+=item *
+
+The C<x> repetition operator no longer crashes on 64-bit builds with large
+repeat counts [perl #94560].
+
+=item *
+
+Calling C<require> on an implicit C<$_> when C<*CORE::GLOBAL::require> has
+been overridden does not segfault anymore, and C<$_> is now passed to the
+overriding subroutine [perl #78260].
+
+=item *
+
+C<use> and C<require> are no longer affected by the I/O layers active in
+the caller's scope (enabled by L<open.pm|open>) [perl #96008].
+
+=item *
+
+C<our $::é; $é> (which is invalid) no longer produces the "Compilation
+error at lib/utf8_heavy.pl..." error message, which it started emitting in
+5.10.0 [perl #99984].
+
+=item *
+
+On 64-bit systems, C<read()> now understands large string offsets beyond
+the 32-bit range.
+
+=item *
+
+Errors that occur when processing subroutine attributes no longer cause the
+subroutine's op tree to leak.
+
+=item *
+
+Passing the same constant subroutine to both C<index> and C<formline> no
+longer causes one or the other to fail [perl #89218]. (5.14.1)
+
+=item *
+
+List assignment to lexical variables declared with attributes in the same
+statement (C<my ($x,@y) : blimp = (72,94)>) stopped working in Perl 5.8.0.
+It has now been fixed.
+
+=item *
+
+Perl 5.10.0 introduced some faulty logic that made "U*" in the middle of
+a pack template equivalent to "U0" if the input string was empty.  This has
+been fixed [perl #90160]. (5.14.2)
+
+=item *
+
+Destructors on objects were not called during global destruction on objects
+that were not referenced by any scalars.  This could happen if an array
+element were blessed (e.g., C<bless \$a[0]>) or if a closure referenced a
+blessed variable (C<bless \my @a; sub foo { @a }>).
+
+Now there is an extra pass during global destruction to fire destructors on
+any objects that might be left after the usual passes that check for
+objects referenced by scalars [perl #36347].
+
+=item *
+
+Fixed a case where it was possible that a freed buffer may have been read
+from when parsing a here document [perl #90128]. (5.14.1)
+
+=item *
+
+C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
+inside a C<while> condition [perl #90888].
+
+=item *
+
+A problem with context propagation when a C<do> block is an argument to
+C<return> has been fixed.  It used to cause C<undef> to be returned in
+certain cases of a C<return> inside an C<if> block which itself is followed by
+another C<return>.
+
+=item *
+
+Calling C<index> with a tainted constant no longer causes constants in
+subsequently compiled code to become tainted [perl #64804].
+
+=item *
+
+Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
+working for the rest of the block.
+
+=item *
+
+For list assignments like C<($a,$b) = ($b,$a)>, Perl has to make a copy of
+the items on the right-hand side before assignment them to the left.  For
+efficiency's sake, it assigns the values on the right straight to the items
+on the left if no one variable is mentioned on both sides, as in C<($a,$b) =
+($c,$d)>.  The logic for determining when it can cheat was faulty, in that
+C<&&> and C<||> on the right-hand side could fool it.  So C<($a,$b) =
+$some_true_value && ($b,$a)> would end up assigning the value of C<$b> to
+both scalars.
+
+=item *
+
+Perl no longer tries to apply lvalue context to the string in
+C<("string", $variable) ||= 1> (which used to be an error).  Since the
+left-hand side of C<||=> is evaluated in scalar context, that's a scalar
+comma operator, which gives all but the last item void context.  There is
+no such thing as void lvalue context, so it was a mistake for Perl to try
+to force it [perl #96942].
+
+=item *
+
+C<caller> no longer leaks memory when called from the DB package if
+C<@DB::args> was assigned to after the first call to C<caller>.  L<Carp>
+was triggering this bug [perl #97010]. (5.14.2)
+
+=item *
+
+C<close> and similar filehandle functions, when called on built-in global
+variables (like C<$+>), used to die if the variable happened to hold the
+undefined value, instead of producing the usual "Use of uninitialized
+value" warning.
+
+=item *
+
+When autovivified file handles were introduced in Perl 5.6.0, C<readline>
+was inadvertently made to autovivify when called as C<readline($foo)> (but
+not as C<E<lt>$fooE<gt>>).  It has now been fixed never to autovivify.
+
+=item *
+
+Calling an undefined anonymous subroutine (e.g., what $x holds after
+C<undef &{$x = sub{}}>) used to cause a "Not a CODE reference" error, which
+has been corrected to "Undefined subroutine called" [perl #71154].
+
+=item *
+
+Causing C<@DB::args> to be freed between uses of C<caller> no longer
+results in a crash [perl #93320].
+
+=item *
+
+C<setpgrp($foo)> used to be equivalent to C<($foo, setpgrp)>, because
+C<setpgrp> was ignoring its argument if there was just one.  Now it is
+equivalent to C<setpgrp($foo,0)>.
+
+=item *
+
+C<shmread> was not setting the scalar flags correctly when reading from
+shared memory, causing the existing cached numeric representation in the
+scalar to persist [perl #98480].
+
+=item *
+
+C<++> and C<--> now work on copies of globs, instead of dying.
+
+=item *
+
+C<splice()> doesn't warn when truncating
+
+You can now limit the size of an array using C<splice(@a,MAX_LEN)> without
+worrying about warnings.
+
+=item *
+
+C<< $$ >> is no longer tainted.  Since this value comes directly from
+C<< getpid() >>, it is always safe.
+
+=item *
+
+The parser no longer leaks a filehandle if STDIN was closed before parsing
+started [perl #37033].
+
+=item *
+
+C<< die; >> with a non-reference, non-string, or magical (e.g., tainted)
+value in $@ now properly propagates that value [perl #111654].
+
+=back
+
+=head1 Known Problems
+
+=over 4
+
+=item *
+
+On Solaris, we have two kinds of failure.
+
+If F<make> is Sun's F<make>, we get an error about a badly formed macro
+assignment in the F<Makefile>.  That happens when F<./Configure> tries to
+make depends.  F<Configure> then exits 0, but further F<make>-ing fails.
+
+If F<make> is F<gmake>, F<Configure> completes, then we get errors related
+to F</usr/include/stdbool.h>
+
+=item *
+
+On Win32, a number of tests hang unless STDERR is redirected.  The cause of
+this is still under investigation.
+
+=item *
+
+When building as root with a umask that prevents files from being
+other-readable, F<t/op/filetest.t> will fail.  This is a test bug, not a
+bug in perl's behavior.
+
+=item *
+
+Configuring with a recent gcc and link-time-optimization, such as
+C<Configure -Doptimize='-O2 -flto'> fails
+because the optimizer optimizes away some of Configure's tests.  A
+workaround is to omit the C<-flto> flag when running Configure, but add
+it back in while actually building, something like
+
+    sh Configure -Doptimize=-O2                                             
+    make OPTIMIZE='-O2 -flto'                                               
+
+=item *
+
+The following CPAN modules have test failures with perl 5.16.  Patches have
+been submitted for all of these, so hopefully there will be new releases
+soon:
+
+=over
+
+=item *
+
+L<Date::Pcalc> version 6.1
+
+=item *
+
+L<Module::CPANTS::Analyse> version 0.85
+
+This fails due to problems in L<Module::Find> 0.10 and L<File::MMagic>
+1.27.
+
+=item *
+
+L<PerlIO::Util> version 0.72
+
+=back
+
+=back
+
+=head1 Acknowledgements
+
+Perl 5.16.0 represents approximately 12 months of development since Perl
+5.14.0 and contains approximately 590,000 lines of changes across 2,500
+files from 139 authors.
+
+Perl continues to flourish into its third decade thanks to a vibrant
+community of users and developers.  The following people are known to
+have contributed the improvements that became Perl 5.16.0:
+
+Aaron Crane, Abhijit Menon-Sen, Abigail, Alan Haggai Alavi, Alberto
+Simões, Alexandr Ciornii, Andreas König, Andy Dougherty, Aristotle
+Pagaltzis, Bo Johansson, Bo Lindbergh, Breno G. de Oliveira, brian d
+foy, Brian Fraser, Brian Greenfield, Carl Hayter, Chas. Owens,
+Chia-liang Kao, Chip Salzenberg, Chris 'BinGOs' Williams, Christian
+Hansen, Christopher J. Madsen, chromatic, Claes Jacobsson, Claudio
+Ramirez, Craig A. Berry, Damian Conway, Daniel Kahn Gillmor, Darin
+McBride, Dave Rolsky, David Cantrell, David Golden, David Leadbeater,
+David Mitchell, Dee Newcum, Dennis Kaarsemaker, Dominic Hargreaves,
+Douglas Christopher Wilson, Eric Brine, Father Chrysostomos, Florian
+Ragwitz, Frederic Briere, George Greer, Gerard Goossen, Gisle Aas,
+H.Merijn Brand, Hojung Youn, Ian Goodacre, James E Keenan, Jan Dubois,
+Jerry D. Hedden, Jesse Luehrs, Jesse Vincent, Jilles Tjoelker, Jim
+Cromie, Jim Meyering, Joel Berger, Johan Vromans, Johannes Plunien, John
+Hawkinson, John P. Linderman, John Peacock, Joshua ben Jore, Juerd
+Waalboer, Karl Williamson, Karthik Rajagopalan, Keith Thompson, Kevin J.
+Woolley, Kevin Ryde, Laurent Dami, Leo Lapworth, Leon Brocard, Leon
+Timmermans, Louis Strous, Lukas Mai, Marc Green, Marcel Grünauer, Mark
+A.  Stratman, Mark Dootson, Mark Jason Dominus, Martin Hasch, Matthew
+Horsfall, Max Maischein, Michael G Schwern, Michael Witten, Mike
+Sheldrake, Moritz Lenz, Nicholas Clark, Niko Tyni, Nuno Carvalho, Pau
+Amma, Paul Evans, Paul Green, Paul Johnson, Perlover, Peter John Acklam,
+Peter Martini, Peter Scott, Phil Monsen, Pino Toscano, Rafael
+Garcia-Suarez, Rainer Tammer, Reini Urban, Ricardo Signes, Robin Barker,
+Rodolfo Carvalho, Salvador Fandiño, Sam Kimbrel, Samuel Thibault, Shawn
+M Moore, Shigeya Suzuki, Shirakata Kentaro, Shlomi Fish, Sisyphus,
+Slaven Rezic, Spiros Denaxas, Steffen Müller, Steffen Schwigon, Stephen
+Bennett, Stephen Oberholtzer, Stevan Little, Steve Hay, Steve Peters,
+Thomas Sibley, Thorsten Glaser, Timothe Litt, Todd Rinaldo, Tom
+Christiansen, Tom Hukins, Tony Cook, Vadim Konovalov, Vincent Pit,
+Vladimir Timofeev, Walt Mankowski, Yves Orton, Zefram, Zsbán Ambrus,
+Ævar Arnfjörð Bjarmason.
+
+The list above is almost certainly incomplete as it is automatically
+generated from version control history.  In particular, it does not
+include the names of the (very much appreciated) contributors who
+reported issues to the Perl bug tracker.
+
+Many of the changes included in this version originated in the CPAN
+modules included in Perl's core.  We're grateful to the entire CPAN
+community for helping Perl to flourish.
+
+For a more complete list of all of Perl's historical contributors,
+please see the F<AUTHORS> file in the Perl source distribution.
+
+=head1 Reporting Bugs
+
+If you find what you think is a bug, you might check the articles
+recently posted to the comp.lang.perl.misc newsgroup and the perl
+bug database at L<http://rt.perl.org/perlbug/>.  There may also be
+information at L<http://www.perl.org/>, the Perl Home Page.
+
+If you believe you have an unreported bug, please run the L<perlbug>
+program included with your release.  Be sure to trim your bug down
+to a tiny but sufficient test case.  Your bug report, along with the
+output of C<perl -V>, will be sent off to perlbug@perl.org to be
+analysed by the Perl porting team.
+
+If the bug you are reporting has security implications, which make it
+inappropriate to send to a publicly archived mailing list, then please
+send it to perl5-security-report@perl.org.  This points to a closed
+subscription unarchived mailing list, which includes all core
+committers, who will be able to help assess the impact of issues, figure
+out a resolution, and help co-ordinate the release of patches to
+mitigate or fix the problem across all platforms on which Perl is
+supported.  Please use this address only for security issues in the Perl
+core, not for modules independently distributed on CPAN.
+
+=head1 SEE ALSO
+
+The F<Changes> file for an explanation of how to view exhaustive details
+on what changed.
+
+The F<INSTALL> file for how to build Perl.
+
+The F<README> file for general stuff.
+
+The F<Artistic> and F<Copying> files for copyright information.
+
+=cut
index 5fbbf7d..6c64e2c 100644 (file)
 
 =head1 NAME
 
-perldelta - what is new for perl v5.16.0
+[ this is a template for a new perldelta file. Any text flagged as
+XXX needs to be processed before release. ]
 
-=head1 DESCRIPTION
+perldelta - what is new for perl v5.16.1
 
-This document describes differences between the 5.14.0 release and
-the 5.16.0 release.
+=head1 DESCRIPTION
 
-If you are upgrading from an earlier release such as 5.12.0, first read
-L<perl5140delta>, which describes differences between 5.12.0 and
-5.14.0.
+This document describes differences between the 5.16.0 release and
+the 5.16.1 release.
 
-Some bug fixes in this release have been backported to later
-releases of 5.14.x.  Those are indicated with the 5.14.x version in
-parentheses.
+If you are upgrading from an earlier release such as 5.16.0, first read
+L<perl5160delta>, which describes differences between 5.16.0 and
+5.16.0.
 
 =head1 Notice
 
-With the release of Perl 5.16.0, the 5.12.x series of releases is now out of
-its support period.  There may be future 5.12.x releases, but only in the
-event of a critical security issue.  Users of Perl 5.12 or earlier should
-consider upgrading to a more recent release of Perl.
-
-This policy is described in greater detail in
-L<perlpolicy|perlpolicy/MAINTENANCE AND SUPPORT>.
+XXX Any important notices here
 
 =head1 Core Enhancements
 
-=head2 C<use I<VERSION>>
-
-As of this release, version declarations like C<use v5.16> now disable
-all features before enabling the new feature bundle.  This means that
-the following holds true:
-
-    use 5.016;
-    # only 5.16 features enabled here
-    use 5.014;
-    # only 5.14 features enabled here (not 5.16)
-
-C<use v5.12> and higher continue to enable strict, but explicit C<use
-strict> and C<no strict> now override the version declaration, even
-when they come first:
-
-    no strict;
-    use 5.012;
-    # no strict here
-
-There is a new ":default" feature bundle that represents the set of
-features enabled before any version declaration or C<use feature> has
-been seen.  Version declarations below 5.10 now enable the ":default"
-feature set.  This does not actually change the behavior of C<use
-v5.8>, because features added to the ":default" set are those that were
-traditionally enabled by default, before they could be turned off.
-
-C<< no feature >> now resets to the default feature set.  To disable all
-features (which is likely to be a pretty special-purpose request, since
-it presumably won't match any named set of semantics) you can now  
-write C<< no feature ':all' >>.
-
-C<$[> is now disabled under C<use v5.16>.  It is part of the default
-feature set and can be turned on or off explicitly with C<use feature
-'array_base'>.
-
-=head2 C<__SUB__>
-
-The new C<__SUB__> token, available under the C<current_sub> feature
-(see L<feature>) or C<use v5.16>, returns a reference to the current
-subroutine, making it easier to write recursive closures.
-
-=head2 New and Improved Built-ins
-
-=head3 More consistent C<eval>
-
-The C<eval> operator sometimes treats a string argument as a sequence of
-characters and sometimes as a sequence of bytes, depending on the
-internal encoding.  The internal encoding is not supposed to make any
-difference, but there is code that relies on this inconsistency.
-
-The new C<unicode_eval> and C<evalbytes> features (enabled under C<use
-5.16.0>) resolve this.  The C<unicode_eval> feature causes C<eval
-$string> to treat the string always as Unicode.  The C<evalbytes>
-features provides a function, itself called C<evalbytes>, which
-evaluates its argument always as a string of bytes.
-
-These features also fix oddities with source filters leaking to outer
-dynamic scopes.
-
-See L<feature> for more detail.
-
-=head3 C<substr> lvalue revamp
-
-=for comment Does this belong here, or under Incompatible Changes?
-
-When C<substr> is called in lvalue or potential lvalue context with two
-or three arguments, a special lvalue scalar is returned that modifies
-the original string (the first argument) when assigned to.
-
-Previously, the offsets (the second and third arguments) passed to
-C<substr> would be converted immediately to match the string, negative
-offsets being translated to positive and offsets beyond the end of the
-string being truncated.
-
-Now, the offsets are recorded without modification in the special
-lvalue scalar that is returned, and the original string is not even
-looked at by C<substr> itself, but only when the returned lvalue is
-read or modified.
-
-These changes result in an incompatible change:
-
-If the original string changes length after the call to C<substr> but
-before assignment to its return value, negative offsets will remember
-their position from the end of the string, affecting code like this:
-
-    my $string = "string";
-    my $lvalue = \substr $string, -4, 2;
-    print $$lvalue, "\n"; # prints "ri"
-    $string = "bailing twine";
-    print $$lvalue, "\n"; # prints "wi"; used to print "il"
-
-The same thing happens with an omitted third argument.  The returned
-lvalue will always extend to the end of the string, even if the string
-becomes longer.
-
-Since this change also allowed many bugs to be fixed (see
-L</The C<substr> operator>), and since the behavior
-of negative offsets has never been specified, the
-change was deemed acceptable.
-
-=head3 Return value of C<tied>
-
-The value returned by C<tied> on a tied variable is now the actual
-scalar that holds the object to which the variable is tied.  This
-lets ties be weakened with C<Scalar::Util::weaken(tied
-$tied_variable)>.
-
-=head2 Unicode Support
-
-=head3 Supports (I<almost>) Unicode 6.1
-
-Besides the addition of whole new scripts, and new characters in
-existing scripts, this new version of Unicode, as always, makes some
-changes to existing characters.  One change that may trip up some
-applications is that the General Category of two characters in the
-Latin-1 range, PILCROW SIGN and SECTION SIGN, has been changed from
-Other_Symbol to Other_Punctuation.  The same change has been made for
-a character in each of Tibetan, Ethiopic, and Aegean.
-The code points U+3248..U+324F (CIRCLED NUMBER TEN ON BLACK SQUARE
-through CIRCLED NUMBER EIGHTY ON BLACK SQUARE) have had their General
-Category changed from Other_Symbol to Other_Numeric.  The Line Break
-property has changes for Hebrew and Japanese; and because of
-other changes in 6.1, the Perl regular expression construct C<\X> now
-works differently for some characters in Thai and Lao.
-
-New aliases (synonyms) have been defined for many property values;
-these, along with the previously existing ones, are all cross-indexed in
-L<perluniprops>.
-
-The return value of C<charnames::viacode()> is affected by other
-changes:
-
- Code point      Old Name             New Name
-   U+000A    LINE FEED (LF)        LINE FEED
-   U+000C    FORM FEED (FF)        FORM FEED
-   U+000D    CARRIAGE RETURN (CR)  CARRIAGE RETURN
-   U+0085    NEXT LINE (NEL)       NEXT LINE
-   U+008E    SINGLE-SHIFT 2        SINGLE-SHIFT-2
-   U+008F    SINGLE-SHIFT 3        SINGLE-SHIFT-3
-   U+0091    PRIVATE USE 1         PRIVATE USE-1
-   U+0092    PRIVATE USE 2         PRIVATE USE-2
-   U+2118    SCRIPT CAPITAL P      WEIERSTRASS ELLIPTIC FUNCTION
-
-Perl will accept any of these names as input, but
-C<charnames::viacode()> now returns the new name of each pair.  The
-change for U+2118 is considered by Unicode to be a correction, that is
-the original name was a mistake (but again, it will remain forever valid
-to use it to refer to U+2118).  But most of these changes are the
-fallout of the mistake Unicode 6.0 made in naming a character used in
-Japanese cell phones to be "BELL", which conflicts with the longstanding
-industry use of (and Unicode's recommendation to use) that name
-to mean the ASCII control character at U+0007.  Therefore, that name
-has been deprecated in Perl since v5.14, and any use of it will raise a
-warning message (unless turned off).  The name "ALERT" is now the
-preferred name for this code point, with "BEL" an acceptable short
-form.  The name for the new cell phone character, at code point U+1F514,
-remains undefined in this version of Perl (hence we don't 
-implement quite all of Unicode 6.1), but starting in v5.18, BELL will mean
-this character, and not U+0007.
-
-Unicode has taken steps to make sure that this sort of mistake does not
-happen again.  The Standard now includes all generally accepted
-names and abbreviations for control characters, whereas previously it
-didn't (though there were recommended names for most of them, which Perl
-used).  This means that most of those recommended names are now
-officially in the Standard.  Unicode did not recommend names for the
-four code points listed above between U+008E and U+008F, and in
-standardizing them Unicode subtly changed the names that Perl had
-previously given them, by replacing the final blank in each name by a
-hyphen.  Unicode also officially accepts names that Perl had deprecated,
-such as FILE SEPARATOR.  Now the only deprecated name is BELL.
-Finally, Perl now uses the new official names instead of the old
-(now considered obsolete) names for the first four code points in the
-list above (the ones which have the parentheses in them).
-
-Now that the names have been placed in the Unicode standard, these kinds
-of changes should not happen again, though corrections, such as to
-U+2118, are still possible.
-
-Unicode also added some name abbreviations, which Perl now accepts:
-SP for SPACE;
-TAB for CHARACTER TABULATION;
-NEW LINE, END OF LINE, NL, and EOL for LINE FEED;
-LOCKING-SHIFT ONE for SHIFT OUT;
-LOCKING-SHIFT ZERO for SHIFT IN;
-and ZWNBSP for ZERO WIDTH NO-BREAK SPACE.
-
-More details on this version of Unicode are provided in
-L<http://www.unicode.org/versions/Unicode6.1.0/>.
-
-=head3 C<use charnames> is no longer needed for C<\N{I<name>}>
-
-When C<\N{I<name>}> is encountered, the C<charnames> module is now
-automatically loaded when needed as if the C<:full> and C<:short>
-options had been specified.  See L<charnames> for more information.
-
-=head3 C<\N{...}> can now have Unicode loose name matching
-
-This is described in the C<charnames> item in
-L</Updated Modules and Pragmata> below.
-
-=head3 Unicode Symbol Names
-
-Perl now has proper support for Unicode in symbol names.  It used to be
-that C<*{$foo}> would ignore the internal UTF8 flag and use the bytes of
-the underlying representation to look up the symbol.  That meant that
-C<*{"\x{100}"}> and C<*{"\xc4\x80"}> would return the same thing.  All
-these parts of Perl have been fixed to account for Unicode:
-
-=over
-
-=item *
-
-Method names (including those passed to C<use overload>)
-
-=item *
-
-Typeglob names (including names of variables, subroutines, and filehandles)
-
-=item *
-
-Package names
-
-=item *
-
-C<goto>
-
-=item *
-
-Symbolic dereferencing
-
-=item *
-
-Second argument to C<bless()> and C<tie()>
-
-=item *
-
-Return value of C<ref()>
-
-=item *
-
-Subroutine prototypes
-
-=item *
-
-Attributes
-
-=item *
-
-Various warnings and error messages that mention variable names or values,
-methods, etc.
-
-=back
-
-In addition, a parsing bug has been fixed that prevented C<*{é}> from
-implicitly quoting the name, but instead interpreted it as C<*{+é}>, which
-would cause a strict violation.
-
-C<*{"*a::b"}> automatically strips off the * if it is followed by an ASCII
-letter.  That has been extended to all Unicode identifier characters.
-
-One-character non-ASCII non-punctuation variables (like C<$é>) are now
-subject to "Used only once" warnings.  They used to be exempt, as they
-were treated as punctuation variables.
-
-Also, single-character Unicode punctuation variables (like C<$‰>) are now
-supported [perl #69032].
-
-=head3 Improved ability to mix locales and Unicode, including UTF-8 locales
-
-An optional parameter has been added to C<use locale>
-
- use locale ':not_characters';
-
-which tells Perl to use all but the C<LC_CTYPE> and C<LC_COLLATE>
-portions of the current locale.  Instead, the character set is assumed
-to be Unicode.  This lets locales and Unicode be seamlessly mixed,
-including the increasingly frequent UTF-8 locales.  When using this
-hybrid form of locales, the C<:locale> layer to the L<open> pragma can
-be used to interface with the file system, and there are CPAN modules
-available for ARGV and environment variable conversions.
-
-Full details are in L<perllocale>.
-
-=head3 New function C<fc> and corresponding escape sequence C<\F> for Unicode foldcase
-
-Unicode foldcase is an extension to lowercase that gives better results
-when comparing two strings case-insensitively.  It has long been used
-internally in regular expression C</i> matching.  Now it is available
-explicitly through the new C<fc> function call (enabled by
-S<C<"use feature 'fc'">>, or C<use v5.16>, or explicitly callable via
-C<CORE::fc>) or through the new C<\F> sequence in double-quotish
-strings.
-
-Full details are in L<perlfunc/fc>.
-
-=head3 The Unicode C<Script_Extensions> property is now supported.
-
-New in Unicode 6.0, this is an improved C<Script> property.  Details
-are in L<perlunicode/Scripts>.
-
-=head2 XS Changes
-
-=head3 Improved typemaps for Some Builtin Types
-
-Most XS authors will know there is a longstanding bug in the
-OUTPUT typemap for T_AVREF (C<AV*>), T_HVREF (C<HV*>), T_CVREF (C<CV*>),
-and T_SVREF (C<SVREF> or C<\$foo>) that requires manually decrementing
-the reference count of the return value instead of the typemap taking
-care of this.  For backwards-compatibility, this cannot be changed in the
-default typemaps.  But we now provide additional typemaps
-C<T_AVREF_REFCOUNT_FIXED>, etc. that do not exhibit this bug.  Using
-them in your extension is as simple as having one line in your
-C<TYPEMAP> section:
-
-  HV*  T_HVREF_REFCOUNT_FIXED
-
-=head3 C<is_utf8_char()>
-
-The XS-callable function C<is_utf8_char()>, when presented with
-malformed UTF-8 input, can read up to 12 bytes beyond the end of the
-string.  This cannot be fixed without changing its API, and so its
-use is now deprecated.  Use C<is_utf8_char_buf()> (described just below)
-instead.
-
-=head3 Added C<is_utf8_char_buf()>
-
-This function is designed to replace the deprecated L</is_utf8_char()>
-function.  It includes an extra parameter to make sure it doesn't read
-past the end of the input buffer.
-
-=head3 Other C<is_utf8_foo()> functions, as well as C<utf8_to_foo()>, etc.
-
-Most other XS-callable functions that take UTF-8 encoded input
-implicitly assume that the UTF-8 is valid (not malformed) with respect to
-buffer length.  Do not do things such as change a character's case or
-see if it is alphanumeric without first being sure that it is valid
-UTF-8.  This can be safely done for a whole string by using one of the
-functions C<is_utf8_string()>, C<is_utf8_string_loc()>, and
-C<is_utf8_string_loclen()>.
-
-=head3 New Pad API
-
-Many new functions have been added to the API for manipulating lexical
-pads.  See L<perlapi/Pad Data Structures> for more information.
-
-=head2 Changes to Special Variables
-
-=head3 C<$$> can be assigned to
-
-C<$$> was made read-only in Perl 5.8.0.  But only sometimes: C<local $$>
-would make it writable again.  Some CPAN modules were using C<local $$> or
-XS code to bypass the read-only check, so there is no reason to keep C<$$>
-read-only.  (This change also allowed a bug to be fixed while maintaining
-backward compatibility.)
-
-=head3 C<$^X> converted to an absolute path on FreeBSD, OS X and Solaris
-
-C<$^X> is now converted to an absolute path on OS X, FreeBSD (without
-needing F</proc> mounted) and Solaris 10 and 11.  This augments the
-previous approach of using F</proc> on Linux, FreeBSD, and NetBSD
-(in all cases, where mounted).
-
-This makes relocatable perl installations more useful on these platforms.
-(See "Relocatable @INC" in F<INSTALL>)
-
-=head2 Debugger Changes
-
-=head3 Features inside the debugger
-
-The current Perl's L<feature> bundle is now enabled for commands entered
-in the interactive debugger.
-
-=head3 New option for the debugger's B<t> command
-
-The B<t> command in the debugger, which toggles tracing mode, now
-accepts a numeric argument that determines how many levels of subroutine
-calls to trace.
-
-=head3 C<enable> and C<disable>
-
-The debugger now has C<disable> and C<enable> commands for disabling
-existing breakpoints and re-enabling them.  See L<perldebug>.
-
-=head3 Breakpoints with file names
-
-The debugger's "b" command for setting breakpoints now lets a line
-number be prefixed with a file name.  See
-L<perldebug/"b [file]:[line] [condition]">.
-
-=head2 The C<CORE> Namespace
-
-=head3 The C<CORE::> prefix
-
-The C<CORE::> prefix can now be used on keywords enabled by
-L<feature.pm|feature>, even outside the scope of C<use feature>.
-
-=head3 Subroutines in the C<CORE> namespace
-
-Many Perl keywords are now available as subroutines in the CORE namespace.
-This lets them be aliased:
-
-    BEGIN { *entangle = \&CORE::tie }
-    entangle $variable, $package, @args;
-
-And for prototypes to be bypassed:
-
-    sub mytie(\[%$*@]$@) {
-       my ($ref, $pack, @args) = @_;
-       ... do something ...
-       goto &CORE::tie;
-    }
-
-Some of these cannot be called through references or via C<&foo> syntax,
-but must be called as barewords.
-
-See L<CORE> for details.
-
-=head2 Other Changes
-
-=head3 Anonymous handles
-
-Automatically generated file handles are now named __ANONIO__ when the
-variable name cannot be determined, rather than $__ANONIO__.
-
-=head3 Autoloaded sort Subroutines
-
-Custom sort subroutines can now be autoloaded [perl #30661]:
-
-    sub AUTOLOAD { ... }
-    @sorted = sort foo @list; # uses AUTOLOAD
-
-=head3 C<continue> no longer requires the "switch" feature
-
-The C<continue> keyword has two meanings.  It can introduce a C<continue>
-block after a loop, or it can exit the current C<when> block.  Up to now,
-the latter meaning was valid only with the "switch" feature enabled, and
-was a syntax error otherwise.  Since the main purpose of feature.pm is to
-avoid conflicts with user-defined subroutines, there is no reason for
-C<continue> to depend on it.
-
-=head3 DTrace probes for interpreter phase change
-
-The C<phase-change> probes will fire when the interpreter's phase
-changes, which tracks the C<${^GLOBAL_PHASE}> variable.  C<arg0> is
-the new phase name; C<arg1> is the old one.  This is useful 
-for limiting your instrumentation to one or more of: compile time,
-run time, or destruct time.
-
-=head3 C<__FILE__()> Syntax
-
-The C<__FILE__>, C<__LINE__> and C<__PACKAGE__> tokens can now be written
-with an empty pair of parentheses after them.  This makes them parse the
-same way as C<time>, C<fork> and other built-in functions.
-
-=head3 The C<\$> prototype accepts any scalar lvalue
-
-The C<\$> and C<\[$]> subroutine prototypes now accept any scalar lvalue
-argument.  Previously they accepted only scalars beginning with C<$> and
-hash and array elements.  This change makes them consistent with the way
-the built-in C<read> and C<recv> functions (among others) parse their
-arguments.  This means that one can override the built-in functions with
-custom subroutines that parse their arguments the same way.
-
-=head3 C<_> in subroutine prototypes
+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.
 
-The C<_> character in subroutine prototypes is now allowed before C<@> or
-C<%>.
+[ List each enhancement as a =head2 entry ]
 
 =head1 Security
 
-=head2 Use C<is_utf8_char_buf()> and not C<is_utf8_char()>
+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.
 
-The latter function is now deprecated because its API is insufficient to
-guarantee that it doesn't read (up to 12 bytes in the worst case) beyond
-the end of its input string.  See
-L<is_utf8_char_buf()|/Added is_utf8_char_buf()>.
-
-=head2 Malformed UTF-8 input could cause attempts to read beyond the end of the buffer
-
-Two new XS-accessible functions, C<utf8_to_uvchr_buf()> and
-C<utf8_to_uvuni_buf()> are now available to prevent this, and the Perl
-core has been converted to use them.
-See L</Internal Changes>.
-
-=head2 C<File::Glob::bsd_glob()> memory error with GLOB_ALTDIRFUNC (CVE-2011-2728).
-
-Calling C<File::Glob::bsd_glob> with the unsupported flag
-GLOB_ALTDIRFUNC would cause an access violation / segfault.  A Perl
-program that accepts a flags value from an external source could expose
-itself to denial of service or arbitrary code execution attacks.  There
-are no known exploits in the wild.  The problem has been corrected by
-explicitly disabling all unsupported flags and setting unused function
-pointers to null.  Bug reported by Clément Lecigne. (5.14.2)
-
-=head2 Privileges are now set correctly when assigning to C<$(>
-
-A hypothetical bug (probably unexploitable in practice) because the
-incorrect setting of the effective group ID while setting C<$(> has been
-fixed.  The bug would have affected only systems that have C<setresgid()>
-but not C<setregid()>, but no such systems are known to exist.
-
-=head1 Deprecations
-
-=head2 Don't read the Unicode data base files in F<lib/unicore>
-
-It is now deprecated to directly read the Unicode data base files.
-These are stored in the F<lib/unicore> directory.  Instead, you should
-use the new functions in L<Unicode::UCD>.  These provide a stable API,
-and give complete information.
-
-Perl may at some point in the future change or remove these files.  The
-file which applications were most likely to have used is
-F<lib/unicore/ToDigit.pl>.  L<Unicode::UCD/prop_invmap()> can be used to
-get at its data instead.
-
-=head2 XS functions C<is_utf8_char()>, C<utf8_to_uvchr()> and
-C<utf8_to_uvuni()>
-
-This function is deprecated because it could read beyond the end of the
-input string.  Use the new L<is_utf8_char_buf()|/Added is_utf8_char_buf()>,
-C<utf8_to_uvchr_buf()> and C<utf8_to_uvuni_buf()> instead.
-
-=head1 Future Deprecations
-
-This section serves as a notice of features that are I<likely> to be
-removed or L<deprecated|perlpolicy/deprecated> in the next release of
-perl (5.18.0).  If your code depends on these features, you should
-contact the Perl 5 Porters via the L<mailing
-list|http://lists.perl.org/list/perl5-porters.html> or L<perlbug> to
-explain your use case and inform the deprecation process.
-
-=head2 Core Modules
-
-These modules may be marked as deprecated I<from the core>.  This only
-means that they will no longer be installed by default with the core
-distribution, but will remain available on the CPAN.
-
-=over
-
-=item *
-
-CPANPLUS
-
-=item *
-
-Filter::Simple
-
-=item *
-
-PerlIO::mmap
-
-=item *
-
-Pod::LaTeX
-
-=item *
-
-Pod::Parser
-
-=item *
-
-SelfLoader
-
-=item *
-
-Text::Soundex
-
-=item *
-
-Thread.pm
-
-=back
-
-=head2 Platforms with no supporting programmers:
-
-These platforms will probably have their
-special build support removed during the
-5.17.0 development series.
-
-=over
-
-=item *
-
-BeOS
-
-=item *
-
-djgpp
-
-=item *
-
-dgux
-
-=item *
-
-EPOC
-
-=item *
-
-MPE/iX
-
-=item *
-
-Rhapsody
-
-=item *
-
-UTS
-
-=item *
-
-VM/ESA
-
-=back
-
-=head2 Other Future Deprecations
-
-=over
-
-=item *
-
-Swapping of $< and $>
-
-For more information about this future deprecation, see L<the relevant RT
-ticket|https://rt.perl.org/rt3/Ticket/Display.html?id=96212>.
-
-=item *
-
-sfio, stdio
-
-Perl supports being built without PerlIO proper, using a stdio or sfio
-wrapper instead.  A perl build like this will not support IO layers and
-thus Unicode IO, making it rather handicapped.
-
-PerlIO supports a C<stdio> layer if stdio use is desired, and similarly a
-sfio layer could be produced.
-
-=item *
-
-Unescaped literal C<< "{" >> in regular expressions.
-
-Starting with v5.20, it is planned to require a literal C<"{"> to be
-escaped, for example by preceding it with a backslash.  In v5.18, a
-deprecated warning message will be emitted for all such uses.  
-This affects only patterns that are to match a literal C<"{">.  Other
-uses of this character, such as part of a quantifier or sequence as in
-those below, are completely unaffected:
-
-    /foo{3,5}/
-    /\p{Alphabetic}/
-    /\N{DIGIT ZERO}
-
-Removing this will permit extensions to Perl's pattern syntax and better
-error checking for existing syntax.  See L<perlre/Quantifiers> for an
-example.
-
-=item *
-
-Revamping C<< "\Q" >> semantics in double-quotish strings when combined with other escapes.
-
-There are several bugs and inconsistencies involving combinations
-of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair.
-These need to be fixed, and doing so will necessarily change current
-behavior.  The changes have not yet been settled.
-
-=back
+[ List each security issue as a =head2 entry ]
 
 =head1 Incompatible Changes
 
-=head2 Special blocks called in void context
-
-Special blocks (C<BEGIN>, C<CHECK>, C<INIT>, C<UNITCHECK>, C<END>) are now
-called in void context.  This avoids wasteful copying of the result of the
-last statement [perl #108794].
-
-=head2 The C<overloading> pragma and regexp objects
-
-With C<no overloading>, regular expression objects returned by C<qr//> are
-now stringified as "Regexp=REGEXP(0xbe600d)" instead of the regular
-expression itself [perl #108780].
-
-=head2 Two XS typemap Entries removed
-
-Two presumably unused XS typemap entries have been removed from the
-core typemap: T_DATAUNIT and T_CALLBACK.  If you are, against all odds,
-a user of these, please see the instructions on how to restore them
-in L<perlxstypemap>.
-
-=head2 Unicode 6.1 has incompatibilities with Unicode 6.0
-
-These are detailed in L</Supports (almost) Unicode 6.1> above.
-You can compile this version of Perl to use Unicode 6.0.  See
-L<perlunicode/Hacking Perl to work on earlier Unicode versions (for very serious hackers only)>.
-
-=head2 Borland compiler
-
-All support for the Borland compiler has been dropped.  The code had not
-worked for a long time anyway.
-
-=head2 Certain deprecated Unicode properties are no longer supported by default
-
-Perl should never have exposed certain Unicode properties that are used
-by Unicode internally and not meant to be publicly available.  Use of
-these has generated deprecated warning messages since Perl 5.12.  The
-removed properties are Other_Alphabetic,
-Other_Default_Ignorable_Code_Point, Other_Grapheme_Extend,
-Other_ID_Continue, Other_ID_Start, Other_Lowercase, Other_Math, and
-Other_Uppercase.
-
-Perl may be recompiled to include any or all of them; instructions are
-given in
-L<perluniprops/Unicode character properties that are NOT accepted by Perl>.
-
-=head2 Dereferencing IO thingies as typeglobs
+XXX For a release on a stable branch, this section aspires to be:
 
-The C<*{...}> operator, when passed a reference to an IO thingy (as in
-C<*{*STDIN{IO}}>), creates a new typeglob containing just that IO object.
-Previously, it would stringify as an empty string, but some operators would
-treat it as undefined, producing an "uninitialized" warning.
-Now it stringifies as __ANONIO__ [perl #96326].
+    There are no changes intentionally incompatible with 5.XXX.XXX
+    If any exist, they are bugs, and we request that you submit a
+    report.  See L</Reporting Bugs> below.
 
-=head2 User-defined case-changing operations
+[ List each incompatible change as a =head2 entry ]
 
-This feature was deprecated in Perl 5.14, and has now been removed.
-The CPAN module L<Unicode::Casing> provides better functionality without
-the drawbacks that this feature had, as are detailed in the 5.14
-documentation:
-L<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
-
-=head2 XSUBs are now 'static'
-
-XSUB C functions are now 'static', that is, they are not visible from
-outside the compilation unit.  Users can use the new C<XS_EXTERNAL(name)>
-and C<XS_INTERNAL(name)> macros to pick the desired linking behavior.
-The ordinary C<XS(name)> declaration for XSUBs will continue to declare
-non-'static' XSUBs for compatibility, but the XS compiler,
-L<ExtUtils::ParseXS> (C<xsubpp>) will emit 'static' XSUBs by default.
-L<ExtUtils::ParseXS>'s behavior can be reconfigured from XS using the
-C<EXPORT_XSUB_SYMBOLS> keyword.  See L<perlxs> for details.
-
-=head2 Weakening read-only references
-
-Weakening read-only references is no longer permitted.  It should never
-have worked anyway, and could sometimes result in crashes.
-
-=head2 Tying scalars that hold typeglobs
-
-Attempting to tie a scalar after a typeglob was assigned to it would
-instead tie the handle in the typeglob's IO slot.  This meant that it was
-impossible to tie the scalar itself.  Similar problems affected C<tied> and
-C<untie>: C<tied $scalar> would return false on a tied scalar if the last
-thing returned was a typeglob, and C<untie $scalar> on such a tied scalar
-would do nothing.
-
-We fixed this problem before Perl 5.14.0, but it caused problems with some
-CPAN modules, so we put in a deprecation cycle instead.
-
-Now the deprecation has been removed and this bug has been fixed.  So
-C<tie $scalar> will always tie the scalar, not the handle it holds.  To tie
-the handle, use C<tie *$scalar> (with an explicit asterisk).  The same
-applies to C<tied *$scalar> and C<untie *$scalar>.
-
-=head2 IPC::Open3 no longer provides C<xfork()>, C<xclose_on_exec()>
-and C<xpipe_anon()>
-
-All three functions were private, undocumented, and unexported.  They do
-not appear to be used by any code on CPAN.  Two have been inlined and one
-deleted entirely.
-
-=head2 C<$$> no longer caches PID
-
-Previously, if one called fork(3) from C, Perl's
-notion of C<$$> could go out of sync with what getpid() returns.  By always
-fetching the value of C<$$> via getpid(), this potential bug is eliminated.
-Code that depends on the caching behavior will break.  As described in
-L<Core Enhancements|/C<$$> can be assigned to>,
-C<$$> is now writable, but it will be reset during a
-fork.
-
-=head2 C<$$> and C<getppid()> no longer emulate POSIX semantics under LinuxThreads
-
-The POSIX emulation of C<$$> and C<getppid()> under the obsolete
-LinuxThreads implementation has been removed.
-This only impacts users of Linux 2.4 and
-users of Debian GNU/kFreeBSD up to and including 6.0, not the vast
-majority of Linux installations that use NPTL threads.
-
-This means that C<getppid()>, like C<$$>, is now always guaranteed to
-return the OS's idea of the current state of the process, not perl's
-cached version of it.
-
-See the documentation for L<$$|perlvar/$$> for details.
-
-=head2 C<< $< >>, C<< $> >>, C<$(> and C<$)> are no longer cached
-
-Similarly to the changes to C<$$> and C<getppid()>, the internal
-caching of C<< $< >>, C<< $> >>, C<$(> and C<$)> has been removed.
-
-When we cached these values our idea of what they were would drift out
-of sync with reality if someone (e.g., someone embedding perl) called
-C<sete?[ug]id()> without updating C<PL_e?[ug]id>.  Having to deal with
-this complexity wasn't worth it given how cheap the C<gete?[ug]id()>
-system call is.
-
-This change will break a handful of CPAN modules that use the XS-level
-C<PL_uid>, C<PL_gid>, C<PL_euid> or C<PL_egid> variables.
-
-The fix for those breakages is to use C<PerlProc_gete?[ug]id()> to
-retrieve them (e.g., C<PerlProc_getuid()>), and not to assign to
-C<PL_e?[ug]id> if you change the UID/GID/EUID/EGID.  There is no longer
-any need to do so since perl will always retrieve the up-to-date
-version of those values from the OS.
+=head1 Deprecations
 
-=head2 Which Non-ASCII characters get quoted by C<quotemeta> and C<\Q> has changed
+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.
 
-This is unlikely to result in a real problem, as Perl does not attach
-special meaning to any non-ASCII character, so it is currently
-irrelevant which are quoted or not.  This change fixes bug [perl #77654] and
-brings Perl's behavior more into line with Unicode's recommendations.
-See L<perlfunc/quotemeta>.
+[ List each deprecation as a =head2 entry ]
 
 =head1 Performance Enhancements
 
-=over
-
-=item *
+XXX Changes which enhance performance without changing behaviour go here. There
+may well be none in a stable release.
 
-Improved performance for Unicode properties in regular expressions
-
-=for comment Can this be compacted some? -- rjbs, 2012-02-20
-
-Matching a code point against a Unicode property is now done via a
-binary search instead of linear.  This means for example that the worst
-case for a 1000 item property is 10 probes instead of 1000.  This
-inefficiency has been compensated for in the past by permanently storing
-in a hash the results of a given probe plus the results for the adjacent
-64 code points, under the theory that near-by code points are likely to
-be searched for.  A separate hash was used for each mention of a Unicode
-property in each regular expression.  Thus, C<qr/\p{foo}abc\p{foo}/>
-would generate two hashes.  Any probes in one instance would be unknown
-to the other, and the hashes could expand separately to be quite large
-if the regular expression were used on many different widely-separated
-code points.
-Now, however, there is just one hash shared by all instances of a given
-property.  This means that if C<\p{foo}> is matched against "A" in one
-regular expression in a thread, the result will be known immediately to
-all regular expressions, and the relentless march of using up memory is
-slowed considerably.
+[ List each enhancement as a =item entry ]
 
-=item *
-
-Version declarations with the C<use> keyword (e.g., C<use 5.012>) are now
-faster, as they enable features without loading F<feature.pm>.
-
-=item *
-
-C<local $_> is faster now, as it no longer iterates through magic that it
-is not going to copy anyway.
-
-=item *
-
-Perl 5.12.0 sped up the destruction of objects whose classes define
-empty C<DESTROY> methods (to prevent autoloading), by simply not
-calling such empty methods.  This release takes this optimization a
-step further, by not calling any C<DESTROY> method that begins with a
-C<return> statement.  This can be useful for destructors that are only
-used for debugging:
-
-    use constant DEBUG => 1;
-    sub DESTROY { return unless DEBUG; ... }
-
-Constant-folding will reduce the first statement to C<return;> if DEBUG
-is set to 0, triggering this optimization.
-
-=item *
-
-Assigning to a variable that holds a typeglob or copy-on-write scalar
-is now much faster.  Previously the typeglob would be stringified or
-the copy-on-write scalar would be copied before being clobbered.
-
-=item *
-
-Assignment to C<substr> in void context is now more than twice its
-previous speed.  Instead of creating and returning a special lvalue
-scalar that is then assigned to, C<substr> modifies the original string
-itself.
-
-=item *
-
-C<substr> no longer calculates a value to return when called in void
-context.
-
-=item *
-
-Due to changes in L<File::Glob>, Perl's C<glob> function and its C<<
-<...> >> equivalent are now much faster.  The splitting of the pattern
-into words has been rewritten in C, resulting in speed-ups of 20% for
-some cases.
-
-This does not affect C<glob> on VMS, as it does not use File::Glob.
-
-=item *
-
-The short-circuiting operators C<&&>, C<||>, and C<//>, when chained
-(such as C<$a || $b || $c>), are now considerably faster to short-circuit,
-due to reduced optree traversal.
-
-=item *
-
-The implementation of C<s///r> makes one fewer copy of the scalar's value.
+=over 4
 
 =item *
 
-Recursive calls to lvalue subroutines in lvalue scalar context use less
-memory.
+XXX
 
 =back
 
 =head1 Modules and Pragmata
 
-=head2 Deprecated Modules
-
-=over
+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 L<Version::Requirements>
-
-Version::Requirements is now DEPRECATED, use L<CPAN::Meta::Requirements>,
-which is a drop-in replacement.  It will be deleted from perl.git blead
-in v5.17.0.
-
-=back
+[ Within each section, list entries as a =item entry ]
 
 =head2 New Modules and Pragmata
 
@@ -968,894 +87,87 @@ in v5.17.0.
 
 =item *
 
-L<arybase> -- this new module implements the C<$[> variable.
-
-=item *
-
-L<PerlIO::mmap> 0.010 has been added to the Perl core.
-
-The C<mmap> PerlIO layer is no longer implemented by perl itself, but has
-been moved out into the new L<PerlIO::mmap> module.
+XXX
 
 =back
 
 =head2 Updated Modules and Pragmata
 
-This is only an overview of selected module updates.  For a complete list of
-updates, run:
-
-    $ corelist --diff 5.14.0 5.16.0
-
-You can substitute your favorite version in place of 5.14.0, too.
-
 =over 4
 
 =item *
 
-L<Archive::Extract> has been upgraded from version 0.48 to 0.58.
-
-Includes a fix for FreeBSD to only use C<unzip> if it is located in
-C</usr/local/bin>, as FreeBSD 9.0 will ship with a limited C<unzip> in
-C</usr/bin>.
-
-=item *
-
-L<Archive::Tar> has been upgraded from version 1.76 to 1.82.
-
-Adjustments to handle files >8gb (>0777777777777 octal) and a feature
-to return the MD5SUM of files in the archive.
-
-=item *
-
-L<base> has been upgraded from version 2.16 to 2.18.
-
-C<base> no longer sets a module's C<$VERSION> to "-1" when a module it
-loads does not define a C<$VERSION>.  This change has been made because
-"-1" is not a valid version number under the new "lax" criteria used
-internally by C<UNIVERSAL::VERSION>.  (See L<version> for more on "lax"
-version criteria.)
-
-C<base> no longer internally skips loading modules it has already loaded
-and instead relies on C<require> to inspect C<%INC>.  This fixes a bug
-when C<base> is used with code that clear C<%INC> to force a module to
-be reloaded.
-
-=item *
-
-L<Carp> has been upgraded from version 1.20 to 1.26.
-
-It now includes last read filehandle info and puts a dot after the file
-and line number, just like errors from C<die> [perl #106538].
-
-=item *
-
-L<charnames> has been updated from version 1.18 to 1.30.
-
-C<charnames> can now be invoked with a new option, C<:loose>,
-which is like the existing C<:full> option, but enables Unicode loose
-name matching.  Details are in L<charnames/LOOSE MATCHES>.
-
-=item *
-
-L<B::Deparse> has been upgraded from version 1.03 to 1.14.  This fixes
-numerous deparsing bugs.
-
-=item *
-
-L<CGI> has been upgraded from version 3.52 to 3.59.
-
-It uses the public and documented FCGI.pm API in CGI::Fast.  CGI::Fast was
-using an FCGI API that was deprecated and removed from documentation
-more than ten years ago.  Usage of this deprecated API with FCGI E<gt>=
-0.70 or FCGI E<lt>= 0.73 introduces a security issue.
-L<https://rt.cpan.org/Public/Bug/Display.html?id=68380>
-L<http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-2766>
-
-Things that may break your code:
-
-C<url()> was fixed to return C<PATH_INFO> when it is explicitly requested
-with either the C<path=E<gt>1> or C<path_info=E<gt>1> flag.
-
-If your code is running under mod_rewrite (or compatible) and you are
-calling C<self_url()> or you are calling C<url()> and passing
-C<path_info=E<gt>1>, these methods will actually be returning
-C<PATH_INFO> now, as you have explicitly requested or C<self_url()>
-has requested on your behalf.
-
-The C<PATH_INFO> has been omitted in such URLs since the issue was
-introduced in the 3.12 release in December, 2005.
-
-This bug is so old your application may have come to depend on it or
-workaround it. Check for application before upgrading to this release.
-
-Examples of affected method calls:
-
-  $q->url(-absolute => 1, -query => 1, -path_info => 1);
-  $q->url(-path=>1);
-  $q->url(-full=>1,-path=>1);
-  $q->url(-rewrite=>1,-path=>1);
-  $q->self_url();
-
-We no longer read from STDIN when the Content-Length is not set,
-preventing requests with no Content-Length from sometimes freezing.
-This is consistent with the CGI RFC 3875, and is also consistent with
-CGI::Simple.  However, the old behavior may have been expected by some
-command-line uses of CGI.pm.
-
-In addition, the DELETE HTTP verb is now supported.
-
-=item *
-
-L<Compress::Zlib> has been upgraded from version 2.035 to 2.048.
-
-IO::Compress::Zip and IO::Uncompress::Unzip now have support for LZMA
-(method 14).  There is a fix for a CRC issue in IO::Compress::Unzip and
-it supports Streamed Stored context now.  And fixed a Zip64 issue in
-IO::Compress::Zip when the content size was exactly 0xFFFFFFFF.
-
-=item *
-
-L<Digest::SHA> has been upgraded from version 5.61 to 5.71.
-
-Added BITS mode to the addfile method and shasum.  This makes
-partial-byte inputs possible via files/STDIN and lets shasum check
-all 8074 NIST Msg vectors, where previously special programming was
-required to do this.
-
-=item *
-
-L<Encode> has been upgraded from version 2.42 to 2.44.
-
-Missing aliases added, a deep recursion error fixed and various
-documentation updates.
-
-Addressed 'decode_xs n-byte heap-overflow' security bug in Unicode.xs
-(CVE-2011-2939). (5.14.2)
-
-=item *
-
-L<ExtUtils::CBuilder> updated from version 0.280203 to 0.280206.
-
-The new version appends CFLAGS and LDFLAGS to their Config.pm
-counterparts.
-
-=item *
-
-L<ExtUtils::ParseXS> has been upgraded from version 2.2210 to 3.16.
-
-Much of L<ExtUtils::ParseXS>, the module behind the XS compiler C<xsubpp>,
-was rewritten and cleaned up.  It has been made somewhat more extensible
-and now finally uses strictures.
-
-The typemap logic has been moved into a separate module,
-L<ExtUtils::Typemaps>.  See L</New Modules and Pragmata>, above.
-
-For a complete set of changes, please see the ExtUtils::ParseXS
-changelog, available on the CPAN.
-
-=item *
-
-L<File::Glob> has been upgraded from version 1.12 to 1.17.
-
-On Windows, tilde (~) expansion now checks the C<USERPROFILE> environment
-variable, after checking C<HOME>.
-
-It has a new C<:bsd_glob> export tag, intended to replace C<:glob>.  Like
-C<:glob> it overrides C<glob> with a function that does not split the glob
-pattern into words, but, unlike C<:glob>, it iterates properly in scalar
-context, instead of returning the last file.
-
-There are other changes affecting Perl's own C<glob> operator (which uses
-File::Glob internally, except on VMS).  See L</Performance Enhancements>
-and L</Selected Bug Fixes>.
-
-=item *
-
-L<FindBin> updated from version 1.50 to 1.51.
-
-It no longer returns a wrong result if a script of the same name as the
-current one exists in the path and is executable.
-
-=item *
-
-L<HTTP::Tiny> has been upgraded from version 0.012 to 0.017.
-
-Added support for using C<$ENV{http_proxy}> to set the default proxy host.
-
-Adds additional shorthand methods for all common HTTP verbs,
-a C<post_form()> method for POST-ing x-www-form-urlencoded data and
-a C<www_form_urlencode()> utility method.
-
-=item *
-
-L<IO> has been upgraded from version 1.25_04 to 1.25_06, and L<IO::Handle>
-from version 1.31 to 1.33.
-
-Together, these upgrades fix a problem with IO::Handle's C<getline> and
-C<getlines> methods.  When these methods are called on the special ARGV
-handle, the next file is automatically opened, as happens with the built-in
-C<E<lt>E<gt>> and C<readline> functions.  But, unlike the built-ins, these
-methods were not respecting the caller's use of the L<open> pragma and
-applying the appropriate I/O layers to the newly-opened file
-[rt.cpan.org #66474].
-
-=item *
-
-L<IPC::Cmd> has been upgraded from version 0.70 to 0.76.
-
-Capturing of command output (both C<STDOUT> and C<STDERR>) is now supported
-using L<IPC::Open3> on MSWin32 without requiring L<IPC::Run>.
-
-=item *
-
-L<IPC::Open3> has been upgraded from version 1.09 to 1.12.
-
-Fixes a bug which prevented use of C<open3> on Windows when C<*STDIN>,
-C<*STDOUT> or C<*STDERR> had been localized.
-
-Fixes a bug which prevented duplicating numeric file descriptors on Windows.
-
-C<open3> with "-" for the program name works once more.  This was broken in
-version 1.06 (and hence in Perl 5.14.0) [perl #95748].
-
-=item *
-
-L<Locale::Codes> has been upgraded from version 3.16 to 3.21.
-
-Added Language Extension codes (langext) and Language Variation codes (langvar)
-as defined in the IANA language registry.
-
-Added language codes from ISO 639-5
-
-Added language/script codes from the IANA language subtag registry
-
-Fixed an uninitialized value warning [rt.cpan.org #67438].
-
-Fixed the return value for the all_XXX_codes and all_XXX_names functions
-[rt.cpan.org #69100].
-
-Reorganized modules to move Locale::MODULE to Locale::Codes::MODULE to allow
-for cleaner future additions.  The original four modules (Locale::Language,
-Locale::Currency, Locale::Country, Locale::Script) will continue to work, but
-all new sets of codes will be added in the Locale::Codes namespace.
-
-The code2XXX, XXX2code, all_XXX_codes, and all_XXX_names functions now
-support retired codes.  All codesets may be specified by a constant or
-by their name now.  Previously, they were specified only by a constant.
-
-The alias_code function exists for backward compatibility.  It has been
-replaced by rename_country_code.  The alias_code function will be
-removed some time after September, 2013.
-
-All work is now done in the central module (Locale::Codes).  Previously,
-some was still done in the wrapper modules (Locale::Codes::*).  Added
-Language Family codes (langfam) as defined in ISO 639-5.
-
-=item *
-
-L<Math::BigFloat> has been upgraded from version 1.993 to 1.997.
-
-The C<numify> method has been corrected to return a normalized Perl number
-(the result of C<0 + $thing>), instead of a string [rt.cpan.org #66732].
-
-=item *
-
-L<Math::BigInt> has been upgraded from version 1.994 to 1.998.
-
-It provides a new C<bsgn> method that complements the C<babs> method.
-
-It fixes the internal C<objectify> function's handling of "foreign objects"
-so they are converted to the appropriate class (Math::BigInt or
-Math::BigFloat).
-
-=item *
-
-L<Math::BigRat> has been upgraded from version 0.2602 to 0.2603.
-
-C<int()> on a Math::BigRat object containing -1/2 now creates a
-Math::BigInt containing 0, rather than -0.  L<Math::BigInt> does not even
-support negative zero, so the resulting object was actually malformed
-[perl #95530].
-
-=item *
-
-L<Math::Complex> has been upgraded from version 1.56 to 1.59
-and L<Math::Trig> from version 1.2 to 1.22.
-
-Fixes include: correct copy constructor usage; fix polarwise formatting with
-numeric format specifier; and more stable C<great_circle_direction> algorithm.
-
-=item *
-
-L<Module::CoreList> has been upgraded from version 2.51 to 2.66.
-
-The C<corelist> utility now understands the C<-r> option for displaying
-Perl release dates and the C<--diff> option to print the set of modlib
-changes between two perl distributions.
-
-=item *
-
-L<Module::Metadata> has been upgraded from version 1.000004 to 1.000009.
-
-Adds C<provides> method to generate a CPAN META provides data structure
-correctly; use of C<package_versions_from_directory> is discouraged.
-
-=item *
-
-L<ODBM_File> has been upgraded from version 1.10 to 1.12.
-
-The XS code is now compiled with C<PERL_NO_GET_CONTEXT>, which will aid
-performance under ithreads.
-
-=item *
-
-L<open> has been upgraded from version 1.08 to 1.10.
-
-It no longer turns off layers on standard handles when invoked without the
-":std" directive.  Similarly, when invoked I<with> the ":std" directive, it
-now clears layers on STDERR before applying the new ones, and not just on
-STDIN and STDOUT [perl #92728].
-
-=item *
-
-L<overload> has been upgraded from version 1.13 to 1.18.
-
-C<overload::Overloaded> no longer calls C<can> on the class, but uses
-another means to determine whether the object has overloading.  It was
-never correct for it to call C<can>, as overloading does not respect
-AUTOLOAD.  So classes that autoload methods and implement C<can> no longer
-have to account for overloading [perl #40333].
-
-A warning is now produced for invalid arguments.  See L</New Diagnostics>.
-
-=item *
-
-L<PerlIO::scalar> has been upgraded from version 0.11 to 0.14.
-
-(This is the module that implements C<< open $fh, '>', \$scalar >>.)
-
-It fixes a problem with C<< open my $fh, ">", \$scalar >> not working if
-C<$scalar> is a copy-on-write scalar. (5.14.2)
-
-It also fixes a hang that occurs with C<readline> or C<< <$fh> >> if a
-typeglob has been assigned to $scalar [perl #92258].
-
-It no longer assumes during C<seek> that $scalar is a string internally.
-If it didn't crash, it was close to doing so [perl #92706].  Also, the
-internal print routine no longer assumes that the position set by C<seek>
-is valid, but extends the string to that position, filling the intervening
-bytes (between the old length and the seek position) with nulls
-[perl #78980].
-
-Printing to an in-memory handle now works if the $scalar holds a reference,
-stringifying the reference before modifying it.  References used to be
-treated as empty strings.
-
-Printing to an in-memory handle no longer crashes if the $scalar happens to
-hold a number internally, but no string buffer.
-
-Printing to an in-memory handle no longer creates scalars that confuse
-the regular expression engine [perl #108398].
-
-=item *
-
-L<Pod::Functions> has been upgraded from version 1.04 to 1.05.
-
-F<Functions.pm> is now generated at perl build time from annotations in
-F<perlfunc.pod>.  This will ensure that L<Pod::Functions> and L<perlfunc>
-remain in synchronisation.
-
-=item *
-
-L<Pod::Html> has been upgraded from version 1.11 to 1.1502.
-
-This is an extensive rewrite of Pod::Html to use L<Pod::Simple> under
-the hood.  The output has changed significantly.
-
-=item *
-
-L<Pod::Perldoc> has been upgraded from version 3.15_03 to 3.17.
-
-It corrects the search paths on VMS [perl #90640]. (5.14.1)
-
-The B<-v> option now fetches the right section for C<$0>.
-
-This upgrade has numerous significant fixes.  Consult its changelog on
-the CPAN for more information.
-
-=item *
-
-L<POSIX> has been upgraded from version 1.24 to 1.30.
-
-L<POSIX> no longer uses L<AutoLoader>.  Any code which was relying on this
-implementation detail was buggy, and may fail because of this change.
-The module's Perl code has been considerably simplified, roughly halving
-the number of lines, with no change in functionality.  The XS code has
-been refactored to reduce the size of the shared object by about 12%,
-with no change in functionality.  More POSIX functions now have tests.
-
-C<sigsuspend> and C<pause> now run signal handlers before returning, as the
-whole point of these two functions is to wait until a signal has
-arrived, and then return I<after> it has been triggered.  Delayed, or
-"safe", signals were preventing that from happening, possibly resulting in
-race conditions [perl #107216].
-
-C<POSIX::sleep> is now a direct call into the underlying OS C<sleep>
-function, instead of being a Perl wrapper on C<CORE::sleep>.
-C<POSIX::dup2> now returns the correct value on Win32 (I<i.e.>, the file
-descriptor).  C<POSIX::SigSet> C<sigsuspend> and C<sigpending> and
-C<POSIX::pause> now dispatch safe signals immediately before returning to
-their caller.
-
-C<POSIX::Termios::setattr> now defaults the third argument to C<TCSANOW>,
-instead of 0. On most platforms C<TCSANOW> is defined to be 0, but on some
-0 is not a valid parameter, which caused a call with defaults to fail.
-
-=item *
-
-L<Socket> has been upgraded from version 1.94 to 2.001.
-
-It has new functions and constants for handling IPv6 sockets:
-
-    pack_ipv6_mreq
-    unpack_ipv6_mreq
-    IPV6_ADD_MEMBERSHIP
-    IPV6_DROP_MEMBERSHIP
-    IPV6_MTU
-    IPV6_MTU_DISCOVER
-    IPV6_MULTICAST_HOPS
-    IPV6_MULTICAST_IF
-    IPV6_MULTICAST_LOOP
-    IPV6_UNICAST_HOPS
-    IPV6_V6ONLY
-
-=item *
-
-L<Storable> has been upgraded from version 2.27 to 2.34.
-
-It no longer turns copy-on-write scalars into read-only scalars when
-freezing and thawing.
-
-=item *
-
-L<Sys::Syslog> has been upgraded from version 0.27 to 0.29.
-
-This upgrade closes many outstanding bugs.
-
-=item *
-
-L<Term::ANSIColor> has been upgraded from version 3.00 to 3.01.
-
-Only interpret an initial array reference as a list of colors, not any initial
-reference, allowing the colored function to work properly on objects with
-stringification defined.
-
-=item *
-
-L<Term::ReadLine> has been upgraded from version 1.07 to 1.09.
-
-Term::ReadLine now supports any event loop, including unpublished ones and
-simple L<IO::Select>, loops without the need to rewrite existing code for
-any particular framework [perl #108470].
-
-=item *
-
-L<threads::shared> has been upgraded from version 1.37 to 1.40.
-
-Destructors on shared objects used to be ignored sometimes if the objects
-were referenced only by shared data structures.  This has been mostly
-fixed, but destructors may still be ignored if the objects still exist at
-global destruction time [perl #98204].
-
-=item *
-
-L<Unicode::Collate> has been upgraded from version 0.73 to 0.89.
-
-Updated to CLDR 1.9.1
-
-Locales updated to CLDR 2.0: mk, mt, nb, nn, ro, ru, sk, sr, sv, uk,
-zh__pinyin, zh__stroke
-
-Newly supported locales: bn, fa, ml, mr, or, pa, sa, si, si__dictionary,
-sr_Latn, sv__reformed, ta, te, th, ur, wae.
-
-Tailored compatibility ideographs as well as unified ideographs for the
-locales: ja, ko, zh__big5han, zh__gb2312han, zh__pinyin, zh__stroke.
-
-Locale/*.pl files are now searched for in @INC.
-
-=item *
-
-L<Unicode::Normalize> has been upgraded from version 1.10 to 1.14.
-
-Fixes for the removal of F<unicore/CompositionExclusions.txt> from core.
-
-=item *
-
-L<Unicode::UCD> has been upgraded from version 0.32 to 0.43.
-
-This adds four new functions:  C<prop_aliases()> and
-C<prop_value_aliases()>, which are used to find all Unicode-approved
-synonyms for property names, or to convert from one name to another;
-C<prop_invlist> which returns all code points matching a given
-Unicode binary property; and C<prop_invmap> which returns the complete
-specification of a given Unicode property.
-
-=item *
-
-L<Win32API::File> has been upgraded from version 0.1101 to 0.1200.
-
-Added SetStdHandle and GetStdHandle functions
+L<XXX> has been upgraded from version 0.69 to version 0.70.
 
 =back
 
 =head2 Removed Modules and Pragmata
 
-As promised in Perl 5.14.0's release notes, the following modules have
-been removed from the core distribution, and if needed should be installed
-from CPAN instead.
-
-=over
-
-=item *
-
-L<Devel::DProf> has been removed from the Perl core.  Prior version was
-20110228.00.
-
-=item *
-
-L<Shell> has been removed from the Perl core.  Prior version was 0.72_01.
+=over 4
 
 =item *
 
-Several old perl4-style libraries which have been deprecated with 5.14
-are now removed:
-
-    abbrev.pl assert.pl bigfloat.pl bigint.pl bigrat.pl cacheout.pl
-    complete.pl ctime.pl dotsh.pl exceptions.pl fastcwd.pl flush.pl
-    getcwd.pl getopt.pl getopts.pl hostname.pl importenv.pl
-    lib/find{,depth}.pl look.pl newgetopt.pl open2.pl open3.pl
-    pwd.pl shellwords.pl stat.pl tainted.pl termcap.pl timelocal.pl
-
-They can be found on CPAN as L<Perl4::CoreLibs>.
+XXX
 
 =back
 
 =head1 Documentation
 
-=head2 New Documentation
-
-=head3 L<perldtrace>
-
-L<perldtrace> describes Perl's DTrace support, listing the provided probes
-and gives examples of their use.
-
-=head3 L<perlexperiment>
+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>.
 
-This document is intended to provide a list of experimental features in
-Perl.  It is still a work in progress.
-
-=head3 L<perlootut>
+=head2 New Documentation
 
-This a new OO tutorial.  It focuses on basic OO concepts, and then recommends
-that readers choose an OO framework from CPAN.
+XXX Changes which create B<new> files in F<pod/> go here.
 
-=head3 L<perlxstypemap>
+=head3 L<XXX>
 
-The new manual describes the XS typemapping mechanism in unprecedented
-detail and combines new documentation with information extracted from
-L<perlxs> and the previously unofficial list of all core typemaps.
+XXX Description of the purpose of the new file here
 
 =head2 Changes to Existing Documentation
 
-=head3 L<perlapi>
-
-=over 4
-
-=item *
-
-The HV API has long accepted negative lengths to show that the key is
-in UTF8.  This is now documented.
-
-=item *
-
-The C<boolSV()> macro is now documented.
-
-=back
-
-=head3 L<perlfunc>
-
-=over 4
-
-=item *
-
-C<dbmopen> treats a 0 mode as a special case, that prevents a nonexistent
-file from being created.  This has been the case since Perl 5.000, but was
-never documented anywhere.  Now the perlfunc entry mentions it
-[perl #90064].
-
-=item *
-
-As an accident of history, C<open $fh, '<:', ...> applies the default
-layers for the platform (C<:raw> on Unix, C<:crlf> on Windows), ignoring
-whatever is declared by L<open.pm|open>.  This seems such a useful feature
-it has been documented in L<perlfunc|perlfunc/open> and L<open>.
-
-=item *
-
-The entry for C<split> has been rewritten.  It is now far clearer than
-before.
-
-=back
-
-=head3 L<perlguts>
-
-=over 4
-
-=item *
-
-A new section, L<Autoloading with XSUBs|perlguts/Autoloading with XSUBs>,
-has been added, which explains the two APIs for accessing the name of the
-autoloaded sub.
-
-=item *
-
-Some function descriptions in L<perlguts> were confusing, as it was
-not clear whether they referred to the function above or below the
-description.  This has been clarified [perl #91790].
-
-=back
+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.
 
-=head3 L<perlobj>
+=head3 L<XXX>
 
 =over 4
 
 =item *
 
-This document has been rewritten from scratch, and its coverage of various OO
-concepts has been expanded.
+XXX Description of the change here
 
 =back
 
-=head3 L<perlop>
-
-=over 4
-
-=item *
-
-Documentation of the smartmatch operator has been reworked and moved from
-perlsyn to perlop where it belongs.
-
-It has also been corrected for the case of C<undef> on the left-hand
-side.  The list of different smart match behaviors had an item in the
-wrong place.
-
-=item *
-
-Documentation of the ellipsis statement (C<...>) has been reworked and
-moved from perlop to perlsyn.
-
-=item *
-
-The explanation of bitwise operators has been expanded to explain how they
-work on Unicode strings (5.14.1).
-
-=item *
-
-More examples for C<m//g> have been added (5.14.1).
-
-=item *
-
-The C<<< <<\FOO >>> here-doc syntax has been documented (5.14.1).
-
-=back
-
-=head3 L<perlpragma>
-
-=over 4
-
-=item *
-
-There is now a standard convention for naming keys in the C<%^H>,
-documented under L<Key naming|perlpragma/Key naming>.
-
-=back
-
-=head3 L<perlsec/Laundering and Detecting Tainted Data>
-
-=over 4
-
-=item *
-
-The example function for checking for taintedness contained a subtle
-error.  C<$@> needs to be localized to prevent its changing this
-global's value outside the function.  The preferred method to check for
-this remains L<Scalar::Util/tainted>.
-
-=back
-
-=head3 L<perllol>
-
-=over
-
-=item *
-
-L<perllol> has been expanded with examples using the new C<push $scalar>
-syntax introduced in Perl 5.14.0 (5.14.1).
-
-=back
-
-=head3 L<perlmod>
-
-=over
-
-=item *
-
-L<perlmod> now states explicitly that some types of explicit symbol table
-manipulation are not supported.  This codifies what was effectively already
-the case [perl #78074].
-
-=back
-
-=head3 L<perlpodstyle>
-
-=over 4
-
-=item *
-
-The tips on which formatting codes to use have been corrected and greatly
-expanded.
-
-=item *
-
-There are now a couple of example one-liners for previewing POD files after
-they have been edited.
-
-=back
-
-=head3 L<perlre>
-
-=over
-
-=item *
-
-The C<(*COMMIT)> directive is now listed in the right section
-(L<Verbs without an argument|perlre/Verbs without an argument>).
-
-=back
-
-=head3 L<perlrun>
-
-=over
-
-=item *
-
-L<perlrun> has undergone a significant clean-up.  Most notably, the
-B<-0x...> form of the B<-0> flag has been clarified, and the final section
-on environment variables has been corrected and expanded (5.14.1).
-
-=back
-
-=head3 L<perlsub>
-
-=over
-
-=item *
-
-The ($;) prototype syntax, which has existed for rather a long time, is now
-documented in L<perlsub>.  It lets a unary function have the same
-precedence as a list operator.
-
-=back
-
-=head3 L<perltie>
-
-=over
-
-=item *
-
-The required syntax for tying handles has been documented.
-
-=back
-
-=head3 L<perlvar>
-
-=over
-
-=item *
-
-The documentation for L<$!|perlvar/$!> has been corrected and clarified.
-It used to state that $! could be C<undef>, which is not the case.  It was
-also unclear whether system calls set C's C<errno> or Perl's C<$!>
-[perl #91614].
-
-=item *
-
-Documentation for L<$$|perlvar/$$> has been amended with additional
-cautions regarding changing the process ID.
-
-=back
-
-=head3 Other Changes
-
-=over 4
-
-=item *
-
-L<perlxs> was extended with documentation on inline typemaps.
-
-=item *
-
-L<perlref> has a new L<Circular References|perlref/Circular References>
-section explaining how circularities may not be freed and how to solve that
-with weak references.
-
-=item *
-
-Parts of L<perlapi> were clarified, and Perl equivalents of some C
-functions have been added as an additional mode of exposition.
-
-=item *
-
-A few parts of L<perlre> and L<perlrecharclass> were clarified.
-
-=back
-
-=head2 Removed Documentation
-
-=head3 Old OO Documentation
-
-The old OO tutorials, perltoot, perltooc, and perlboot, have been
-removed.  The perlbot (bag of object tricks) document has been removed
-as well.
-
-=head3 Development Deltas
-
-The perldelta files for development releases are no longer packaged with
-perl.  These can still be found in the perl source code repository.
-
 =head1 Diagnostics
 
 The following additions or changes have been made to diagnostic output,
 including warnings and fatal error messages.  For the complete list of
 diagnostic messages, see L<perldiag>.
 
-=head2 New Diagnostics
-
-=head3 New Errors
-
-=over 4
-
-=item *
-
-L<Cannot set tied @DB::args|perldiag/"Cannot set tied @DB::args">
+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.
 
-This error occurs when C<caller> tries to set C<@DB::args> but finds it
-tied.  Before this error was added, it used to crash instead.
+[ Within each section, list entries as a =item entry that links to perldiag,
+  e.g.
 
-=item *
+  =item *
 
-L<Cannot tie unreifiable array|perldiag/"Cannot tie unreifiable array">
+  L<Invalid version object|perldiag/"Invalid version object">
+]
 
-This error is part of a safety check that the C<tie> operator does before
-tying a special array like C<@_>.  You should never see this message.
+=head2 New Diagnostics
 
-=item *
+XXX Newly added diagnostic messages go here
 
-L<&CORE::%s cannot be called directly|perldiag/"&CORE::%s cannot be called directly">
+=head3 New Errors
 
-This occurs when a subroutine in the C<CORE::> namespace is called
-with C<&foo> syntax or through a reference.  Some subroutines
-in this package cannot yet be called that way, but must be
-called as barewords.  See L</Subroutines in the C<CORE> namespace>, above.
+=over 4
 
 =item *
 
-L<Source filters apply only to byte streams|perldiag/"Source filters apply only to byte streams">
-
-This new error occurs when you try to activate a source filter (usually by
-loading a source filter module) within a string passed to C<eval> under the
-C<unicode_eval> feature.
+XXX L<message|perldiag/"message">
 
 =back
 
@@ -1865,2435 +177,193 @@ C<unicode_eval> feature.
 
 =item *
 
-L<defined(@array) is deprecated|perldiag/"defined(@array) is deprecated">
-
-The long-deprecated C<defined(@array)> now also warns for package variables.
-Previously it issued a warning for lexical variables only.
-
-=item *
-
-L<length() used on %s|perldiag/length() used on %s>
-
-This new warning occurs when C<length> is used on an array or hash, instead
-of C<scalar(@array)> or C<scalar(keys %hash)>.
-
-=item *
-
-L<lvalue attribute %s already-defined subroutine|perldiag/"lvalue attribute %s already-defined subroutine">
-
-L<attributes.pm|attributes> now emits this warning when the :lvalue
-attribute is applied to a Perl subroutine that has already been defined, as
-doing so can have unexpected side-effects.
-
-=item *
-
-L<overload arg '%s' is invalid|perldiag/"overload arg '%s' is invalid">
-
-This warning, in the "overload" category, is produced when the overload
-pragma is given an argument it doesn't recognize, presumably a mistyped
-operator.
-
-=item *
-
-L<$[ used in %s (did you mean $] ?)|perldiag/"$[ used in %s (did you mean $] ?)">
-
-This new warning exists to catch the mistaken use of C<$[> in version
-checks.  C<$]>, not C<$[>, contains the version number.
-
-=item *
-
-L<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
-
-Assigning to a temporary scalar returned
-from an lvalue subroutine now produces this
-warning [perl #31946].
-
-=item *
-
-L<Useless use of \E|perldiag/"Useless use of \E">
-
-C<\E> does nothing unless preceded by C<\Q>, C<\L> or C<\U>.
-
-=back
-
-=head2 Removed Errors
-
-=over
-
-=item *
-
-"sort is now a reserved word"
-
-This error used to occur when C<sort> was called without arguments,
-followed by C<;> or C<)>.  (E.g., C<sort;> would die, but C<{sort}> was
-OK.)  This error message was added in Perl 3 to catch code like
-C<close(sort)> which would no longer work.  More than two decades later,
-this message is no longer appropriate.  Now C<sort> without arguments is
-always allowed, and returns an empty list, as it did in those cases
-where it was already allowed [perl #90030].
+XXX L<message|perldiag/"message">
 
 =back
 
 =head2 Changes to Existing Diagnostics
 
-=over 4
-
-=item *
-
-The "Applying pattern match..." or similar warning produced when an
-array or hash is on the left-hand side of the C<=~> operator now
-mentions the name of the variable.
-
-=item *
-
-The "Attempt to free non-existent shared string" has had the spelling
-of "non-existent" corrected to "nonexistent".  It was already listed
-with the correct spelling in L<perldiag>.
-
-=item *
-
-The error messages for using C<default> and C<when> outside a
-topicalizer have been standardized to match the messages for C<continue>
-and loop controls.  They now read 'Can't "default" outside a
-topicalizer' and 'Can't "when" outside a topicalizer'.  They both used
-to be 'Can't use when() outside a topicalizer' [perl #91514].
-
-=item *
-
-The message, "Code point 0x%X is not Unicode, no properties match it;
-all inverse properties do" has been changed to "Code point 0x%X is not
-Unicode, all \p{} matches fail; all \P{} matches succeed".
-
-=item *
-
-Redefinition warnings for constant subroutines used to be mandatory,
-even occurring under C<no warnings>.  Now they respect the L<warnings>
-pragma.
-
-=item *
-
-The "glob failed" warning message is now suppressible via C<no warnings>
-[perl #111656].
-
-=item *
-
-The L<Invalid version format|perldiag/"Invalid version format (%s)">
-error message now says "negative version number" within the parentheses,
-rather than "non-numeric data", for negative numbers.
-
-=item *
-
-The two warnings
-L<Possible attempt to put comments in qw() list|perldiag/"Possible attempt to put comments in qw() list">
-and
-L<Possible attempt to separate words with commas|perldiag/"Possible attempt to separate words with commas">
-are no longer mutually exclusive: the same C<qw> construct may produce
-both.
-
-=item *
-
-The uninitialized warning for C<y///r> when C<$_> is implicit and
-undefined now mentions the variable name, just like the non-/r variation
-of the operator.
-
-=item *
-
-The 'Use of "foo" without parentheses is ambiguous' warning has been
-extended to apply also to user-defined subroutines with a (;$)
-prototype, and not just to built-in functions.
-
-=item *
-
-Warnings that mention the names of lexical (C<my>) variables with
-Unicode characters in them now respect the presence or absence of the
-C<:utf8> layer on the output handle, instead of outputting UTF8
-regardless.  Also, the correct names are included in the strings passed
-to C<$SIG{__WARN__}> handlers, rather than the raw UTF8 bytes.
-
-=back
-
-=head1 Utility Changes
-
-=head3 L<h2ph>
+XXX Changes (i.e. rewording) of diagnostic messages go here
 
 =over 4
 
 =item *
 
-L<h2ph> used to generate code of the form
-
-  unless(defined(&FOO)) {
-    sub FOO () {42;}
-  }
-
-But the subroutine is a compile-time declaration, and is hence unaffected
-by the condition.  It has now been corrected to emit a string C<eval>
-around the subroutine [perl #99368].
+XXX Describe change here
 
 =back
 
-=head3 L<splain>
-
-=over 4
-
-=item *
-
-F<splain> no longer emits backtraces with the first line number repeated.
-
-This:
-
-    Uncaught exception from user code:
-            Cannot fwiddle the fwuddle at -e line 1.
-     at -e line 1
-            main::baz() called at -e line 1
-            main::bar() called at -e line 1
-            main::foo() called at -e line 1
-
-has become this:
-
-    Uncaught exception from user code:
-            Cannot fwiddle the fwuddle at -e line 1.
-            main::baz() called at -e line 1
-            main::bar() called at -e line 1
-            main::foo() called at -e line 1
+=head1 Utility Changes
 
-=item *
+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>.
 
-Some error messages consist of multiple lines that are listed as separate
-entries in L<perldiag>.  splain has been taught to find the separate
-entries in these cases, instead of simply failing to find the message.
+[ 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. ]
 
-=back
-
-=head3 L<zipdetails>
+=head3 L<XXX>
 
 =over 4
 
 =item *
 
-This is a new utility, included as part of an
-L<IO::Compress::Base> upgrade.
-
-L<zipdetails> displays information about the internal record structure
-of the zip file.  It is not concerned with displaying any details of
-the compressed data stored in the zip file.
+XXX
 
 =back
 
 =head1 Configuration and Compilation
 
-=over 4
-
-=item *
-
-F<regexp.h> has been modified for compatibility with GCC's B<-Werror>
-option, as used by some projects that include perl's header files (5.14.1).
-
-=item *
-
-C<USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}> have been added the output of perl -V
-as they have affect the behavior of the interpreter binary (albeit
-in only a small area).
-
-=item *
-
-The code and tests for L<IPC::Open2> have been moved from F<ext/IPC-Open2>
-into F<ext/IPC-Open3>, as C<IPC::Open2::open2()> is implemented as a thin
-wrapper around C<IPC::Open3::_open3()>, and hence is very tightly coupled to
-it.
-
-=item *
-
-The magic types and magic vtables are now generated from data in a new script
-F<regen/mg_vtable.pl>, instead of being maintained by hand.  As different
-EBCDIC variants can't agree on the code point for '~', the character to code
-point conversion is done at build time by F<generate_uudmap> to a new generated
-header F<mg_data.h>.  C<PL_vtbl_bm> and C<PL_vtbl_fm> are now defined by the
-pre-processor as C<PL_vtbl_regexp>, instead of being distinct C variables.
-C<PL_vtbl_sig> has been removed.
-
-=item *
+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.
 
-Building with C<-DPERL_GLOBAL_STRUCT> works again.  This configuration is not
-generally used.
+[ List changes as a =item entry ].
 
-=item *
-
-Perl configured with I<MAD> now correctly frees C<MADPROP> structures when
-OPs are freed.  C<MADPROP>s are now allocated with C<PerlMemShared_malloc()>
-
-=item *
-
-F<makedef.pl> has been refactored.  This should have no noticeable affect on
-any of the platforms that use it as part of their build (AIX, VMS, Win32).
-
-=item *
-
-C<useperlio> can no longer be disabled.
-
-=item *
-
-The file F<global.sym> is no longer needed, and has been removed.  It
-contained a list of all exported functions, one of the files generated by
-F<regen/embed.pl> from data in F<embed.fnc> and F<regen/opcodes>.  The code
-has been refactored so that the only user of F<global.sym>, F<makedef.pl>,
-now reads F<embed.fnc> and F<regen/opcodes> directly, removing the need to
-store the list of exported functions in an intermediate file.
-
-As F<global.sym> was never installed, this change should not be visible
-outside the build process.
-
-=item *
-
-F<pod/buildtoc>, used by the build process to build L<perltoc>, has been
-refactored and simplified.  It now contains only code to build L<perltoc>;
-the code to regenerate Makefiles has been moved to F<Porting/pod_rules.pl>.
-It's a bug if this change has any material effect on the build process.
-
-=item *
-
-F<pod/roffitall> is now built by F<pod/buildtoc>, instead of being
-shipped with the distribution.  Its list of manpages is now generated
-(and therefore current).  See also RT #103202 for an unresolved related
-issue.
-
-=item *
-
-The man page for C<XS::Typemap> is no longer installed.  C<XS::Typemap>
-is a test module which is not installed, hence installing its
-documentation makes no sense.
+=over 4
 
 =item *
 
-The -Dusesitecustomize and -Duserelocatableinc options now work
-together properly.
+XXX
 
 =back
 
-=head1 Platform Support
+=head1 Testing
 
-=head2 Platform-Specific Notes
+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.
 
-=head3 Cygwin
+[ List each test improvement as a =item entry ]
 
 =over 4
 
 =item *
 
-Since version 1.7, Cygwin supports native UTF-8 paths.  If Perl is built
-under that environment, directory and filenames will be UTF-8 encoded.
-
-=item *
-
-Cygwin does not initialize all original Win32 environment variables.  See
-F<README.cygwin> for a discussion of the newly-added
-C<Cygwin::sync_winenv()> function [perl #110190] and for
-further links.
+XXX
 
 =back
 
-=head3 HP-UX
-
-=over 4
-
-=item *
+=head1 Platform Support
 
-HP-UX PA-RISC/64 now supports gcc-4.x
+XXX Any changes to platform support should be listed in the sections below.
 
-A fix to correct the socketsize now makes the test suite pass on HP-UX
-PA-RISC for 64bitall builds. (5.14.2)
+[ Within the sections, list each platform as a =item entry with specific
+changes as paragraphs below it. ]
 
-=back
+=head2 New Platforms
 
-=head3 VMS
+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.
 
 =over 4
 
-=item *
+=item XXX-some-platform
 
-Remove unnecessary includes, fix miscellaneous compiler warnings and
-close some unclosed comments on F<vms/vms.c>.
-
-=item *
-
-Remove sockadapt layer from the VMS build.
-
-=item *
-
-Explicit support for VMS versions before v7.0 and DEC C versions
-before v6.0 has been removed.
-
-=item *
-
-Since Perl 5.10.1, the home-grown C<stat> wrapper has been unable to
-distinguish between a directory name containing an underscore and an
-otherwise-identical filename containing a dot in the same position
-(e.g., t/test_pl as a directory and t/test.pl as a file).  This problem
-has been corrected.
-
-=item *
-
-The build on VMS now permits names of the resulting symbols in C code for
-Perl longer than 31 characters.  Symbols like
-C<Perl__it_was_the_best_of_times_it_was_the_worst_of_times> can now be
-created freely without causing the VMS linker to seize up.
+XXX
 
 =back
 
-=head3 GNU/Hurd
+=head2 Discontinued Platforms
 
-=over 4
-
-=item *
-
-Numerous build and test failures on GNU/Hurd have been resolved with hints
-for building DBM modules, detection of the library search path, and enabling
-of large file support.
-
-=back
-
-=head3 OpenVOS
+XXX List any platforms that this version of perl no longer compiles on.
 
 =over 4
 
-=item *
+=item XXX-some-platform
 
-Perl is now built with dynamic linking on OpenVOS, the minimum supported
-version of which is now Release 17.1.0.
+XXX
 
 =back
 
-=head3 SunOS
-
-The CC workshop C++ compiler is now detected and used on systems that ship
-without cc.
+=head2 Platform-Specific Notes
 
-=head1 Internal Changes
+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.
 
 =over 4
 
-=item *
-
-The compiled representation of formats is now stored via the C<mg_ptr> of
-their C<PERL_MAGIC_fm>.  Previously it was stored in the string buffer,
-beyond C<SvLEN()>, the regular end of the string.  C<SvCOMPILED()> and
-C<SvCOMPILED_{on,off}()> now exist solely for compatibility for XS code.
-The first is always 0, the other two now no-ops. (5.14.1)
-
-=item *
-
-Some global variables have been marked C<const>, members in the interpreter
-structure have been re-ordered, and the opcodes have been re-ordered.  The
-op C<OP_AELEMFAST> has been split into C<OP_AELEMFAST> and C<OP_AELEMFAST_LEX>.
-
-=item *
-
-When empting a hash of its elements (e.g., via undef(%h), or %h=()), HvARRAY
-field is no longer temporarily zeroed.  Any destructors called on the freed
-elements see the remaining elements.  Thus, %h=() becomes more like
-C<delete $h{$_} for keys %h>.
-
-=item *
-
-Boyer-Moore compiled scalars are now PVMGs, and the Boyer-Moore tables are now
-stored via the mg_ptr of their C<PERL_MAGIC_bm>.
-Previously they were PVGVs, with the tables stored in
-the string buffer, beyond C<SvLEN()>.  This eliminates
-the last place where the core stores data beyond C<SvLEN()>.
-
-=item *
-
-Simplified logic in C<Perl_sv_magic()> introduces a small change of
-behavior for error cases involving unknown magic types.  Previously, if
-C<Perl_sv_magic()> was passed a magic type unknown to it, it would
-
-=over
-
-=item 1.
-
-Croak "Modification of a read-only value attempted" if read only
-
-=item 2.
+=item XXX-some-platform
 
-Return without error if the SV happened to already have this magic
-
-=item 3.
-
-otherwise croak "Don't know how to handle magic of type \\%o"
+XXX
 
 =back
 
-Now it will always croak "Don't know how to handle magic of type \\%o", even
-on read-only values, or SVs which already have the unknown magic type.
-
-=item *
-
-The experimental C<fetch_cop_label> function has been renamed to
-C<cop_fetch_label>.
-
-=item *
-
-The C<cop_store_label> function has been added to the API, but is
-experimental.
-
-=item *
-
-F<embedvar.h> has been simplified, and one level of macro indirection for
-PL_* variables has been removed for the default (non-multiplicity)
-configuration.  PERLVAR*() macros now directly expand their arguments to
-tokens such as C<PL_defgv>, instead of expanding to C<PL_Idefgv>, with
-F<embedvar.h> defining a macro to map C<PL_Idefgv> to C<PL_defgv>.  XS code
-which has unwarranted chumminess with the implementation may need updating.
-
-=item *
-
-An API has been added to explicitly choose whether to export XSUB
-symbols.  More detail can be found in the comments for commit e64345f8.
-
-=item *
-
-The C<is_gv_magical_sv> function has been eliminated and merged with
-C<gv_fetchpvn_flags>.  It used to be called to determine whether a GV
-should be autovivified in rvalue context.  Now it has been replaced with a
-new C<GV_ADDMG> flag (not part of the API).
-
-=item *
-
-The returned code point from the function C<utf8n_to_uvuni()>
-when the input is malformed UTF-8, malformations are allowed, and
-C<utf8> warnings are off is now the Unicode REPLACEMENT CHARACTER
-whenever the malformation is such that no well-defined code point can be
-computed.  Previously the returned value was essentially garbage.  The
-only malformations that have well-defined values are a zero-length
-string (0 is the return), and overlong UTF-8 sequences.
-
-=item *
-
-Padlists are now marked C<AvREAL>; i.e., reference-counted.  They have
-always been reference-counted, but were not marked real, because F<pad.c>
-did its own clean-up, instead of using the usual clean-up code in F<sv.c>.
-That caused problems in thread cloning, so now the C<AvREAL> flag is on,
-but is turned off in F<pad.c> right before the padlist is freed (after
-F<pad.c> has done its custom freeing of the pads).
-
-=item *
-
-All C files that make up the Perl core have been converted to UTF-8.
-
-=item *
-
-These new functions have been added as part of the work on Unicode symbols:
-
-    HvNAMELEN
-    HvNAMEUTF8
-    HvENAMELEN
-    HvENAMEUTF8
-    gv_init_pv
-    gv_init_pvn
-    gv_init_pvsv
-    gv_fetchmeth_pv
-    gv_fetchmeth_pvn
-    gv_fetchmeth_sv
-    gv_fetchmeth_pv_autoload
-    gv_fetchmeth_pvn_autoload
-    gv_fetchmeth_sv_autoload
-    gv_fetchmethod_pv_flags
-    gv_fetchmethod_pvn_flags
-    gv_fetchmethod_sv_flags
-    gv_autoload_pv
-    gv_autoload_pvn
-    gv_autoload_sv
-    newGVgen_flags
-    sv_derived_from_pv
-    sv_derived_from_pvn
-    sv_derived_from_sv
-    sv_does_pv
-    sv_does_pvn
-    sv_does_sv
-    whichsig_pv
-    whichsig_pvn
-    whichsig_sv
-    newCONSTSUB_flags
-
-The gv_fetchmethod_*_flags functions, like gv_fetchmethod_flags, are
-experimental and may change in a future release.
-
-=item *
-
-The following functions were added.  These are I<not> part of the API:
-
-    GvNAMEUTF8
-    GvENAMELEN
-    GvENAME_HEK
-    CopSTASH_flags
-    CopSTASH_flags_set
-    PmopSTASH_flags
-    PmopSTASH_flags_set
-    sv_sethek
-    HEKfARG
-
-There is also a C<HEKf> macro corresponding to C<SVf>, for
-interpolating HEKs in formatted strings.
-
-=item *
-
-C<sv_catpvn_flags> takes a couple of new internal-only flags,
-C<SV_CATBYTES> and C<SV_CATUTF8>, which tell it whether the char array to
-be concatenated is UTF8.  This allows for more efficient concatenation than
-creating temporary SVs to pass to C<sv_catsv>.
-
-=item *
-
-For XS AUTOLOAD subs, $AUTOLOAD is set once more, as it was in 5.6.0.  This
-is in addition to setting C<SvPVX(cv)>, for compatibility with 5.8 to 5.14.
-See L<perlguts/Autoloading with XSUBs>.
-
-=item *
-
-Perl now checks whether the array (the linearized isa) returned by a MRO
-plugin begins with the name of the class itself, for which the array was
-created, instead of assuming that it does.  This prevents the first element
-from being skipped during method lookup.  It also means that
-C<mro::get_linear_isa> may return an array with one more element than the
-MRO plugin provided [perl #94306].
-
-=item *
-
-C<PL_curstash> is now reference-counted.
-
-=item *
-
-There are now feature bundle hints in C<PL_hints> (C<$^H>) that version
-declarations use, to avoid having to load F<feature.pm>.  One setting of
-the hint bits indicates a "custom" feature bundle, which means that the
-entries in C<%^H> still apply.  F<feature.pm> uses that.
-
-The C<HINT_FEATURE_MASK> macro is defined in F<perl.h> along with other
-hints.  Other macros for setting and testing features and bundles are in
-the new F<feature.h>.  C<FEATURE_IS_ENABLED> (which has moved to
-F<feature.h>) is no longer used throughout the codebase, but more specific
-macros, e.g., C<FEATURE_SAY_IS_ENABLED>, that are defined in F<feature.h>.
-
-=item *
-
-F<lib/feature.pm> is now a generated file, created by the new
-F<regen/feature.pl> script, which also generates F<feature.h>.
-
-=item *
-
-Tied arrays are now always C<AvREAL>.  If C<@_> or C<DB::args> is tied, it
-is reified first, to make sure this is always the case.
+=head1 Internal Changes
 
-=item *
+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.
 
-Two new functions C<utf8_to_uvchr_buf()> and C<utf8_to_uvuni_buf()> have
-been added.  These are the same as C<utf8_to_uvchr> and
-C<utf8_to_uvuni> (which are now deprecated), but take an extra parameter
-that is used to guard against reading beyond the end of the input
-string.
-See L<perlapi/utf8_to_uvchr_buf> and L<perlapi/utf8_to_uvuni_buf>.
+[ List each change as a =item entry ]
 
-=item *
-
-The regular expression engine now does TRIE case insensitive matches
-under Unicode. This may change the output of C<< use re 'debug'; >>,
-and will speed up various things.
+=over 4
 
 =item *
 
-There is a new C<wrap_op_checker()> function, which provides a thread-safe
-alternative to writing to C<PL_check> directly.
+XXX
 
 =back
 
 =head1 Selected Bug Fixes
 
-=head2 Array and hash
-
-=over
-
-=item *
-
-A bug has been fixed that would cause a "Use of freed value in iteration"
-error if the next two hash elements that would be iterated over are
-deleted [perl #85026]. (5.14.1)
-
-=item *
-
-Deleting the current hash iterator (the hash element that would be returned
-by the next call to C<each>) in void context used not to free it
-[perl #85026].
+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 *
-
-Deletion of methods via C<delete $Class::{method}> syntax used to update
-method caches if called in void context, but not scalar or list context.
-
-=item *
-
-When hash elements are deleted in void context, the internal hash entry is
-now freed before the value is freed, to prevent destructors called by that
-latter freeing from seeing the hash in an inconsistent state.  It was
-possible to cause double-frees if the destructor freed the hash itself
-[perl #100340].
-
-=item *
-
-A C<keys> optimization in Perl 5.12.0 to make it faster on empty hashes
-caused C<each> not to reset the iterator if called after the last element
-was deleted.
-
-=item *
-
-Freeing deeply nested hashes no longer crashes [perl #44225].
-
-=item *
-
-It is possible from XS code to create hashes with elements that have no
-values.  The hash element and slice operators used to crash
-when handling these in lvalue context.  They now
-produce a "Modification of non-creatable hash value attempted" error
-message.
-
-=item *
-
-If list assignment to a hash or array triggered destructors that freed the
-hash or array itself, a crash would ensue.  This is no longer the case
-[perl #107440].
-
-=item *
-
-It used to be possible to free the typeglob of a localized array or hash
-(e.g., C<local @{"x"}; delete $::{x}>), resulting in a crash on scope exit.
-
-=item *
-
-Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
-element that is a glob copy no longer causes the next assignment to it to
-corrupt the glob (5.14.2), and unlocking a hash element that holds a
-copy-on-write scalar no longer causes modifications to that scalar to
-modify other scalars that were sharing the same string buffer.
-
-=back
-
-=head2 C API fixes
-
-=over
-
-=item *
-
-The C<newHVhv> XS function now works on tied hashes, instead of crashing or
-returning an empty hash.
-
-=item *
-
-The C<SvIsCOW> C macro now returns false for read-only copies of typeglobs,
-such as those created by:
-
-  $hash{elem} = *foo;
-  Hash::Util::lock_value %hash, 'elem';
-
-It used to return true.
-
-=item *
-
-The C<SvPVutf8> C function no longer tries to modify its argument,
-resulting in errors [perl #108994].
-
-=item *
-
-C<SvPVutf8> now works properly with magical variables.
-
-=item *
-
-C<SvPVbyte> now works properly non-PVs.
-
-=item *
-
-When presented with malformed UTF-8 input, the XS-callable functions
-C<is_utf8_string()>, C<is_utf8_string_loc()>, and
-C<is_utf8_string_loclen()> could read beyond the end of the input
-string by up to 12 bytes.  This no longer happens.  [perl #32080].
-However, currently, C<is_utf8_char()> still has this defect, see
-L</is_utf8_char()> above.
-
-=item *
-
-The C-level C<pregcomp> function could become confused about whether the
-pattern was in UTF8 if the pattern was an overloaded, tied, or otherwise
-magical scalar [perl #101940].
-
-=back
-
-=head2 Compile-time hints
-
-=over
-
-=item *
-
-Tying C<%^H> no longer causes perl to crash or ignore the contents of
-C<%^H> when entering a compilation scope [perl #106282].
-
-=item *
-
-C<eval $string> and C<require> used not to
-localize C<%^H> during compilation if it
-was empty at the time the C<eval> call itself was compiled.  This could
-lead to scary side effects, like C<use re "/m"> enabling other flags that
-the surrounding code was trying to enable for its caller [perl #68750].
-
-=item *
-
-C<eval $string> and C<require> no longer localize hints (C<$^H> and C<%^H>)
-at run time, but only during compilation of the $string or required file.
-This makes C<BEGIN { $^H{foo}=7 }> equivalent to
-C<BEGIN { eval '$^H{foo}=7' }> [perl #70151].
-
-=item *
-
-Creating a BEGIN block from XS code (via C<newXS> or C<newATTRSUB>) would,
-on completion, make the hints of the current compiling code the current
-hints.  This could cause warnings to occur in a non-warning scope.
-
-=back
-
-=head2 Copy-on-write scalars
-
-Copy-on-write or shared hash key scalars
-were introduced in 5.8.0, but most Perl code
-did not encounter them (they were used mostly internally).  Perl
-5.10.0 extended them, such that assigning C<__PACKAGE__> or a
-hash key to a scalar would make it copy-on-write.  Several parts
-of Perl were not updated to account for them, but have now been fixed.
-
-=over
-
-=item *
-
-C<utf8::decode> had a nasty bug that would modify copy-on-write scalars'
-string buffers in place (i.e., skipping the copy).  This could result in
-hashes having two elements with the same key [perl #91834]. (5.14.2)
-
-=item *
-
-Lvalue subroutines were not allowing COW scalars to be returned.  This was
-fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0, but list context
-was not fixed until this release.
-
-=item *
-
-Elements of restricted hashes (see the L<fields> pragma) containing
-copy-on-write values couldn't be deleted, nor could such hashes be cleared
-(C<%hash = ()>). (5.14.2)
-
-=item *
-
-Localizing a tied variable used to make it read-only if it contained a
-copy-on-write string. (5.14.2)
-
-=item *
-
-Assigning a copy-on-write string to a stash
-element no longer causes a double free.  Regardless of this change, the
-results of such assignments are still undefined.
-
-=item *
-
-Assigning a copy-on-write string to a tied variable no longer stops that
-variable from being tied if it happens to be a PVMG or PVLV internally.
-
-=item *
-
-Doing a substitution on a tied variable returning a copy-on-write
-scalar used to cause an assertion failure or an "Attempt to free
-nonexistent shared string" warning.
-
-=item *
-
-This one is a regression from 5.12: In 5.14.0, the bitwise assignment
-operators C<|=>, C<^=> and C<&=> started leaving the left-hand side
-undefined if it happened to be a copy-on-write string [perl #108480].
-
-=item *
-
-L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
-See L</Updated Modules and Pragmata>, above.
-
-=back
-
-=head2 The debugger
-
-=over
-
-=item *
-
-F<dumpvar.pl>, and therefore the C<x> command in the debugger, have been
-fixed to handle objects blessed into classes whose names contain "=".  The
-contents of such objects used not to be dumped [perl #101814].
-
-=item *
-
-The "R" command for restarting a debugger session has been fixed to work on
-Windows, or any other system lacking a C<POSIX::_SC_OPEN_MAX> constant
-[perl #87740].
-
-=item *
-
-The C<#line 42 foo> directive used not to update the arrays of lines used
-by the debugger if it occurred in a string eval.  This was partially fixed
-in 5.14, but it worked only for a single C<#line 42 foo> in each eval.  Now
-it works for multiple.
-
-=item *
-
-When subroutine calls are intercepted by the debugger, the name of the
-subroutine or a reference to it is stored in C<$DB::sub>, for the debugger
-to access.  Sometimes (such as C<$foo = *bar; undef *bar; &$foo>)
-C<$DB::sub> would be set to a name that could not be used to find the
-subroutine, and so the debugger's attempt to call it would fail.  Now the
-check to see whether a reference is needed is more robust, so those
-problems should not happen anymore [rt.cpan.org #69862].
-
-=item *
-
-Every subroutine has a filename associated with it that the debugger uses.
-The one associated with constant subroutines used to be misallocated when
-cloned under threads.  Consequently, debugging threaded applications could
-result in memory corruption [perl #96126].
-
-=back
-
-=head2 Dereferencing operators
-
-=over
-
-=item *
-
-C<defined(${"..."})>, C<defined(*{"..."})>, etc., used to
-return true for most, but not all built-in variables, if
-they had not been used yet.  This bug affected C<${^GLOBAL_PHASE}> and
-C<${^UTF8CACHE}>, among others.  It also used to return false if the
-package name was given as well (C<${"::!"}>) [perl #97978, #97492].
-
-=item *
-
-Perl 5.10.0 introduced a similar bug: C<defined(*{"foo"})> where "foo"
-represents the name of a built-in global variable used to return false if
-the variable had never been used before, but only on the I<first> call.
-This, too, has been fixed.
-
-=item *
-
-Since 5.6.0, C<*{ ... }> has been inconsistent in how it treats undefined
-values.  It would die in strict mode or lvalue context for most undefined
-values, but would be treated as the empty string (with a warning) for the
-specific scalar return by C<undef()> (C<&PL_sv_undef> internally).  This
-has been corrected.  C<undef()> is now treated like other undefined
-scalars, as in Perl 5.005.
-
-=back
-
-=head2 Filehandle, last-accessed
-
-Perl has an internal variable that stores the last filehandle to be
-accessed.  It is used by C<$.> and by C<tell> and C<eof> without
-arguments.
-
-=over
-
-=item *
-
-It used to be possible to set this internal variable to a glob copy and
-then modify that glob copy to be something other than a glob, and still
-have the last-accessed filehandle associated with the variable after
-assigning a glob to it again:
-
-    my $foo = *STDOUT;  # $foo is a glob copy
-    <$foo>;             # $foo is now the last-accessed handle
-    $foo = 3;           # no longer a glob
-    $foo = *STDERR;     # still the last-accessed handle
-
-Now the C<$foo = 3> assignment unsets that internal variable, so there
-is no last-accessed filehandle, just as if C<< <$foo> >> had never
-happened.
-
-This also prevents some unrelated handle from becoming the last-accessed
-handle if $foo falls out of scope and the same internal SV gets used for
-another handle [perl #97988].
-
-=item *
-
-A regression in 5.14 caused these statements not to set that internal
-variable:
-
-    my $fh = *STDOUT;
-    tell $fh;
-    eof  $fh;
-    seek $fh, 0,0;
-    tell     *$fh;
-    eof      *$fh;
-    seek     *$fh, 0,0;
-    readline *$fh;
-
-This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
-is not clear how to fix it [perl #106536].
-
-=back
-
-=head2 Filetests and C<stat>
-
-The term "filetests" refers to the operators that consist of a hyphen
-followed by a single letter: C<-r>, C<-x>, C<-M>, etc.  The term "stacked"
-when applied to filetests means followed by another filetest operator
-sharing the same operand, as in C<-r -x -w $fooo>.
-
-=over
-
-=item *
-
-C<stat> produces more consistent warnings.  It no longer warns for "_"
-[perl #71002] and no longer skips the warning at times for other unopened
-handles.  It no longer warns about an unopened handle when the operating
-system's C<fstat> function fails.
-
-=item *
-
-C<stat> would sometimes return negative numbers for large inode numbers,
-because it was using the wrong internal C type. [perl #84590]
-
-=item *
-
-C<lstat> is documented to fall back to C<stat> (with a warning) when given
-a filehandle.  When passed an IO reference, it was actually doing the
-equivalent of S<C<stat _>> and ignoring the handle.
-
-=item *
-
-C<-T _> with no preceding C<stat> used to produce a
-confusing "uninitialized" warning, even though there
-is no visible uninitialized value to speak of.
-
-=item *
-
-C<-T>, C<-B>, C<-l> and C<-t> now work
-when stacked with other filetest operators
-[perl #77388].
-
-=item *
-
-In 5.14.0, filetest ops (C<-r>, C<-x>, etc.) started calling FETCH on a
-tied argument belonging to the previous argument to a list operator, if
-called with a bareword argument or no argument at all.  This has been
-fixed, so C<push @foo, $tied, -r> no longer calls FETCH on C<$tied>.
-
-=item *
-
-In Perl 5.6, C<-l> followed by anything other than a bareword would treat
-its argument as a file name.  That was changed in 5.8 for glob references
-(C<\*foo>), but not for globs themselves (C<*foo>).  C<-l> started
-returning C<undef> for glob references without setting the last
-stat buffer that the "_" handle uses, but only if warnings
-were turned on.  With warnings off, it was the same as 5.6.
-In other words, it was simply buggy and inconsistent.  Now the 5.6
-behavior has been restored.
-
-=item *
-
-C<-l> followed by a bareword no longer "eats" the previous argument to
-the list operator in whose argument list it resides.  Hence,
-C<print "bar", -l foo> now actually prints "bar", because C<-l>
-on longer eats it.
-
-=item *
-
-Perl keeps several internal variables to keep track of the last stat
-buffer, from which file(handle) it originated, what type it was, and
-whether the last stat succeeded.
-
-There were various cases where these could get out of synch, resulting in
-inconsistent or erratic behavior in edge cases (every mention of C<-T>
-applies to C<-B> as well):
-
-=over
-
-=item *
-
-C<-T I<HANDLE>>, even though it does a C<stat>, was not resetting the last
-stat type, so an C<lstat _> following it would merrily return the wrong
-results.  Also, it was not setting the success status.
-
-=item *
-
-Freeing the handle last used by C<stat> or a filetest could result in
-S<C<-T _>> using an unrelated handle.
-
-=item *
-
-C<stat> with an IO reference would not reset the stat type or record the
-filehandle for S<C<-T _>> to use.
-
-=item *
-
-Fatal warnings could cause the stat buffer not to be reset
-for a filetest operator on an unopened filehandle or C<-l> on any handle.
-Fatal warnings also stopped C<-T> from setting C<$!>.
-
-=item *
-
-When the last stat was on an unreadable file, C<-T _> is supposed to
-return C<undef>, leaving the last stat buffer unchanged.  But it was
-setting the stat type, causing C<lstat _> to stop working.
-
-=item *
-
-C<-T I<FILENAME>> was not resetting the internal stat buffers for
-unreadable files.
-
-=back
-
-These have all been fixed.
-
-=back
-
-=head2 Formats
-
-=over
-
-=item *
-
-Several edge cases have been fixed with formats and C<formline>;
-in particular, where the format itself is potentially variable (such as
-with ties and overloading), and where the format and data differ in their
-encoding.  In both these cases, it used to possible for the output to be
-corrupted [perl #91032].
-
-=item *
-
-C<formline> no longer converts its argument into a string in-place.  So
-passing a reference to C<formline> no longer destroys the reference
-[perl #79532].
-
-=item *
-
-Assignment to C<$^A> (the format output accumulator) now recalculates
-the number of lines output.
-
-=back
-
-=head2 C<given> and C<when>
-
-=over
-
-=item *
-
-C<given> was not scoping its implicit $_ properly, resulting in memory
-leaks or "Variable is not available" warnings [perl #94682].
-
-=item *
-
-C<given> was not calling set-magic on the implicit lexical C<$_> that it
-uses.  This meant, for example, that C<pos> would be remembered from one
-execution of the same C<given> block to the next, even if the input were a
-different variable [perl #84526].
-
-=item *
-
-C<when> blocks are now capable of returning variables declared inside the
-enclosing C<given> block [perl #93548].
-
-=back
-
-=head2 The C<glob> operator
-
-=over
-
-=item *
-
-On OSes other than VMS, Perl's C<glob> operator (and the C<< <...> >> form)
-use L<File::Glob> underneath.  L<File::Glob> splits the pattern into words,
-before feeding each word to its C<bsd_glob> function.
-
-There were several inconsistencies in the way the split was done.  Now
-quotation marks (' and ") are always treated as shell-style word delimiters
-(that allow whitespace as part of a word) and backslashes are always
-preserved, unless they exist to escape quotation marks.  Before, those
-would only sometimes be the case, depending on whether the pattern
-contained whitespace.  Also, escaped whitespace at the end of the pattern
-is no longer stripped [perl #40470].
-
-=item *
-
-C<CORE::glob> now works as a way to call the default globbing function.  It
-used to respect overrides, despite the C<CORE::> prefix.
-
-=item *
-
-Under miniperl (used to configure modules when perl itself is built),
-C<glob> now clears %ENV before calling csh, since the latter croaks on some
-systems if it does not like the contents of the LS_COLORS environment
-variable [perl #98662].
-
-=back
-
-=head2 Lvalue subroutines
-
-=over
-
-=item *
-
-Explicit return now returns the actual argument passed to return, instead
-of copying it [perl #72724, #72706].
-
-=item *
-
-Lvalue subroutines used to enforce lvalue syntax (i.e., whatever can go on
-the left-hand side of C<=>) for the last statement and the arguments to
-return.  Since lvalue subroutines are not always called in lvalue context,
-this restriction has been lifted.
-
-=item *
-
-Lvalue subroutines are less restrictive about what values can be returned.
-It used to croak on values returned by C<shift> and C<delete> and from
-other subroutines, but no longer does so [perl #71172].
-
-=item *
-
-Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
-context.  All subroutines used to do this, but regular subs were fixed in
-Perl 5.8.2.  Now lvalue subroutines have been likewise fixed.
-
-=item *
-
-Autovivification now works on values returned from lvalue subroutines
-[perl #7946], as does returning C<keys> in lvalue context.
-
-=item *
-
-Lvalue subroutines used to copy their return values in rvalue context.  Not
-only was this a waste of CPU cycles, but it also caused bugs.  A C<($)>
-prototype would cause an lvalue sub to copy its return value [perl #51408],
-and C<while(lvalue_sub() =~ m/.../g) { ... }> would loop endlessly
-[perl #78680].
-
-=item *
-
-When called in potential lvalue context
-(e.g., subroutine arguments or a list
-passed to C<for>), lvalue subroutines used to copy
-any read-only value that was returned.  E.g., C< sub :lvalue { $] } >
-would not return C<$]>, but a copy of it.
-
-=item *
-
-When called in potential lvalue context, an lvalue subroutine returning
-arrays or hashes used to bind the arrays or hashes to scalar variables,
-resulting in bugs.  This was fixed in 5.14.0 if an array were the first
-thing returned from the subroutine (but not for C<$scalar, @array> or
-hashes being returned).  Now a more general fix has been applied
-[perl #23790].
-
-=item *
-
-Method calls whose arguments were all surrounded with C<my()> or C<our()>
-(as in C<< $object->method(my($a,$b)) >>) used to force lvalue context on
-the subroutine.  This would prevent lvalue methods from returning certain
-values.
-
-=item *
-
-Lvalue sub calls that are not determined to be such at compile time
-(C<&$name> or &{"name"}) are no longer exempt from strict refs if they
-occur in the last statement of an lvalue subroutine [perl #102486].
-
-=item *
-
-Sub calls whose subs are not visible at compile time, if
-they occurred in the last statement of an lvalue subroutine,
-would reject non-lvalue subroutines and die with "Can't modify non-lvalue
-subroutine call" [perl #102486].
-
-Non-lvalue sub calls whose subs I<are> visible at compile time exhibited
-the opposite bug.  If the call occurred in the last statement of an lvalue
-subroutine, there would be no error when the lvalue sub was called in
-lvalue context.  Perl would blindly assign to the temporary value returned
-by the non-lvalue subroutine.
-
-=item *
-
-C<AUTOLOAD> routines used to take precedence over the actual sub being
-called (i.e., when autoloading wasn't needed), for sub calls in lvalue or
-potential lvalue context, if the subroutine was not visible at compile
-time.
-
-=item *
-
-Applying the C<:lvalue> attribute to an XSUB or to an aliased subroutine
-stub with C<< sub foo :lvalue; >> syntax stopped working in Perl 5.12.
-This has been fixed.
-
-=item *
-
-Applying the :lvalue attribute to subroutine that is already defined does
-not work properly, as the attribute changes the way the sub is compiled.
-Hence, Perl 5.12 began warning when an attempt is made to apply the
-attribute to an already defined sub.  In such cases, the attribute is
-discarded.
-
-But the change in 5.12 missed the case where custom attributes are also
-present: that case still silently and ineffectively applied the attribute.
-That omission has now been corrected.  C<sub foo :lvalue :Whatever> (when
-C<foo> is already defined) now warns about the :lvalue attribute, and does
-not apply it.
-
-=item *
-
-A bug affecting lvalue context propagation through nested lvalue subroutine
-calls has been fixed.  Previously, returning a value in nested rvalue
-context would be treated as lvalue context by the inner subroutine call,
-resulting in some values (such as read-only values) being rejected.
-
-=back
-
-=head2 Overloading
-
-=over
-
-=item *
-
-Arithmetic assignment (C<$left += $right>) involving overloaded objects
-that rely on the 'nomethod' override no longer segfault when the left
-operand is not overloaded.
-
-=item *
-
-Errors that occur when methods cannot be found during overloading now
-mention the correct package name, as they did in 5.8.x, instead of
-erroneously mentioning the "overload" package, as they have since 5.10.0.
-
-=item *
-
-Undefining C<%overload::> no longer causes a crash.
-
-=back
-
-=head2 Prototypes of built-in keywords
-
-=over
-
-=item *
-
-The C<prototype> function no longer dies for the C<__FILE__>, C<__LINE__>
-and C<__PACKAGE__> directives.  It now returns an empty-string prototype
-for them, because they are syntactically indistinguishable from nullary
-functions like C<time>.
-
-=item *
-
-C<prototype> now returns C<undef> for all overridable infix operators,
-such as C<eq>, which are not callable in any way resembling functions.
-It used to return incorrect prototypes for some and die for others
-[perl #94984].
-
-=item *
-
-The prototypes of several built-in functions--C<getprotobynumber>, C<lock>,
-C<not> and C<select>--have been corrected, or at least are now closer to
-reality than before.
-
-=back
-
-=head2 Regular expressions
-
-=for comment Is it possible to merge some of these items?
+[ List each fix as a =item entry ]
 
 =over 4
 
 =item *
 
-C</[[:ascii:]]/> and C</[[:blank:]]/> now use locale rules under
-C<use locale> when the platform supports that.  Previously, they used
-the platform's native character set.
-
-=item *
-
-C<m/[[:ascii:]]/i> and C</\p{ASCII}/i> now match identically (when not
-under a differing locale).  This fixes a regression introduced in 5.14
-in which the first expression could match characters outside of ASCII,
-such as the KELVIN SIGN.
-
-=item *
-
-C</.*/g> would sometimes refuse to match at the end of a string that ends
-with "\n".  This has been fixed [perl #109206].
-
-=item *
-
-Starting with 5.12.0, Perl used to get its internal bookkeeping muddled up
-after assigning C<${ qr// }> to a hash element and locking it with
-L<Hash::Util>.  This could result in double frees, crashes, or erratic
-behavior.
-
-=item *
-
-The new (in 5.14.0) regular expression modifier C</a> when repeated like
-C</aa> forbids the characters outside the ASCII range that match
-characters inside that range from matching under C</i>.  This did not
-work under some circumstances, all involving alternation, such as:
-
- "\N{KELVIN SIGN}" =~ /k|foo/iaa;
-
-succeeded inappropriately.  This is now fixed.
-
-=item *
-
-5.14.0 introduced some memory leaks in regular expression character
-classes such as C<[\w\s]>, which have now been fixed. (5.14.1)
-
-=item *
-
-An edge case in regular expression matching could potentially loop.
-This happened only under C</i> in bracketed character classes that have
-characters with multi-character folds, and the target string to match
-against includes the first portion of the fold, followed by another
-character that has a multi-character fold that begins with the remaining
-portion of the fold, plus some more.
-
- "s\N{U+DF}" =~ /[\x{DF}foo]/i
-
-is one such case.  C<\xDF> folds to C<"ss">. (5.14.1)
-
-=item *
-
-A few characters in regular expression pattern matches did not
-match correctly in some circumstances, all involving C</i>.  The
-affected characters are:
-COMBINING GREEK YPOGEGRAMMENI,
-GREEK CAPITAL LETTER IOTA,
-GREEK CAPITAL LETTER UPSILON,
-GREEK PROSGEGRAMMENI,
-GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
-GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
-GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA,
-GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
-LATIN SMALL LETTER LONG S,
-LATIN SMALL LIGATURE LONG S T,
-and
-LATIN SMALL LIGATURE ST.
-
-=item *
-
-A memory leak regression in regular expression compilation
-under threading has been fixed.
-
-=item *
-
-A regression introduced in 5.14.0 has
-been fixed.  This involved an inverted
-bracketed character class in a regular expression that consisted solely
-of a Unicode property.  That property wasn't getting inverted outside the
-Latin1 range.
-
-=item *
-
-Three problematic Unicode characters now work better in regex pattern matching under C</i>.
-
-In the past, three Unicode characters:
-LATIN SMALL LETTER SHARP S,
-GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
-and
-GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
-along with the sequences that they fold to
-(including "ss" for LATIN SMALL LETTER SHARP S),
-did not properly match under C</i>.  5.14.0 fixed some of these cases,
-but introduced others, including a panic when one of the characters or
-sequences was used in the C<(?(DEFINE)> regular expression predicate.
-The known bugs that were introduced in 5.14 have now been fixed; as well
-as some other edge cases that have never worked until now.  These all
-involve using the characters and sequences outside bracketed character
-classes under C</i>.  This closes [perl #98546].
-
-There remain known problems when using certain characters with
-multi-character folds inside bracketed character classes, including such
-constructs as C<qr/[\N{LATIN SMALL LETTER SHARP}a-z]/i>.  These
-remaining bugs are addressed in [perl #89774].
-
-=item *
-
-RT #78266: The regex engine has been leaking memory when accessing
-named captures that weren't matched as part of a regex ever since 5.10
-when they were introduced; e.g., this would consume over a hundred MB of
-memory:
-
-    for (1..10_000_000) {
-        if ("foo" =~ /(foo|(?<capture>bar))?/) {
-            my $capture = $+{capture}
-        }
-    }
-    system "ps -o rss $$"'
-
-=item *
-
-In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
-opposite case.  This has been fixed [perl #101970].
-
-=item *
-
-A regular expression match with an overloaded object on the right-hand side
-would sometimes stringify the object too many times.
-
-=item *
-
-A regression has been fixed that was introduced in 5.14, in C</i>
-regular expression matching, in which a match improperly fails if the
-pattern is in UTF-8, the target string is not, and a Latin-1 character
-precedes a character in the string that should match the pattern.
-[perl #101710]
-
-=item *
-
-In case-insensitive regular expression pattern matching, no longer on
-UTF-8 encoded strings does the scan for the start of match look only at
-the first possible position.  This caused matches such as
-C<"f\x{FB00}" =~ /ff/i> to fail.
-
-=item *
-
-The regexp optimizer no longer crashes on debugging builds when merging
-fixed-string nodes with inconvenient contents.
-
-=item *
-
-A panic involving the combination of the regular expression modifiers
-C</aa> and the C<\b> escape sequence introduced in 5.14.0 has been
-fixed [perl #95964]. (5.14.2)
-
-=item *
-
-The combination of the regular expression modifiers C</aa> and the C<\b>
-and C<\B> escape sequences did not work properly on UTF-8 encoded
-strings.  All non-ASCII characters under C</aa> should be treated as
-non-word characters, but what was happening was that Unicode rules were
-used to determine wordness/non-wordness for non-ASCII characters.  This
-is now fixed [perl #95968].
-
-=item *
-
-C<< (?foo: ...) >> no longer loses passed in character set.
-
-=item *
-
-The trie optimization used to have problems with alternations containing
-an empty C<(?:)>, causing C<< "x" =~ /\A(?>(?:(?:)A|B|C?x))\z/ >> not to
-match, whereas it should [perl #111842].
-
-=item *
-
-Use of lexical (C<my>) variables in code blocks embedded in regular
-expressions will no longer result in memory corruption or crashes.
-
-Nevertheless, these code blocks are still experimental, as there are still
-problems with the wrong variables being closed over (in loops for instance)
-and with abnormal exiting (e.g., C<die>) causing memory corruption.
-
-=item *
-
-The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
-cause a panic error message when trying to match at the end of the
-string [perl #96354].
-
-=item *
-
-The abbreviations for four C1 control characters C<MW> C<PM>, C<RI>, and
-C<ST> were previously unrecognized by C<\N{}>, vianame(), and
-string_vianame().
-
-=item *
-
-Mentioning a variable named "&" other than C<$&> (i.e., C<@&> or C<%&>) no
-longer stops C<$&> from working.  The same applies to variables named "'"
-and "`" [perl #24237].
-
-=item *
-
-Creating a C<UNIVERSAL::AUTOLOAD> sub no longer stops C<%+>, C<%-> and
-C<%!> from working some of the time [perl #105024].
-
-=back
-
-=head2 Smartmatching
-
-=over
-
-=item *
-
-C<~~> now correctly handles the precedence of Any~~Object, and is not tricked
-by an overloaded object on the left-hand side.
-
-=item *
-
-In Perl 5.14.0, C<$tainted ~~ @array> stopped working properly.  Sometimes
-it would erroneously fail (when C<$tainted> contained a string that occurs
-in the array I<after> the first element) or erroneously succeed (when
-C<undef> occurred after the first element) [perl #93590].
-
-=back
-
-=head2 The C<sort> operator
-
-=over
-
-=item *
-
-C<sort> was not treating C<sub {}> and C<sub {()}> as equivalent when
-such a sub was provided as the comparison routine.  It used to croak on
-C<sub {()}>.
-
-=item *
-
-C<sort> now works once more with custom sort routines that are XSUBs.  It
-stopped working in 5.10.0.
-
-=item *
-
-C<sort> with a constant for a custom sort routine, although it produces
-unsorted results, no longer crashes.  It started crashing in 5.10.0.
-
-=item *
-
-Warnings emitted by C<sort> when a custom comparison routine returns a
-non-numeric value now contain "in sort" and show the line number of the
-C<sort> operator, rather than the last line of the comparison routine.  The
-warnings also now occur only if warnings are enabled in the scope where
-C<sort> occurs.  Previously the warnings would occur if enabled in the
-comparison routine's scope.
-
-=item *
-
-C<< sort { $a <=> $b } >>, which is optimized internally, now produces
-"uninitialized" warnings for NaNs (not-a-number values), since C<< <=> >>
-returns C<undef> for those.  This brings it in line with
-S<C<< sort { 1; $a <=> $b } >>> and other more complex cases, which are not
-optimized [perl #94390].
-
-=back
-
-=head2 The C<substr> operator
-
-=over
-
-=item *
-
-Tied (and otherwise magical) variables are no longer exempt from the
-"Attempt to use reference as lvalue in substr" warning.
-
-=item *
-
-That warning now occurs when the returned lvalue is assigned to, not
-when C<substr> itself is called.  This makes a difference only if the
-return value of C<substr> is referenced and later assigned to.
-
-=item *
-
-Passing a substring of a read-only value or a typeglob to a function
-(potential lvalue context) no longer causes an immediate "Can't coerce"
-or "Modification of a read-only value" error.  That error occurs only 
-if the passed value is assigned to.
-
-The same thing happens with the "substr outside of string" error.  If
-the lvalue is only read from, not written to, it is now just a warning, as
-with rvalue C<substr>.
-
-=item *
-
-C<substr> assignments no longer call FETCH twice if the first argument
-is a tied variable, just once.
-
-=back
-
-=head2 Support for embedded nulls
-
-Some parts of Perl did not work correctly with nulls (C<chr 0>) embedded in
-strings.  That meant that, for instance, C<< $m = "a\0b"; foo->$m >> would
-call the "a" method, instead of the actual method name contained in $m.
-These parts of perl have been fixed to support nulls:
-
-=over
-
-=item *
-
-Method names
-
-=item *
-
-Typeglob names (including filehandle and subroutine names)
-
-=item *
-
-Package names, including the return value of C<ref()>
-
-=item *
-
-Typeglob elements (C<*foo{"THING\0stuff"}>)
-
-=item *
-
-Signal names
-
-=item *
-
-Various warnings and error messages that mention variable names or values,
-methods, etc.
-
-=item *
-
-L<Scalar::Util> has been upgraded from version 1.23 to version 1.25.
-
-=back
-
-One side effect of these changes is that blessing into "\0" no longer
-causes C<ref()> to return false.
-
-=head2 Threading bugs
-
-=over
-
-=item *
-
-Typeglobs returned from threads are no longer cloned if the parent thread
-already has a glob with the same name.  This means that returned
-subroutines will now assign to the right package variables [perl #107366].
-
-=item *
-
-Some cases of threads crashing due to memory allocation during cloning have
-been fixed [perl #90006].
-
-=item *
-
-Thread joining would sometimes emit "Attempt to free unreferenced scalar"
-warnings if C<caller> had been used from the C<DB> package before thread
-creation [perl #98092].
-
-=item *
-
-Locking a subroutine (via C<lock &sub>) is no longer a compile-time error
-for regular subs.  For lvalue subroutines, it no longer tries to return the
-sub as a scalar, resulting in strange side effects like C<ref \$_>
-returning "CODE" in some instances.
-
-C<lock &sub> is now a run-time error if L<threads::shared> is loaded (a
-no-op otherwise), but that may be rectified in a future version.
-
-=back
-
-=head2 Tied variables
-
-=over
-
-=item *
-
-Various cases in which FETCH was being ignored or called too many times
-have been fixed:
-
-=over
-
-=item *
-
-C<PerlIO::get_layers> [perl #97956]
-
-=item *
-
-C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> when $tied holds a
-reference.
-
-=item *
-
-When calling C<local $_> [perl #105912]
-
-=item *
-
-Four-argument C<select>
-
-=item *
-
-A tied buffer passed to C<sysread>
-
-=item *
-
-C<< $tied .= <> >>
-
-=item *
-
-Three-argument C<open>, the third being a tied file handle
-(as in C<< open $fh, ">&", $tied >>)
-
-=item *
-
-C<sort> with a reference to a tied glob for the comparison routine.
-
-=item *
-
-C<..> and C<...> in list context [perl #53554].
-
-=item *
-
-C<${$tied}>, C<@{$tied}>, C<%{$tied}> and C<*{$tied}> where the tied
-variable returns a string (C<&{}> was unaffected)
-
-=item *
-
-C<defined ${ $tied_variable }>
-
-=item *
-
-Various functions that take a filehandle argument in rvalue context
-(C<close>, C<readline>, etc.) [perl #97482]
-
-=item *
-
-Some cases of dereferencing a complex expression, such as
-C<${ (), $tied } = 1>, used to call C<FETCH> multiple times, but now call
-it once.
-
-=item *
-
-C<$tied-E<gt>method> where $tied returns a package name--even resulting in
-a failure to call the method, due to memory corruption
-
-=item *
-
-Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied>
-
-=item *
-
-C<chdir>, C<chmod>, C<chown>, C<utime>, C<truncate>, C<stat>, C<lstat> and
-the filetest ops (C<-r>, C<-x>, etc.)
-
-=back
-
-=item *
-
-C<caller> sets C<@DB::args> to the subroutine arguments when called from
-the DB package.  It used to crash when doing so if C<@DB::args> happened to
-be tied.  Now it croaks instead.
-
-=item *
-
-Tying an element of %ENV or C<%^H> and then deleting that element would
-result in a call to the tie object's DELETE method, even though tying the
-element itself is supposed to be equivalent to tying a scalar (the element
-is, of course, a scalar) [perl #67490].
-
-=item *
-
-When Perl autovivifies an element of a tied array or hash (which entails
-calling STORE with a new reference), it now calls FETCH immediately after
-the STORE, instead of assuming that FETCH would have returned the same
-reference.  This can make it easier to implement tied objects [perl #35865, #43011].
-
-=item *
-
-Four-argument C<select> no longer produces its "Non-string passed as
-bitmask" warning on tied or tainted variables that are strings.
-
-=item *
-
-Localizing a tied scalar that returns a typeglob no longer stops it from
-being tied till the end of the scope.
-
-=item *
-
-Attempting to C<goto> out of a tied handle method used to cause memory
-corruption or crashes.  Now it produces an error message instead
-[perl #8611].
-
-=item *
-
-A bug has been fixed that occurs when a tied variable is used as a
-subroutine reference:  if the last thing assigned to or returned from the
-variable was a reference or typeglob, the C<\&$tied> could either crash or
-return the wrong subroutine.  The reference case is a regression introduced
-in Perl 5.10.0.  For typeglobs, it has probably never worked till now.
-
-=back
-
-=head2 Version objects and vstrings
-
-=over
-
-=item *
-
-The bitwise complement operator (and possibly other operators, too) when
-passed a vstring would leave vstring magic attached to the return value,
-even though the string had changed.  This meant that
-C<< version->new(~v1.2.3) >> would create a version looking like "v1.2.3"
-even though the string passed to C<< version->new >> was actually
-"\376\375\374".  This also caused L<B::Deparse> to deparse C<~v1.2.3>
-incorrectly, without the C<~> [perl #29070].
-
-=item *
-
-Assigning a vstring to a magic (e.g., tied, C<$!>) variable and then
-assigning something else used to blow away all magic.  This meant that
-tied variables would come undone, C<$!> would stop getting updated on
-failed system calls, C<$|> would stop setting autoflush, and other
-mischief would take place.  This has been fixed.
-
-=item *
-
-C<< version->new("version") >> and C<printf "%vd", "version"> no longer
-crash [perl #102586].
-
-=item *
-
-Version comparisons, such as those that happen implicitly with C<use
-v5.43>, no longer cause locale settings to change [perl #105784].
-
-=item *
-
-Version objects no longer cause memory leaks in boolean context
-[perl #109762].
-
-=back
-
-=head2 Warnings, redefinition
-
-=over
-
-=item *
-
-Subroutines from the C<autouse> namespace are once more exempt from
-redefinition warnings.  This used to work in 5.005, but was broken in
-5.6 for most subroutines.  For subs created via XS that redefine
-subroutines from the C<autouse> package, this stopped working in 5.10.
-
-=item *
-
-New XSUBs now produce redefinition warnings if they overwrite existing
-subs, as they did in 5.8.x.  (The C<autouse> logic was reversed in
-5.10-14.  Only subroutines from the C<autouse> namespace would warn
-when clobbered.)
-
-=item *
-
-C<newCONSTSUB> used to use compile-time warning hints, instead of
-run-time hints.  The following code should never produce a redefinition
-warning, but it used to, if C<newCONSTSUB> redefined an existing
-subroutine:
-
-    use warnings;
-    BEGIN {
-        no warnings;
-        some_XS_function_that_calls_new_CONSTSUB();
-    }
-
-=item *
-
-Redefinition warnings for constant subroutines are on by default (what
-are known as severe warnings in L<perldiag>).  This occurred only
-when it was a glob assignment or declaration of a Perl subroutine that
-caused the warning.  If the creation of XSUBs triggered the warning, it
-was not a default warning.  This has been corrected.
-
-=item *
-
-The internal check to see whether a redefinition warning should occur
-used to emit "uninitialized" warnings in cases like this:
-
-    use warnings "uninitialized";
-    use constant {u => undef, v => undef};
-    sub foo(){u}
-    sub foo(){v}
-
-=back
-
-=head2 Warnings, "Uninitialized"
-
-=over
-
-=item *
-
-Various functions that take a filehandle argument in rvalue context
-(C<close>, C<readline>, etc.) used to warn twice for an undefined handle
-[perl #97482].
-
-=item *
-
-C<dbmopen> now only warns once, rather than three times, if the mode
-argument is C<undef> [perl #90064].
-
-=item *
-
-The C<+=> operator does not usually warn when the left-hand side is
-C<undef>, but it was doing so for tied variables.  This has been fixed
-[perl #44895].
-
-=item *
-
-A bug fix in Perl 5.14 introduced a new bug, causing "uninitialized"
-warnings to report the wrong variable if the operator in question had
-two operands and one was C<%{...}> or C<@{...}>.  This has been fixed
-[perl #103766].
-
-=item *
-
-C<..> and C<...> in list context now mention the name of the variable in
-"uninitialized" warnings for string (as opposed to numeric) ranges.
-
-=back
-
-=head2 Weak references
-
-=over
-
-=item *
-
-Weakening the first argument to an automatically-invoked C<DESTROY> method
-could result in erroneous "DESTROY created new reference" errors or
-crashes.  Now it is an error to weaken a read-only reference.
-
-=item *
-
-Weak references to lexical hashes going out of scope were not going stale
-(becoming undefined), but continued to point to the hash.
-
-=item *
-
-Weak references to lexical variables going out of scope are now broken
-before any magical methods (e.g., DESTROY on a tie object) are called.
-This prevents such methods from modifying the variable that will be seen
-the next time the scope is entered.
-
-=item *
-
-Creating a weak reference to an @ISA array or accessing the array index
-(C<$#ISA>) could result in confused internal bookkeeping for elements
-later added to the @ISA array.  For instance, creating a weak
-reference to the element itself could push that weak reference on to @ISA;
-and elements added after use of C<$#ISA> would be ignored by method lookup
-[perl #85670].
-
-=back
-
-=head2 Other notable fixes
-
-=over
-
-=item *
-
-C<quotemeta> now quotes consistently the same non-ASCII characters under
-C<use feature 'unicode_strings'>, regardless of whether the string is
-encoded in UTF-8 or not, hence fixing the last vestiges (we hope) of the
-notorious L<perlunicode/The "Unicode Bug">.  [perl #77654].
-
-Which of these code points is quoted has changed, based on Unicode's
-recommendations.  See L<perlfunc/quotemeta> for details.
-
-=item *
-
-C<study> is now a no-op, presumably fixing all outstanding bugs related to
-study causing regex matches to behave incorrectly!
-
-=item *
-
-When one writes C<open foo || die>, which used to work in Perl 4, a
-"Precedence problem" warning is produced.  This warning used erroneously to
-apply to fully-qualified bareword handle names not followed by C<||>.  This
-has been corrected.
-
-=item *
-
-After package aliasing (C<*foo:: = *bar::>), C<select> with 0 or 1 argument
-would sometimes return a name that could not be used to refer to the
-filehandle, or sometimes it would return C<undef> even when a filehandle
-was selected.  Now it returns a typeglob reference in such cases.
-
-=item *
-
-C<PerlIO::get_layers> no longer ignores some arguments that it thinks are
-numeric, while treating others as filehandle names.  It is now consistent
-for flat scalars (i.e., not references).
-
-=item *
-
-Unrecognized switches on C<#!> line
-
-If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
-there, perl dies with "Can't emulate...".
-
-It used to produce the same message for switches that perl did not
-recognize at all, whether on the command line or the C<#!> line.
-
-Now it produces the "Unrecognized switch" error message [perl #104288].
-
-=item *
-
-C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
-signal handler from stealing the exit status [perl #105700].
-
-=item *
-
-The %n formatting code for C<printf> and C<sprintf>, which causes the number
-of characters to be assigned to the next argument, now actually
-assigns the number of characters, instead of the number of bytes.
-
-It also works now with special lvalue functions like C<substr> and with
-nonexistent hash and array elements [perl #3471, #103492].
-
-=item *
-
-Perl skips copying values returned from a subroutine, for the sake of
-speed, if doing so would make no observable difference.  Because of faulty
-logic, this would happen with the
-result of C<delete>, C<shift> or C<splice>, even if the result was
-referenced elsewhere.  It also did so with tied variables about to be freed
-[perl #91844, #95548].
-
-=item *
-
-C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
-
-=item *
-
-Freeing $_ inside a C<grep> or C<map> block, a code block embedded in a
-regular expression, or an @INC filter (a subroutine returned by a
-subroutine in @INC) used to result in double frees or crashes
-[perl #91880, #92254, #92256].
-
-=item *
-
-C<eval> returns C<undef> in scalar context or an empty list in list
-context when there is a run-time error.  When C<eval> was passed a
-string in list context and a syntax error occurred, it used to return a
-list containing a single undefined element.  Now it returns an empty
-list in list context for all errors [perl #80630].
-
-=item *
-
-C<goto &func> no longer crashes, but produces an error message, when
-the unwinding of the current subroutine's scope fires a destructor that
-undefines the subroutine being "goneto" [perl #99850].
-
-=item *
-
-Perl now holds an extra reference count on the package that code is
-currently compiling in.  This means that the following code no longer
-crashes [perl #101486]:
-
-    package Foo;
-    BEGIN {*Foo:: = *Bar::}
-    sub foo;
-
-=item *
-
-The C<x> repetition operator no longer crashes on 64-bit builds with large
-repeat counts [perl #94560].
-
-=item *
-
-Calling C<require> on an implicit C<$_> when C<*CORE::GLOBAL::require> has
-been overridden does not segfault anymore, and C<$_> is now passed to the
-overriding subroutine [perl #78260].
-
-=item *
-
-C<use> and C<require> are no longer affected by the I/O layers active in
-the caller's scope (enabled by L<open.pm|open>) [perl #96008].
-
-=item *
-
-C<our $::é; $é> (which is invalid) no longer produces the "Compilation
-error at lib/utf8_heavy.pl..." error message, which it started emitting in
-5.10.0 [perl #99984].
-
-=item *
-
-On 64-bit systems, C<read()> now understands large string offsets beyond
-the 32-bit range.
-
-=item *
-
-Errors that occur when processing subroutine attributes no longer cause the
-subroutine's op tree to leak.
-
-=item *
-
-Passing the same constant subroutine to both C<index> and C<formline> no
-longer causes one or the other to fail [perl #89218]. (5.14.1)
-
-=item *
-
-List assignment to lexical variables declared with attributes in the same
-statement (C<my ($x,@y) : blimp = (72,94)>) stopped working in Perl 5.8.0.
-It has now been fixed.
-
-=item *
-
-Perl 5.10.0 introduced some faulty logic that made "U*" in the middle of
-a pack template equivalent to "U0" if the input string was empty.  This has
-been fixed [perl #90160]. (5.14.2)
-
-=item *
-
-Destructors on objects were not called during global destruction on objects
-that were not referenced by any scalars.  This could happen if an array
-element were blessed (e.g., C<bless \$a[0]>) or if a closure referenced a
-blessed variable (C<bless \my @a; sub foo { @a }>).
-
-Now there is an extra pass during global destruction to fire destructors on
-any objects that might be left after the usual passes that check for
-objects referenced by scalars [perl #36347].
-
-=item *
-
-Fixed a case where it was possible that a freed buffer may have been read
-from when parsing a here document [perl #90128]. (5.14.1)
-
-=item *
-
-C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
-inside a C<while> condition [perl #90888].
-
-=item *
-
-A problem with context propagation when a C<do> block is an argument to
-C<return> has been fixed.  It used to cause C<undef> to be returned in
-certain cases of a C<return> inside an C<if> block which itself is followed by
-another C<return>.
-
-=item *
-
-Calling C<index> with a tainted constant no longer causes constants in
-subsequently compiled code to become tainted [perl #64804].
-
-=item *
-
-Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
-working for the rest of the block.
-
-=item *
-
-For list assignments like C<($a,$b) = ($b,$a)>, Perl has to make a copy of
-the items on the right-hand side before assignment them to the left.  For
-efficiency's sake, it assigns the values on the right straight to the items
-on the left if no one variable is mentioned on both sides, as in C<($a,$b) =
-($c,$d)>.  The logic for determining when it can cheat was faulty, in that
-C<&&> and C<||> on the right-hand side could fool it.  So C<($a,$b) =
-$some_true_value && ($b,$a)> would end up assigning the value of C<$b> to
-both scalars.
-
-=item *
-
-Perl no longer tries to apply lvalue context to the string in
-C<("string", $variable) ||= 1> (which used to be an error).  Since the
-left-hand side of C<||=> is evaluated in scalar context, that's a scalar
-comma operator, which gives all but the last item void context.  There is
-no such thing as void lvalue context, so it was a mistake for Perl to try
-to force it [perl #96942].
-
-=item *
-
-C<caller> no longer leaks memory when called from the DB package if
-C<@DB::args> was assigned to after the first call to C<caller>.  L<Carp>
-was triggering this bug [perl #97010]. (5.14.2)
-
-=item *
-
-C<close> and similar filehandle functions, when called on built-in global
-variables (like C<$+>), used to die if the variable happened to hold the
-undefined value, instead of producing the usual "Use of uninitialized
-value" warning.
-
-=item *
-
-When autovivified file handles were introduced in Perl 5.6.0, C<readline>
-was inadvertently made to autovivify when called as C<readline($foo)> (but
-not as C<E<lt>$fooE<gt>>).  It has now been fixed never to autovivify.
-
-=item *
-
-Calling an undefined anonymous subroutine (e.g., what $x holds after
-C<undef &{$x = sub{}}>) used to cause a "Not a CODE reference" error, which
-has been corrected to "Undefined subroutine called" [perl #71154].
-
-=item *
-
-Causing C<@DB::args> to be freed between uses of C<caller> no longer
-results in a crash [perl #93320].
-
-=item *
-
-C<setpgrp($foo)> used to be equivalent to C<($foo, setpgrp)>, because
-C<setpgrp> was ignoring its argument if there was just one.  Now it is
-equivalent to C<setpgrp($foo,0)>.
-
-=item *
-
-C<shmread> was not setting the scalar flags correctly when reading from
-shared memory, causing the existing cached numeric representation in the
-scalar to persist [perl #98480].
-
-=item *
-
-C<++> and C<--> now work on copies of globs, instead of dying.
-
-=item *
-
-C<splice()> doesn't warn when truncating
-
-You can now limit the size of an array using C<splice(@a,MAX_LEN)> without
-worrying about warnings.
-
-=item *
-
-C<< $$ >> is no longer tainted.  Since this value comes directly from
-C<< getpid() >>, it is always safe.
-
-=item *
-
-The parser no longer leaks a filehandle if STDIN was closed before parsing
-started [perl #37033].
-
-=item *
-
-C<< die; >> with a non-reference, non-string, or magical (e.g., tainted)
-value in $@ now properly propagates that value [perl #111654].
-
-=item *
-
-Unicode 6.1 published an incorrect alias for one of the
-Canonical_Combining_Class property's values (which range between 0 and
-254).  The alias C<CCC133> should have been C<CCC132>.  Perl now
-overrides the data file furnished by Unicode to give the correct value.
+XXX
 
 =back
 
 =head1 Known Problems
 
-=over 4
-
-=item *
-
-On Solaris, we have two kinds of failure.
-
-If F<make> is Sun's F<make>, we get an error about a badly formed macro
-assignment in the F<Makefile>.  That happens when F<./Configure> tries to
-make depends.  F<Configure> then exits 0, but further F<make>-ing fails.
-
-If F<make> is F<gmake>, F<Configure> completes, then we get errors related
-to F</usr/include/stdbool.h>
-
-=item *
-
-On Win32, a number of tests hang unless STDERR is redirected.  The cause of
-this is still under investigation.
-
-=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).
 
-When building as root with a umask that prevents files from being
-other-readable, F<t/op/filetest.t> will fail.  This is a test bug, not a
-bug in perl's behavior.
+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 ]
 
-Configuring with a recent gcc and link-time-optimization, such as
-C<Configure -Doptimize='-O2 -flto'> fails
-because the optimizer optimizes away some of Configure's tests.  A
-workaround is to omit the C<-flto> flag when running Configure, but add
-it back in while actually building, something like
-
-    sh Configure -Doptimize=-O2                                             
-    make OPTIMIZE='-O2 -flto'                                               
-
-=item *
-
-The following CPAN modules have test failures with perl 5.16.  Patches have
-been submitted for all of these, so hopefully there will be new releases
-soon:
-
-=over
-
-=item *
-
-L<Date::Pcalc> version 6.1
-
-=item *
-
-L<Module::CPANTS::Analyse> version 0.85
-
-This fails due to problems in L<Module::Find> 0.10 and L<File::MMagic>
-1.27.
+=over 4
 
 =item *
 
-L<PerlIO::Util> version 0.72
+XXX
 
 =back
 
-=back
+=head1 Obituary
+
+XXX If any significant core contributor has died, we've added a short obituary
+here.
 
 =head1 Acknowledgements
 
-Perl 5.16.0 represents approximately 12 months of development since Perl
-5.14.0 and contains approximately 590,000 lines of changes across 2,500
-files from 139 authors.
-
-Perl continues to flourish into its third decade thanks to a vibrant
-community of users and developers.  The following people are known to
-have contributed the improvements that became Perl 5.16.0:
-
-Aaron Crane, Abhijit Menon-Sen, Abigail, Alan Haggai Alavi, Alberto
-Simões, Alexandr Ciornii, Andreas König, Andy Dougherty, Aristotle
-Pagaltzis, Bo Johansson, Bo Lindbergh, Breno G. de Oliveira, brian d
-foy, Brian Fraser, Brian Greenfield, Carl Hayter, Chas. Owens,
-Chia-liang Kao, Chip Salzenberg, Chris 'BinGOs' Williams, Christian
-Hansen, Christopher J. Madsen, chromatic, Claes Jacobsson, Claudio
-Ramirez, Craig A. Berry, Damian Conway, Daniel Kahn Gillmor, Darin
-McBride, Dave Rolsky, David Cantrell, David Golden, David Leadbeater,
-David Mitchell, Dee Newcum, Dennis Kaarsemaker, Dominic Hargreaves,
-Douglas Christopher Wilson, Eric Brine, Father Chrysostomos, Florian
-Ragwitz, Frederic Briere, George Greer, Gerard Goossen, Gisle Aas,
-H.Merijn Brand, Hojung Youn, Ian Goodacre, James E Keenan, Jan Dubois,
-Jerry D. Hedden, Jesse Luehrs, Jesse Vincent, Jilles Tjoelker, Jim
-Cromie, Jim Meyering, Joel Berger, Johan Vromans, Johannes Plunien, John
-Hawkinson, John P. Linderman, John Peacock, Joshua ben Jore, Juerd
-Waalboer, Karl Williamson, Karthik Rajagopalan, Keith Thompson, Kevin J.
-Woolley, Kevin Ryde, Laurent Dami, Leo Lapworth, Leon Brocard, Leon
-Timmermans, Louis Strous, Lukas Mai, Marc Green, Marcel Grünauer, Mark
-A.  Stratman, Mark Dootson, Mark Jason Dominus, Martin Hasch, Matthew
-Horsfall, Max Maischein, Michael G Schwern, Michael Witten, Mike
-Sheldrake, Moritz Lenz, Nicholas Clark, Niko Tyni, Nuno Carvalho, Pau
-Amma, Paul Evans, Paul Green, Paul Johnson, Perlover, Peter John Acklam,
-Peter Martini, Peter Scott, Phil Monsen, Pino Toscano, Rafael
-Garcia-Suarez, Rainer Tammer, Reini Urban, Ricardo Signes, Robin Barker,
-Rodolfo Carvalho, Salvador Fandiño, Sam Kimbrel, Samuel Thibault, Shawn
-M Moore, Shigeya Suzuki, Shirakata Kentaro, Shlomi Fish, Sisyphus,
-Slaven Rezic, Spiros Denaxas, Steffen Müller, Steffen Schwigon, Stephen
-Bennett, Stephen Oberholtzer, Stevan Little, Steve Hay, Steve Peters,
-Thomas Sibley, Thorsten Glaser, Timothe Litt, Todd Rinaldo, Tom
-Christiansen, Tom Hukins, Tony Cook, Vadim Konovalov, Vincent Pit,
-Vladimir Timofeev, Walt Mankowski, Yves Orton, Zefram, Zsbán Ambrus,
-Ævar Arnfjörð Bjarmason.
-
-The list above is almost certainly incomplete as it is automatically
-generated from version control history.  In particular, it does not
-include the names of the (very much appreciated) contributors who
-reported issues to the Perl bug tracker.
-
-Many of the changes included in this version originated in the CPAN
-modules included in Perl's core.  We're grateful to the entire CPAN
-community for helping Perl to flourish.
-
-For a more complete list of all of Perl's historical contributors,
-please see the F<AUTHORS> file in the Perl source distribution.
+XXX Generate this with:
+
+  perl Porting/acknowledgements.pl v5.16.0..HEAD
 
 =head1 Reporting Bugs
 
 If you find what you think is a bug, you might check the articles
 recently posted to the comp.lang.perl.misc newsgroup and the perl
-bug database at L<http://rt.perl.org/perlbug/>.  There may also be
-information at L<http://www.perl.org/>, the Perl Home Page.
+bug database at http://rt.perl.org/perlbug/ .  There may also be
+information at http://www.perl.org/ , the Perl Home Page.
 
 If you believe you have an unreported bug, please run the L<perlbug>
 program included with your release.  Be sure to trim your bug down
@@ -4302,14 +372,15 @@ output of C<perl -V>, will be sent off to perlbug@perl.org to be
 analysed by the Perl porting team.
 
 If the bug you are reporting has security implications, which make it
-inappropriate to send to a publicly archived mailing list, then please
-send it to perl5-security-report@perl.org.  This points to a closed
-subscription unarchived mailing list, which includes all core
-committers, who will be able to help assess the impact of issues, figure
-out a resolution, and help co-ordinate the release of patches to
-mitigate or fix the problem across all platforms on which Perl is
-supported.  Please use this address only for security issues in the Perl
-core, not for modules independently distributed on CPAN.
+inappropriate to send to a publicly archived mailing list, then please send
+it to perl5-security-report@perl.org. This points to a closed subscription
+unarchived mailing list, which includes
+all the core committers, who will be able
+to help assess the impact of issues, figure out a resolution, and help
+co-ordinate the release of patches to mitigate or fix the problem across all
+platforms on which Perl is supported. Please only use this address for
+security issues in the Perl core, not for modules independently
+distributed on CPAN.
 
 =head1 SEE ALSO
 
index bafbb66..0d48b35 100644 (file)
@@ -326,7 +326,7 @@ x2p : [.x2p]$(DBG)a2p$(E) [.x2p]s2p.com [.x2p]find2perl.com
 extra.pods : miniperl
        @ @extra_pods.com
 
-PERLDELTA_CURRENT = [.pod]perl5160delta.pod
+PERLDELTA_CURRENT = [.pod]perl5161delta.pod
 
 $(PERLDELTA_CURRENT) : [.pod]perldelta.pod
        Copy/NoConfirm/Log $(MMS$SOURCE) $(MMS$TARGET)
index 16e2fd9..8c7571a 100644 (file)
@@ -1075,7 +1075,7 @@ utils: $(PERLEXE) $(X2P)
        copy ..\README.vmesa    ..\pod\perlvmesa.pod
        copy ..\README.vos      ..\pod\perlvos.pod
        copy ..\README.win32    ..\pod\perlwin32.pod
-       copy ..\pod\perldelta.pod ..\pod\perl5160delta.pod
+       copy ..\pod\perldelta.pod ..\pod\perl5161delta.pod
        cd ..\win32
        $(PERLEXE) $(PL2BAT) $(UTILS)
        $(PERLEXE) $(ICWD) ..\autodoc.pl ..
@@ -1168,7 +1168,7 @@ distclean: realclean
        -if exist $(LIBDIR)\XS rmdir /s /q $(LIBDIR)\XS
        -if exist $(LIBDIR)\Win32API rmdir /s /q $(LIBDIR)\Win32API
        -cd $(PODDIR) && del /f *.html *.bat roffitall \
-           perl5160delta.pod perlaix.pod perlamiga.pod perlapi.pod \
+           perl5161delta.pod perlaix.pod perlamiga.pod perlapi.pod \
            perlbeos.pod perlbs2000.pod perlce.pod perlcn.pod \
            perlcygwin.pod perldgux.pod perldos.pod perlepoc.pod \
            perlfreebsd.pod perlhaiku.pod perlhpux.pod perlhurd.pod \
index 9e4d339..6eef9b6 100644 (file)
@@ -1261,7 +1261,7 @@ utils: $(PERLEXE) $(X2P)
        copy ..\README.vmesa    ..\pod\perlvmesa.pod
        copy ..\README.vos      ..\pod\perlvos.pod
        copy ..\README.win32    ..\pod\perlwin32.pod
-       copy ..\pod\perldelta.pod ..\pod\perl5160delta.pod
+       copy ..\pod\perldelta.pod ..\pod\perl5161delta.pod
        $(PERLEXE) $(PL2BAT) $(UTILS)
        $(PERLEXE) $(ICWD) ..\autodoc.pl ..
        $(PERLEXE) $(ICWD) ..\pod\perlmodlib.pl -q
@@ -1353,7 +1353,7 @@ distclean: realclean
        -if exist $(LIBDIR)\XS rmdir /s /q $(LIBDIR)\XS
        -if exist $(LIBDIR)\Win32API rmdir /s /q $(LIBDIR)\Win32API
        -cd $(PODDIR) && del /f *.html *.bat roffitall \
-           perl5160delta.pod perlaix.pod perlamiga.pod perlapi.pod \
+           perl5161delta.pod perlaix.pod perlamiga.pod perlapi.pod \
            perlbeos.pod perlbs2000.pod perlce.pod perlcn.pod \
            perlcygwin.pod perldgux.pod perldos.pod perlepoc.pod \
            perlfreebsd.pod perlhaiku.pod perlhpux.pod perlhurd.pod \
index e7bb256..04c4b36 100644 (file)
@@ -27,6 +27,7 @@ POD = perl.pod        \
        perl5141delta.pod       \
        perl5142delta.pod       \
        perl5160delta.pod       \
+       perl5161delta.pod       \
        perl561delta.pod        \
        perl56delta.pod \
        perl581delta.pod        \
@@ -145,6 +146,7 @@ MAN = perl.man      \
        perl5141delta.man       \
        perl5142delta.man       \
        perl5160delta.man       \
+       perl5161delta.man       \
        perl561delta.man        \
        perl56delta.man \
        perl581delta.man        \
@@ -263,6 +265,7 @@ HTML = perl.html    \
        perl5141delta.html      \
        perl5142delta.html      \
        perl5160delta.html      \
+       perl5161delta.html      \
        perl561delta.html       \
        perl56delta.html        \
        perl581delta.html       \
@@ -381,6 +384,7 @@ TEX = perl.tex      \
        perl5141delta.tex       \
        perl5142delta.tex       \
        perl5160delta.tex       \
+       perl5161delta.tex       \
        perl561delta.tex        \
        perl56delta.tex \
        perl581delta.tex        \