=head1 Notice
-XXX Any important notices here
+As described in L<perlpolicy>, the release of Perl 5.16.0 marks the
+official end of support for Perl 5.12. Users of Perl 5.12 or earlier
+should consider upgrading to a more recent release of Perl.
=head1 Core Enhancements
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
+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.
=head3 C<substr> lvalue revamp
-=for comment Can this be compacted some? -- rjbs, 2012-02-20
+=for comment Does this belong here, or under Incomptable 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
looked at by C<substr> itself, but only when the returned lvalue is
read or modified.
-These changes result in several incompatible changes and bug fixes:
-
-=over
-
-=item *
+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
lvalue will always extend to the end of the string, even if the string
becomes longer.
-=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 only makes a difference if the
-return value of C<substr> is referenced and assigned to later.
-
-=item *
-
-The order in which "uninitialized" warnings occur for arguments to
-C<substr> has changed.
-
-=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 only occurs
-if and when the value passed is assigned to.
-
-The same thing happens with the "substr outside of string" error. If
-the lvalue is only read, 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
-
-It was impossible to fix all the bugs without an incompatible change,
-and the behaviour of negative offsets was never specified, so the
+Since this change also allowed many bugs to be fixed (see
+L</The C<substr> operator>), and since the behaviour
+of negative offsets has never been specified, so the
change was deemed acceptable.
=head3 Return value of C<tied>
C<*{"*a::b"}> automatically strips off the * if it is followed by an ASCII
letter. That has been extended to all Unicode identifier characters.
-C<$é> is now subject to "Used only once" warnings. It used to be exempt,
-as it was treated as a punctuation variable.
+One-character non-ASCII non-punctuation variables (like C<$é>) are now
+subject to "Used only once" warnings. They used to be exempt, as they
+was treated as punctuation variables.
-Also, single-character Unicode punctuation variables (like $‰) are now
-supported [perl #69032]. They are also supported with C<our> and C<my>,
-but that is a mistake that will be fixed before 5.16.
+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
=head3 C<enable> and C<disable>
The debugger now has C<disable> and C<enable> commands for disabling
-existing breakpoints and re
ënabling them. See L<perldebug>.
+existing breakpoints and re
-enabling them. See L<perldebug>.
=head3 Breakpoints with file names
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
F<lib/unicore/ToDigit.pl>. L<Unicode::UCD/prop_invmap()> can be used to
get at its data instead.
-=head2 C<is_utf8_char()>
+=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()>
-instead.
+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
Swapping of $< and $>
-https://rt.perl.org/rt3/Ticket/Display.html?id=96212
+For more information about this future deprecation, see L<the relevant RT
+ticket|https://rt.perl.org/rt3/Ticket/Display.html?id=96212>.
=item *
Unescaped literal C<< "{" >> in regular expressions.
+It is planned starting in v5.20 to require a literal C<"{"> to be
+escaped by, for example, preceding it with a backslash. In v5.18, a
+deprecated warning message will be emitted for all such uses. Note that
+this only affects patterns which are to match a literal C<"{">. Other
+uses of this character, such as part of a quantifier or sequence like in
+the ones below are completely unaffected:
+
+ /foo{3,5}/
+ /\p{Alphabetic}/
+ /\N{DIGIT ZERO}
+
+The removal of this will allow extensions to pattern syntax, and better
+error checking of existing syntax. See L<perlre/Quantifiers> for an
+example.
+
=back
=head1 Incompatible Changes
treat it as undefined, producing an "uninitialized" warning.
Now it stringifies as __ANONIO__ [perl #96326].
-=head2 User-defined case changing operations.
+=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
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
-
sete?[ug]id() without updating C<PL_e?[ug]id>. Having to deal with
+
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.
C<substr> no longer calculates a value to return when called in void
context.
-=item Literal C<"{"> characters in regular expression patterns
-
-It is planned starting in v5.20 to require a literal C<"{"> to be
-escaped by, for example, preceding it with a backslash. In v5.18, a
-deprecated warning message will be emitted for all such uses. Note that
-this only affects patterns which are to match a literal C<"{">. Other
-uses of this character, such as part of a quantifier or sequence like in
-the ones below are completely unaffected:
-
- /foo{3,5}/
- /\p{Alphabetic}/
- /\N{DIGIT ZERO}
-
-The removal of this will allow extensions to pattern syntax, and better
-error checking of existing syntax. See L<perlre/Quantifiers> for an
-example.
-
-=back
-
-=over 4
-
=item *
Due to changes in L<File::Glob>, Perl's C<glob> function and its C<<
into words has been rewritten in C, resulting in speed-ups of 20% in
some cases.
-This does not affect VMS, as it does not use File::Glob.
+This does not affect C<glob> on VMS, as it does not use File::Glob.
=item *
=head1 Modules and Pragmata
-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.
-
-[ Within each section, list entries as a =item entry ]
-
=head2 Deprecated Modules
=over
=item L<Version::Requirements>
-Version::Requirements is now DEPRECATED, use CPAN::Meta::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.
=item *
-The section on the triple-dot or yada-yada operator has been moved up, as
-it used to separate two closely related sections about the comma operator
-(5.14.1).
-
-=item *
-
More examples for C<m//g> have been added (5.14.1).
=item *
=item *
-The L<perlsub/"Lvalue subroutines"> section has been amended to reflect
-the many changes present in 5.16.0.
-
-=item *
-
The ($;) prototype syntax, which has existed for rather a long time, is now
documented in L<perlsub>. It allows a unary function to have the same
precedence as a list operator.
=item *
-Documented the required syntax for tying handles.
+The required syntax for tying handles has been documented.
=back
=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.
-
-=item *
-
L<&CORE::%s cannot be called directly|perldiag/"&CORE::%s cannot be called directly">
-(F) You tried to call a subroutine in the C<CORE::> namespace
+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. Something like this will work:
+called as barewords. See L</Subroutines in the C<CORE> namespace>, above.
+
+=item *
- BEGIN { *shove = \&CORE::push; }
- shove @array, 1,2,3; # pushes on to @array
+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
=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>.
-
-=item *
-
-L<overload arg '%s' is invalid|perldiag/"overload arg '%s' is invalid">
+L<length() used on %s|perldiag/length() used on %s>
-This warning, in the "overload" category, is produced when the overload
-pragma is given an argument it doesn't recognize, presumably a mistyped
-operator.
+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<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
+L<lvalue attribute %s already-defined subroutine|perldiag/"lvalue attribute %s already-defined subroutine">
-Assigning to a temporary returned from an XS lvalue subroutine now produces a
-warning [perl #31946].
+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<length() used on %s|perldiag/length() used on %s>
+L<overload arg '%s' is invalid|perldiag/"overload arg '%s' is invalid">
-This new warning occurs when C<length> is used on an array or hash, instead
-of C<scalar(@array)> or C<scalar(keys %hash)>.
+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. C<$[> in a numeric
-comparison is almost always wrong.
+checks. C<$]>, not C<$[>, contains the version number.
=item *
-L<Use of assignment to $[ is deprecated|perldiag/"Use of assignment to $[ is deprecated">
+L<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
-This previously removed warning has been restored with the re-implementation
-of C<$[> as a module.
+Assigning to a temporary scalar returned
+from an lvalue subroutine now produces this
+warning [perl #31946].
=item *
-L<lvalue attribute %s already-defined subroutine|perldiag/"lvalue attribute %s already-defined subroutine">
+L<Useless use of \E|perldiag/"Useless use of \E">
-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.
+C<\E> does nothing unless preceded by C<\Q>, C<\L> or C<\U>.
=back
-=head2 Removed Warnings
+=head2 Removed Errors
=over
=item *
-Redefinition warnings for constant subroutines used to be mandatory,
-even occurring under C<no warnings>. Now they respect the L<warnings>
-pragma.
+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 *
=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 *
-
The error messages for using C<default> and C<when> outside of a
topicalizer have been standardised to match the messages for C<continue>
and loop controls. They now read 'Can't "default" outside a
=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.
+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 *
-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.
+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 *
=item *
-The message, "Code point 0x%X is not Unicode, no properties match it;
-all inverse prop erties do" has been changed to "Code point 0x%X is not
-Unicode, all \p{} matches fail; all \P{} matches succeed"
+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 *
=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.
=item *
-The C<-Dusesitecustomize> and C<-Duserelocatableinc> options now work
-together properly.
-
-=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 *
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
+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
+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()>
-
-=back
+OPs are freed. C<MADPROP>s are now allocated with C<PerlMemShared_malloc()>
-=head1 Testing
+=item *
-XXX Any significant changes to the testing of a freshly built perl should be
-listed here. Changes which create B<new> files in F<t/> go here as do any
-large changes to the testing harness (e.g. when parallel testing was added).
-Changes to existing files in F<t/> aren't worth summarising, although the bugs
-that they represent may be covered elsewhere.
+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).
-[ List each test improvement as a =item entry ]
+=item *
-=over 4
+C<useperlio> can no longer be disabled.
=item *
-XXX
+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.
-=back
+As F<global.sym> was never installed, this change should not be visible
+outside the build process.
-=head1 Platform Support
+=item *
-XXX Any changes to platform support should be listed in the sections below.
+F<pod/buildtoc>, used by the build process to build L<perltoc>, has been
+refactored and simplified. It now only contains 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.
-[ Within the sections, list each platform as a =item entry with specific
-changes as paragraphs below it. ]
+=item *
-=head2 New Platforms
+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.
-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.
+=item *
-=over 4
+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 XXX-some-platform
+=item *
-XXX
+The -Dusesitecustomize and -Duserelocatableinc options now work
+together properly.
=back
-=head2 Discontinued Platforms
-
-XXX List any platforms that this version of perl no longer compiles on.
-
-=over 4
-
-=item XXX-some-platform
-
-XXX
-
-=back
+=head1 Platform Support
=head2 Platform-Specific Notes
=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.
+
+=back
+
=head3 VMS
=over 4
=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 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)
-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 *
+
+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 *
-F<lib/feature.pm> is now a generated file, created by the new
-F<regen/feature.pl> script, which also generates F<feature.h>.
+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 *
-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.
+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
+behaviour 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 or not to export XSUB
+symbols. More detail can be found in the comments for commit e64345f8.
=item *
=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>.
All the C files that make up the Perl core have been converted to UTF-8.
-=back
+=item *
-=head1 Selected Bug Fixes
+These new functions have been added as part of the work on Unicode symbols:
-=head2 Regular expressions and character classes
+ 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
-=over 4
+The gv_fetchmethod_*_flags functions, like gv_fetchmethod_flags, are
+experimental and may change in a future release.
=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.
+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</.*/g> would sometimes refuse to match at the end of a string that ends
-with "\n". This has been fixed [perl #109206].
-
-=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.
+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 *
-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
-behaviour.
+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 *
-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.
+Perl now checks whether the array (the linearised 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 *
-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)
+C<PL_curstash> is now reference-counted.
=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
+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.
-is one such case. C<\xDF> folds to C<"ss">. (5.14.1)
+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 *
-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.
+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 *
-Fixed memory leak regression in regular expression compilation
-under threading
+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 *
-A regression introduced in 5.13.6 was 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.
-
-=back
-
-=head2 Formats
-
-=over
+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 *
-A number of 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].
+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 *
-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].
+There is a new C<wrap_op_checker()> function, which provides a thread-safe
+alternative to writing to C<PL_check> directly.
=back
-=head2 Copy-on-write scalars
+=head1 Selected Bug Fixes
-Copy-on-write 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.
+=head2 Array and hash
=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].
+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 *
-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.
+Deleting the current hash iterator (the hash element that would be returend
+by the next call to C<each>) in void context used not to free it
+[perl #85026].
=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 = ()>).
+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 *
-Localising a tied variable used to make it read-only if it contained a
-copy-on-write string.
+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 *
-L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
-See L</Updated Modules and Pragmata>, above.
+A C<keys> optimisation 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.
-=back
+=item *
-=head2 lvalue subroutines
+Freeing deeply nested hashes no longer crashes [perl #44225].
-There have been various fixes to lvalue subroutines.
+=item *
-=over
+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 *
-Explicit return now returns the actual argument passed to return, instead
-of copying it [perl #72724, #72706].
-
-B<Note:> There are still some discrepancies between explicit and implicit
-return, which will hopefully be resolved soon. So the exact behaviour is
-not set in stone yet.
+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 *
-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.
+It used to be possible to free the typeglob of a localised array or hash
+(e.g., C<local @{"x"}; delete $::{x}>), resulting in a crash on scope exit.
=item *
-Lvalue subroutines are less restrictive as to 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].
+Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
+element that is a glob copy no longer causes subsequent assignment to it to
+corrupt the glob, 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.
-=item *
+=back
-Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
-context. In fact, all subroutines used to, but regular subs were fixed in
-Perl 5.8.2. Now lvalue subroutines have been likewise fixed.
+=head2 C API fixes
+
+=over
=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].
+The C<newHVhv> XS function now works on tied hashes, instead of crashing or
+returning an empty hash.
=item *
-Autovivification now works on values returned from lvalue subroutines
-[perl #7946].
+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 *
-When called in pass-by-reference context (e.g., subroutine arguments or a list
-passed to C<for>), an lvalue subroutine returning arrays or hashes used to bind
-the arrays (or hashes) to scalar variables--something that is not supposed to
-happen. This could result in "Bizarre copy of ARRAY" errors or C<print>
-ignoring its arguments. It also made nonsensical code like C<@{\$_}> "work".
-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].
+The C<SvPVutf8> C function no longer tries to modify its argument,
+resulting in errors [perl #108994].
=item *
-When called in pass-by-reference context, 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.
+C<SvPVutf8> now works properly with magical variables.
=item *
-Assignment to C<keys> returned from an lvalue sub used not to work, but now
-it does.
+C<SvPVbyte> now works properly non-PVs.
=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.
+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 *
-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.
+The C-level C<pregcomp> function could become confused as to whether the
+pattern was in UTF8 if the pattern was an overloaded, tied, or otherwise
+magical scalar [perl #101940].
=back
-=head2 Fixes related to hashes
+=head2 Compile-time hints
=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)
+Tying C<%^H> no longer causes perl to crash or ignore the contents of
+C<%^H> when entering a compilation scope [perl #106282].
=item *
-Freeing deeply nested hashes no longer crashes [perl #44225].
+C<eval $string> and C<require> used not to
+localise 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 *
-Deleting the current hash iterator (the hash element that would be returend
-by the next call to C<each>) in void context used not to free it. The hash
-would continue to reference it until the next iteration. This has been
-fixed [perl #85026].
+C<eval $string> and C<require> no longer localise 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].
-=back
+=item *
-=head2 Support for Embedded Nulls
+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.
-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:
+=back
-=over
+=head2 Copy-on-write scalars
-=item *
+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.
-Method names
+=over
=item *
-Typeglob names (including filehandle names)
+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].
=item *
-Package names
+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 *
-Autoloading
+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 = ()>).
=item *
-Return value of C<ref()>
+Localising a tied variable used to make it read-only if it contained a
+copy-on-write string.
=item *
-Package names returned by C<caller()>
+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 *
-Filehandle warnings
+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 *
-Typeglob elements (C<*foo{"THING\0stuff"}>)
+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 *
-Signal names
+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 *
-Various warnings and error messages that mention variable names or values,
-methods, etc.
+L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
+See L</Updated Modules and Pragmata>, above.
=back
-One side effect of these changes is that blessing into "\0" no longer
-causes C<ref()> to return false.
-
-=head2 Other notable fixes
+=head2 The debugger
=over
=item *
-Last-accessed filehandle
+F<dumpvar.pl>, and consequently 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].
-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.
+=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:
+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].
- 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
+=item *
-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.
+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 only worked for a single C<#line 42 foo> in each eval. Now
+it works for multiple.
=item *
-C<stat _> no longer warns about unopened filehandles [perl #71002].
+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. In some cases (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 *
-C<stat> on an unopened filehandle now warns consistently, instead of
-skipping the warning at times.
+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
-=item *
+=head2 Dereferencing operators
-C<-t> now works when stacked with other filetest operators [perl #77388].
+=over
=item *
-Stacked filetest operators now only call FETCH once on a tied argument.
+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 *
-C<~~> now correctly handles the precedence of Any~~Object, and is not tricked
-by an overloaded object on the left-hand side.
+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 *
-Tying C<%^H>
+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.
-Tying C<%^H> no longer causes perl to crash or ignore the contents of
-C<%^H> when entering a compilation scope [perl #106282].
+=back
-=item *
+=head2 Filehandle, last-accessed
-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
-infamous L<perlunicode/The "Unicode Bug">. [perl #77654].
+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.
-Which of these code points is quoted has changed, based on Unicode's
-recommendations. See L<perlfunc/quotemeta> for details.
+=over
=item *
-C<~> on vstrings
+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:
-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].
+ 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 *
-Vstrings blowing away magic
+A regression in 5.14 caused these statements not to set that internal
+variable:
-Assigning a vstring to a magic (e.g., tied, C<$!>) variable and then
-assigning something else used to blow away all the 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.
+ my $fh = *STDOUT;
+ tell $fh;
+ eof $fh;
+ seek $fh, 0,0;
+ tell *$fh;
+ eof *$fh;
+ seek *$fh, 0,0;
+ readline *$fh;
-=item *
+This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
+is not clear how to fix it [perl #106536].
-C<newHVhv> and tied hashes
+=back
-The C<newHVhv> XS function now works on tied hashes, instead of crashing or
-returning an empty hash.
+=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 *
-Hashes will null elements
+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.
-It is possible from XS code to create hashes with elements that have no
-values. Perl itself sometimes creates such hashes, but they are rarely
-visible to Perl code. The hash element and slice operators used to crash
-when handling these in lvalue context. These have been fixed. They now
-produce a "Modification of non-creatable hash value attempted" error
-message.
+=item *
+
+C<stat> would sometimes return negative numbers for large inode numbers,
+because it was using the wrong internal C type. [perl #84590]
=item *
-No warning for C<open(foo::bar)>
+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.
-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 *
+
+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<select> and package aliasing
+C<-T>, C<-B>, C<-l> and C<-t> now work
+when stacked with other filetest operators
+[perl #77388].
-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 *
+
+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 *
-C<PerlIO::get_layers> and tied variables
+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
+behaviour has been restored.
+
+=item *
-C<PerlIO::get_layers> no longer ignores FETCH on tied variables as it used
-to most of the time [perl #97956].
+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 *
-C<PerlIO::get_layers> and numbers
+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.
-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).
+There were various cases where these could get out of synch, resulting in
+inconsistent or erratic behaviour in edge cases (every mention of C<-T>
+applies to C<-B> as well):
-=item *
+=over
-Lvalue subs and strict mode
+=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].
+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 *
-Non-lvalue sub calls in potentially lvalue context
+Freeing the handle last used by C<stat> or a filetest could result in
+S<C<-T _>> using an unrelated handle.
-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].
+=item *
-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.
+C<stat> with an IO reference would not reset the stat type or record the
+filehandle for S<C<-T _>> to use.
=item *
-AUTOLOADing lvalue subs
+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<$!>.
-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 *
+
+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<caller> and tied C<@DB::args>
+C<-T I<FILENAME>> was not resetting the internal stat buffers for
+unreadable files.
-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.
+=back
-=item *
+These have all been fixed.
+
+=back
-Tying C<@_>
+=head2 Formats
-Under debugging builds, this code:
+=over
- sub TIEARRAY{bless[]}
- sub {
- tie @_, "";
- \@_;
- }->(1);
+=item *
-use to produce an "av_reify called on tied array" warning. It doesn't any
-more.
+A number of 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 *
-Unrecognised switches on C<#!> line
+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].
-If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
-there, perl dies with "Can't emulate...".
+=item *
-It used to produce the same message for switches that perl did not
-recognise at all, whether on the command line or the C<#!> line.
+Assignment to C<$^A> (the format output accumulator) now recalculates
+the number of lines output.
-Now it produces the "Unrecognized switch" error message [perl #104288].
+=back
+
+=head2 C<given> and C<when>
+
+=over
=item *
-C<system> and SIGCHLD
+C<given> was not scoping its implicit $_ properly, resulting in memory
+leaks or "Variable is not available" warnings [perl #94682].
-C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
-signal handler from stealing the exit status [perl #105700].
+=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 *
-Deleting methods via C<delete>
+C<when> blocks are now capable of returning variables declared inside the
+enclosing C<given> block [perl #93548].
+
+=back
-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.
-Now it always updates those caches.
+=head2 The C<glob> operator
+
+=over
=item *
-Hash element deletion and destructors
+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.
-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].
+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<(s)printf>'s %n formatting code
+C<CORE::glob> now works as a way to call the default globbing function. It
+used to respect overrides, despite the C<CORE::> prefix.
-The %n formatting code, which causes the number of characters to be
-assigned to the next argument to C<printf> or C<sprintf> now actually
-assigns the number of characters, instead of the number of bytes.
+=item *
-It also works now with special lvalue functions like C<substr> and with
-nonexistent hash and array elements [perl #3471, #103492].
+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 enviroment
+variable [perl #98662].
-=item *
+=back
-Typeglobs and threads
+=head2 Lvalue subroutines
-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].
+=over
=item *
-C<local $_>
-
-In Perl 5.14, C<local $_> was changed to create a new variable not tied to
-anything, even if $_ was tied before that. But, due to an oversight, it
-would still call FETCH once on a tied $_ before replacing it with the new
-variable. This has been fixed [perl #105912].
+Explicit return now returns the actual argument passed to return, instead
+of copying it [perl #72724, #72706].
=item *
-Returning tied variables
-
-When returning a value from a non-lvalue subroutine, Perl copies the value.
-Sometimes it cheats for the sake of speed, and does not copy the value if
-it makes no observable difference. This optimisation was erroneously
-allowing the copy to be skipped on tied variables, causing a difference in
-behaviour depending on the tied variable's reference count. This has been
-fixed [perl #95548].
+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 *
-C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
+Lvalue subroutines are less restrictive as to 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 *
-C<dbmopen> with undefined mode
-
-C<dbmopen> now only warns once, rather than three times, if the mode
-argument is C<undef> [perl #90064].
+Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
+context. In fact, all subroutines used to, but regular subs were fixed in
+Perl 5.8.2. Now lvalue subroutines have been likewise fixed.
=item *
-Freeing an aggregate during list assignment
+Autovivification now works on values returned from lvalue subroutines
+[perl #7946], as does returning C<keys> in lvalue context.
-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 *
+
+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 *
-Confused internal bookkeeping with @ISA arrays
+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.
-Creating a weak reference to an @ISA array or accessing the array index
-(C<$#ISA>) could result in confused internal bookkeeping for elements
-subsequently 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].
+=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 *
-DELETE on scalar ties
+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.
-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 *
+
+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 *
-Freeing $_ inside C<grep> or C<map>
+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].
-Freeing $_ inside a C<grep> or C<map> block or a code block embedded in a
-regular expression used to result in double frees [perl #92254, #92256].
+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 *
-Warnings with C<+=>
+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.
-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 *
+
+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 *
-Tying and autovivification
+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.
-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].
+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 *
-C<@&> and C<$&>
+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.
-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].
+=back
+
+=head2 Overloading
+
+=over
=item *
-Stacked filetests
+Arithmetic assignment (C<$left += $right>) involving overloaded objects
+that rely on the 'nomethod' override no longer segfault when the left
+operand is not overloaded.
-C<-T> and C<-B> now work when stacked up with other filetest operators
-[perl #77388].
+=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 *
-Filetests and stat buffers
+Undefining C<%overload::> no longer causes a crash.
-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.
+=back
-There were various cases where these could get out of synch, resulting in
-inconsistent or erratic behaviour in edge cases (every mention of C<-T>
-applies to C<-B> as well):
+=head2 Prototypes of built-in keywords
=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.
+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 *
-Freeing the handle last used by C<stat> or a filetest could result in
-S<C<-T _>> using an unrelated handle.
+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 *
-C<stat> with an IO reference (as returned by C<*STDIO{IO}>, for instance)
-would not reset the stat type.
+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<stat> with an IO reference was not recording the filehandle for
-S<C<-T _>> to use.
+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 *
-The presence of 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.
+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 *
-Fatal warnings would stop C<-T> from setting C<$!>.
+C</.*/g> would sometimes refuse to match at the end of a string that ends
+with "\n". This has been fixed [perl #109206].
=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.
+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
+behaviour.
=item *
-C<-T I<FILENAME>> was not resetting the internal stat buffers for
-unreadable files.
+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:
-=back
+ "\N{KELVIN SIGN}" =~ /k|foo/iaa;
-These have all been fixed.
+succeeded inappropriately. This is now fixed.
=item *
-C<-T _> with no preceding C<stat>
-
-This used to produce a confusing "uninitialized" warning, even though there
-is no visible uninitialized value to speak of.
+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 *
-C<stat I<HANDLE>> and fstat failures
+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
-If the operating system's C<fstat> function failed, C<stat> would warn
-about an unopened handle, even though that was not the case. This has been
-fixed.
+is one such case. C<\xDF> folds to C<"ss">. (5.14.1)
=item *
-C<lstat I<IOREF>>
-
-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.
+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 *
-Bitwise assignment operators and copy-on-write
+A memory leak regression in regular expression compilation
+under threading has been fixed.
-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. This has been fixed [perl #108480].
+=item *
+
+A regression introduced in 5.13.6 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 *
=item *
-A constant subroutine assigned to a glob whose name contains a null
-will no longer cause extra globs to pop into existence when the
-constant is referenced under its new name.
-
-=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 *
-
-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 was only the case
-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.
+In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
+opposite case. This has been fixed [perl #101970].
=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}
+A regular expression match with an overloaded object on the right-hand side
+would in some cases stringify the object too many times.
=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].
+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 *
-C<< version->new("version") >> and C<printf "%vd", "version"> no longer
-crash [perl #102586].
+In case-insensitive regular expression pattern matching, no longer on
+UTF-8 encoded strings does the scan for the start of match only look at
+the first possible position. This caused matches such as
+C<"f\x{FB00}" =~ /ff/i> to fail.
=item *
-C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> now call FETCH
-just once when $tied holds a reference.
+The regexp optimiser no longer crashes on debugging builds when merging
+fixed-string nodes with inconvenient contents.
=item *
-Four-argument C<select> now always calls FETCH on tied arguments. It
-used to skip the call if the tied argument happened to hold C<undef> or
-a typeglob.
+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].
=item *
-Four-argument C<select> no longer produces its "Non-string passed as
-bitmask" warning on tied or tainted variables that are strings.
+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<sysread> now always calls FETCH on the buffer passed to it if the
-buffer is tied. It used to skip the call if the tied variable happened
-to hold a typeglob.
+C<< (?foo: ...) >> no longer loses passed in character set.
=item *
-C<< $tied .= <> >> now calls FETCH once on C<$tied>. It used to call
-it multiple times if the last value assigned to or returned from the
-tied variable was anything other than a string or typeglob.
+The trie optimisation 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 *
-Return value of C<eval>
-
-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 *
+Use of lexical (C<my>) variables in code blocks embedded in regular
+expressions will no longer result in memory corruption or crashes.
-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].
+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 *
-Arithmetic assignment (C<$left += $right>) involving overloaded objects
-that rely on the 'nomethod' override no longer segfault when the left
-operand is not overloaded.
+The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
+cause a panic error message when attempting to match at the end of the
+string [perl #96354].
=item *
-Assigning C<__PACKAGE__> or any other shared hash key scalar to a stash
-element no longer causes a double free. Regardless of this change, the
-results of such assignments are still undefined.
+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 *
-Assigning C<__PACKAGE__> or another shared hash key string to a
-variable no longer stops that variable from being tied if it happens to
-be a PVMG or PVLV internally.
+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].
-=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.
+=back
-=item *
+=head2 Smartmatching
-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.
+=over
=item *
-The debugger no longer tries to do C<local $_> when dumping data
-structures.
+C<~~> now correctly handles the precedence of Any~~Object, and is not tricked
+by an overloaded object on the left-hand side.
=item *
-Calling C<readline($fh)> where $fh is a glob copy (e.g., after C<$fh =
-*STDOUT>), assigning something other than a glob to $fh, and then
-freeing $fh (e.g., by leaving the scope where it is defined) no longer
-causes the internal variable used by C<$.> (C<PL_last_in_gv>) to point
-to a freed scalar, that could be reused for some other glob, causing
-C<$.> to use some unrelated filehandle [perl #97988].
-
-=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].
-A regression in 5.14 caused these statements not to set the internal
-variable that holds the handle used by C<$.>:
+=back
- my $fh = *STDOUT;
- tell $fh;
- eof $fh;
- seek $fh, 0,0;
- tell *$fh;
- eof *$fh;
- seek *$fh, 0,0;
- readline *$fh;
+=head2 The C<sort> operator
-This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
-is not clear how to fix it [perl #106536].
+=over
=item *
-Version comparisons, such as those that happen implicitly with C<use
-v5.43>, no longer cause locale settings to change [perl #105784].
+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 *
-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;
+C<sort> now works once more with custom sort routines that are XSUBs. It
+stopped working in 5.10.0.
=item *
-F<dumpvar.pl>, and consequently 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].
+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 *
-The C<x> repetition operator no longer crashes on 64-bit builds with large
-repeat counts [perl #94560].
+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 occur now 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 *
-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.
+C<< sort { $a <=> $b } >>, which is optimised 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
+optimised [perl #94390].
-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].
+=back
-=item *
+=head2 The C<substr> operator
-C<CORE::glob> now works as a way to call the default globbing function. It
-used to respect overrides, despite the C<CORE::> prefix.
+=over
=item *
-In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
-opposite case. This has been fixed [perl #101970].
+Tied (and otherwise magical) variables are no longer exempt from the
+"Attempt to use reference as lvalue in substr" warning.
=item *
-A regular expression match with an overloaded object on the right-hand side
-would in some cases stringify the object too many times.
+That warning now occurs when the returned lvalue is assigned to, not
+when C<substr> itself is called. This only makes a difference if the
+return value of C<substr> is referenced and assigned to later.
=item *
-The C-level C<pregcomp> function could become confused as to whether the
-pattern was in UTF8 if the pattern was an overloaded, tied, or otherwise
-magical scalar [perl #101940].
+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 only occurs
+if and when the value passed is assigned to.
+
+The same thing happens with the "substr outside of string" error. If
+the lvalue is only read, not written to, it is now just a warning, as
+with rvalue C<substr>.
=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]
+C<substr> assignments no longer call FETCH twice if the first argument
+is a tied variable, just once.
-=item *
+=back
-Weak references to lexical hashes going out of scope were not going stale
-(becoming undefined), but continued to point to the hash.
+=head2 Support for embedded nulls
-=item *
+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:
-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.
+=over
=item *
-A C<keys> optimisation 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. This has been fixed.
+Method names
=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 only worked for a single C<#line 42 foo> in each eval. Now
-it works for multiple.
+Typeglob names (including filehandle and subroutine names)
=item *
-String eval used not to localise C<%^H> when compiling its argument 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].
+Package names, including the return value of C<ref()>
=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.
+Typeglob elements (C<*foo{"THING\0stuff"}>)
=item *
-C<eval $string> and C<require> no longer localise 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].
+Signal names
=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. In some cases (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].
+Various warnings and error messages that mention variable names or values,
+methods, etc.
-=item *
+=back
-Localising a tied scalar that returns a typeglob no longer stops it from
-being tied till the end of the scope.
+One side effect of these changes is that blessing into "\0" no longer
+causes C<ref()> to return false.
-=item *
+=head2 Threading bugs
-When C<open> is called with three arguments, the third being a file handle
-(as in C<< open $fh, ">&", $fh2 >>), if the third argument is tied or a
-reference to a tied variable, FETCH is now called exactly once, instead of
-0, 2, or 3 times (all of which could occur in various circumstances).
+=over
=item *
-C<sort> no longer ignores FETCH when passed a reference to a tied glob for
-the comparison routine.
+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 *
-Warnings emitted by C<sort> when a custom comparison routine returns a
-non-numeric value now show the line number of the C<sort> operator, rather
-than the last line of the comparison routine. The warnings also occur now
-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.
+Some cases of threads crashing due to memory allocation during cloning have
+been fixed [perl #90006].
=item *
-C<Internals::SvREFCNT> now behaves consistently in 'get' and 'set' scenarios
-[perl #103222] and also treats the reference count as unsigned.
+Thread joining would sometimes emit "Attempt to free unreferenced scalar"
+warnings if C<caller> had been used from the C<DB> package prior to thread
+creation [perl #98092].
=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].
+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.
-=item *
+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.
-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 Tied variables
+
+=over
=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].
+Various cases in which FETCH was being ignored or called too many times
+have been fixed:
+
+=over
=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.
+C<PerlIO::get_layers> [perl #97956]
=item *
-Undefining C<%overload::> no longer causes a crash.
+C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> when $tied holds a
+reference.
=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].
+When calling C<local $_> [perl #105912]
=item *
-In case-insensitive regular expression pattern matching, no longer on
-UTF-8 encoded strings does the scan for the start of match only look at
-the first possible position. This caused matches such as
-C<"f\x{FB00}" =~ /ff/i> to fail.
+Four-argument C<select>
=item *
-On 64-bit systems, C<read()> now understands large string offsets beyond
-the 32-bit range.
+A tied buffer passed to C<sysread>
=item *
-Errors that occur when processing subroutine attributes no longer cause the
-subroutine's op tree to leak.
+C<< $tied .= <> >>
=item *
-C<sort> now works once more with custom sort routines that are XSUBs. It
-stopped working in 5.10.0.
+Three-argument C<open>, the third being a tied file handle
+(as in C<< open $fh, ">&", $tied >>)
=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.
+C<sort> with a reference to a tied glob for the comparison routine.
=item *
-Warnings produced when a custom sort routine returns a non-numeric value
-now contain "in sort"; e.g., "Use of uninitialized value in sort".
+C<..> and C<...> in list context [perl #53554].
=item *
-C<< sort { $a <=> $b } >>, which is optimised 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
-optimised [perl #94390].
+C<${$tied}>, C<@{$tied}>, C<%{$tied}> and C<*{$tied}> where the tied
+variable returns a string (C<&{}> was unaffected)
=item *
-C<..> and C<...> in list context now call FETCH only once on tied
-arguments, instead of three or four times [perl #53554].
+C<defined ${ $tied_variable }>
=item *
-C<..> and C<...> in list context now mention the name of the variable in
-"uninitialized" warnings for string (as opposed to numeric) ranges.
+Various functions that take a filehandle argument in rvalue context
+(C<close>, C<readline>, etc.) [perl #97482]
=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)
+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 *
-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.
+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 *
-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].
+Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied>
=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].
+C<chdir>, C<chmod>, C<chown>, C<utime>, C<truncate>, C<stat>, C<lstat> and
+the filetest ops (C<-r>, C<-x>, etc.)
-This bug fix was added in Perl 5.13.9, but caused problems with some CPAN
-modules that were relying on the bug. Since it was so close to Perl
-5.14.0, the fix was reverted in 5.13.10, to allow more time for the modules
-to adapt. Hopefully they will be fixed soon (see L</Known Problems>,
-below).
+=back
=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].
+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 *
-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].
+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 *
-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)
+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 *
-The C<study> function could become confused if fed a string longer than
-2**31 characters. Now that it's a no-op, it can't.
+Four-argument C<select> no longer produces its "Non-string passed as
+bitmask" warning on tied or tainted variables that are strings.
=item *
-C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
-inside a C<while> condition [perl #90888].
+Localising a tied scalar that returns a typeglob no longer stops it from
+being tied till the end of the scope.
=item *
-In @INC filters (subroutines returned by subroutines in @INC), $_ used to
-misbehave: If returned from a subroutine, it would not be copied, but the
-variable itself would be returned; and freeing $_ (e.g., with C<undef *_>)
-would cause perl to crash. This has been fixed [perl #91880].
+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 *
-An ASCII single quote (') in a symbol name is meant to be equivalent to a
-double colon (::) except at the end of the name. It was not equivalent if
-followed by a null character, but now it is [perl #88138].
+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 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().
+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 *
-Some cases of threads crashing due to memory allocation during cloning have
-been fixed [perl #90006].
+Assigning a vstring to a magic (e.g., tied, C<$!>) variable and then
+assigning something else used to blow away all the 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 *
-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].
+C<< version->new("version") >> and C<printf "%vd", "version"> no longer
+crash [perl #102586].
=item *
-Perl skips copying values returned from a subroutine if it thinks the value
-is not in use elsewhere. Due to faulty logic, this would happen with the
-result of C<delete>, C<shift> or C<splice>, even if the result was
-referenced elsewhere. So C<< \sub { delete $_[0] }->($x) >> would return a
-reference to C<$x>. This has been fixed [perl #91844].
+Version comparisons, such as those that happen implicitly with C<use
+v5.43>, no longer cause locale settings to change [perl #105784].
=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.
+Version objects no longer cause memory leaks in boolean context
+[perl #109762].
-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.
+=back
-L<attributes.pm|attributes> has likewise been updated to warn and not apply
-the attribute.
+=head2 Warnings, redefinition
+
+=over
=item *
-The remaining discrepancies between explicit and implicit return from
-lvalue subroutines have been resolved. They mainly involved which error
-message to display when a read-only value is returned in lvalue context.
-Also, returning a PADTMP (the result of most built-ins, like C<index>) in
-lvalue context is now forbidden for explicit return, as it always has been
-for implicit return. This is not a regression from 5.14, as all the cases
-in which it could happen where previously syntax errors.
+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 *
-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 very similar to nullary functions
-like C<time>.
+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<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].
+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 *
-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.
+Redefinition warnings for constant subroutines are on by default (what
+are known as severe warnings in L<perldiag>). This was only the case
+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 *
-Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
-element that is a glob copy no longer causes subsequent assignment to it to
-corrupt the glob, 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.
+The internal check to see whether a redefinition warning should occur
+used to emit "uninitialized" warnings in cases like this:
-=item *
+ use warnings "uninitialized";
+ use constant {u => undef, v => undef};
+ sub foo(){u}
+ sub foo(){v}
-C<when> blocks are now capable of returning variables declared inside the
-enclosing C<given> block [perl #93548].
+=back
+
+=head2 Warnings, "Uninitialized"
+
+=over
=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
-some cases of a C<return> inside an C<if> block which itself is followed by
-another C<return>.
+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 *
-Calling C<index> with a tainted constant no longer causes constants in
-subsequently compiled code to become tainted [perl #64804].
+C<dbmopen> now only warns once, rather than three times, if the mode
+argument is C<undef> [perl #90064].
=item *
-Use of lexical (C<my>) variables in code blocks embedded in regular
-expressions will no longer result in memory corruption or crashes.
+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].
-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 *
+
+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 *
-The C<SvIsCOW> C macro now returns false for read-only copies of typeglobs,
-such as those created by:
+C<..> and C<...> in list context now mention the name of the variable in
+"uninitialized" warnings for string (as opposed to numeric) ranges.
- $hash{elem} = *foo;
- Hash::Util::lock_value %hash, 'elem';
+=back
-It used to return true.
+=head2 Weak references
+
+=over
=item *
-Assignment to C<$^A> (the format output accumulator) now recalculates
-the number of lines output.
+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 *
-The regexp optimiser no longer crashes on debugging builds when merging
-fixed-string nodes with inconvenient contents.
+Weak references to lexical hashes going out of scope were not going stale
+(becoming undefined), but continued to point to the hash.
=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.
+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 *
-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.
+Creating a weak reference to an @ISA array or accessing the array index
+(C<$#ISA>) could result in confused internal bookkeeping for elements
+subsequently 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].
-=item *
+=back
+
+=head2 Other notable fixes
-Most dereferencing operators (C<${}>, etc.) used to call C<FETCH> twice on
-a tied operand when doing a symbolic dereference (looking up a variable by
-name, which is not permitted under C<use strict 'refs'>). Only C<&{}> did
-not have this problem. This has been fixed.
+=over
=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].
+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
+infamous 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 *
-stat() would always return the inode number as an IV, even when the
-original was unsigned, or too large to fit in an IV. stat() now
-returns the inode number as the type that would best preserve the
-original value. [perl #84590]
+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 *
-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].
+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 *
-Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
-working for the rest of the block.t
+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 *
-The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
-cause a panic error message when attempting to match at the end of the
-string [perl #96354].
+Unrecognised switches on C<#!> line
-=item *
+If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
+there, perl dies with "Can't emulate...".
-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 no 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.
+It used to produce the same message for switches that perl did not
+recognise at all, whether on the command line or the C<#!> line.
+
+Now it produces the "Unrecognized switch" error message [perl #104288].
=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].
+C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
+signal handler from stealing the exit status [perl #105700].
=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].
+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 *
-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].
+Perl skips copying values returned from a subroutine, for the sake of
+speed, if doing so would make no observable difference. Due to 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<defined(${"..."})>, C<defined(*{"..."})>, etc., used to
-return true for most, but not all built-in variables, if
-they had not been used yet. Many times that new built-in
-variables were added in past versions, this construct was
-not taken into account, so this 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].
+C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
=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.
+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 *
-Various functions that take a filehandle argument in rvalue context
-(C<close>, C<readline>, etc.) used to call C<FETCH> multiple times, if it
-was a tied variable, and warn twice, if it was C<undef> [perl #97482].
+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<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.
+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 *
-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.
+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 *
-C<defined ${ $tied_variable }> used to call C<FETCH> multiple times, but
-now calls it just once.
+The C<x> repetition operator no longer crashes on 64-bit builds with large
+repeat counts [perl #94560].
=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.
+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 *
-For a tied variable returning a package name, C<$tied-E<gt>method> used to
-call C<FETCH> multiple times (even up to six!), and sometimes would
-fail to call the method, due to memory corruption.
+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 *
-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].
+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 *
-Causing C<@DB::args> to be freed between uses of C<caller> no longer
-results in a crash [perl #93320].
+On 64-bit systems, C<read()> now understands large string offsets beyond
+the 32-bit range.
=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.
+Errors that occur when processing subroutine attributes no longer cause the
+subroutine's op tree to leak.
=item *
-It used to be possible to free the typeglob of a localised array or hash
-(e.g., C<local @{"x"}; delete $::{x}>), resulting in a crash on scope exit.
+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 *
-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)>.
+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 *
-Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied> now call FETCH
-only once.
+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].
=item *
-C<chdir>, C<chmod>, C<chown>, C<utime>, C<truncate>, C<stat>, C<lstat> and
-the filetest ops (C<-r>, C<-x>, etc.) now always call FETCH if passed a tied
-variable as the last argument. They used to ignore tiedness if the last
-thing return from or assigned to the variable was a typeglob or reference
-to a typeglob.
+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 *
-If things were arranged in memory the right way, it was possible for
-thread joining to emit "Attempt to free unreferenced scalar" warnings if
-C<caller> had been used from the C<DB> package prior to thread creation,
-due to the way pads were reference-counted and cloned [perl #98092].
+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 *
-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.
+C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
+inside a C<while> condition [perl #90888].
=item *
-C<given> was not scoping its implicit $_ properly, resulting in memory
-leaks or "Variable is not available" warnings [perl #94682].
+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
+some cases of a C<return> inside an C<if> block which itself is followed by
+another C<return>.
=item *
-C<-l> followed by a bareword no longer "eats" the previous argument to
-the list operator in whose argument list it resides. In less convoluted
-English: C<print "bar", -l foo> now actually prints "bar", because C<-l>
-on longer eats it.
+Calling C<index> with a tainted constant no longer causes constants in
+subsequently compiled code to become tainted [perl #64804].
=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>.
+Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
+working for the rest of the block.t
=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].
+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 *
-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.
+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 *
-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 enviroment
-variable [perl #98662].
+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].
=item *
-C<++> and C<--> now work on copies of globs, instead of dying.
+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 *
-Stacked C<-l> (followed immediately by other filetest operators) did not
-work previously; now it does. It is only permitted when the rightmost
-filetest op has the special "_" handle for its argument and the most
-recent C<stat>/C<lstat> call was an C<lstat>.
+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 *
-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
-behaviour has been restored.
+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 *
-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.
+Causing C<@DB::args> to be freed between uses of C<caller> no longer
+results in a crash [perl #93320].
=item *
-The C<SvPVutf8> C function no longer tries to modify its argument,
-resulting in errors [perl #108994].
+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<SvPVutf8> now works properly with magical variables.
+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<SvPVbyte> now works properly non-PVs.
+C<++> and C<--> now work on copies of globs, instead of dying.
=item *
-Version objects no longer cause memory leaks in boolean context
-[perl #109762].
+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 *
=item *
-C<< (?foo: ...) >> no longer loses passed in character set.
-
-=item *
-
C<< die; >> with a non-reference, non-string, or magical (e.g., tainted)
-value in $@ now properly
-propagates that value [perl #111654].
-
-=item *
-
-The trie optimisation 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 *
-
-The "glob failed" warning message is now suppressible via C<no warnings>
-[perl #111656].
+value in $@ now properly propagates that value [perl #111654].
=back
=item *
-We have a failing test in F<op/sigdispatch.t> on i386-netbsd 3.1
-
-=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
If F<make> is F<gmake>, F<Configure> completes, then we get errors related
to F</usr/include/stdbool.h>
-=back
+=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
-=head1 Obituary
+=back
-XXX If any significant core contributor has died, we've added a short obituary
-here.
+=back
=head1 Acknowledgements
https://perl5.git.perl.org / perl5.git / blobdiff