=encoding utf8
=head1 NAME
perl5160delta - what is new for perl v5.16.0
=head1 DESCRIPTION
This document describes differences between the 5.14.0 release and
the 5.16.0 release.
If you are upgrading from an earlier release such as 5.12.0, first read
L<perl5140delta>, which describes differences between 5.12.0 and
5.14.0.
=head1 Notice
XXX Any important notices here
=head1 Core Enhancements
=head2 C<use charnames> no longer needed for C<\N{I<name>}>
The C<charnames> module is now automatically loaded when needed as if
the C<:full> and C<:short> options had been specified. See
L<charnames>.
=head2 Improved performance for Unicode properties in regular expressions
Matching a code point against a Unicode property is now done via a
binary search instead of linear. This means for example that the worst
case for a 1000 item property is 10 probes instead of 1000. This
inefficiency has been compensated for in the past by permanently storing
in a hash the results of a given probe plus the results for the adjacent
64 code points, under the theory that near-by code points are likely to
be searched for. A separate hash was used for each mention of a Unicode
property in each regular expression. Thus, C<qr/\p{foo}abc\p{foo}/>
would generate two hashes. Any probes in one instance would be unknown
to the other, and the hashes could expand separately to be quite large
if the regular expression were used on many different widely-separated
code points. This can lead to running out of memory in extreme cases.
Now, however, there is just one hash shared by all instances of a given
property. This means that if C<\p{foo}> is matched against "A" in one
regular expression in a thread, the result will be known immediately to
all regular expressions, and the relentless march of using up memory is
slowed considerably.
=head2 C<is_utf8_char()>
The XS-callable function C<is_utf8_char()>, when presented with
malformed UTF-8 input, can read up to 12 bytes beyond the end of the
string. This cannot be fixed without changing its API. It is not
called from CPAN. The documentation now describes how to use it
safely.
=head2 Other C<is_utf8_foo()> functions, as well as C<utf8_to_foo()>, etc.
Most of the other XS-callable functions that take UTF-8 encoded input
implicitly assume that the UTF-8 is valid (not malformed) in regards to
buffer length. Do not do things such as change a character's case or
see if it is alphanumeric without first being sure that it is valid
UTF-8. This can be safely done for a whole string by using one of the
functions C<is_utf8_string()>, C<is_utf8_string_loc()>, and
C<is_utf8_string_loclen()>.
=head2 C<use I<VERSION>>
As of this release, version declarations like C<use v5.16> now disable
all features before enabling the new feature bundle. This means that
the following holds true:
use 5.016;
# 5.16 features enabled here
use 5.014;
# 5.16 features disabled here
C<use v5.12> and higher continue to enable strict, but explicit C<use
strict> and C<no strict> now override the version declaration, even
when they come first:
no strict;
use 5.012;
# no strict here
There is a new ":default" feature bundle that represents the set of
features enabled before any version declaration or C<use feature> has
been seen. Version declarations below 5.10 now enable the ":default"
feature set. This does not actually change the behaviour of C<use
v5.8>, because features added to the ":default" set are those that were
traditionally enabled by default, before they could be turned off.
C<$[> is now disabled under C<use v5.16>. It is part of the default
feature set and can be turned on or off explicitly with C<use feature
'array_base'>.
=head2 C<UNIVERSAL::VERSION>
The change to C<UNIVERSAL::VERSION> in 5.15.2 has been reverted. It
now returns a stringified version object once more.
=head2 C<substr> lvalue revamp
When C<substr> is called in lvalue or potential lvalue context with two
or three arguments, a special lvalue scalar is returned that modifies
the original string (the first argument) when assigned to.
Previously, the offsets (the second and third arguments) passed to
C<substr> would be converted immediately to match the string, negative
offsets being translated to positive and offsets beyond the end of the
string being truncated.
Now, the offsets are recorded without modification in the special
lvalue scalar that is returned, and the original string is not even
looked at by C<substr> itself, but only when the returned lvalue is
read or modified.
These changes result in several incompatible changes and bug fixes:
=over
=item *
If the original string changes length after the call to C<substr> but
before assignment to its return value, negative offsets will remember
their position from the end of the string, affecting code like this:
my $string = "string";
my $lvalue = \substr $string, -4, 2;
print $lvalue, "\n"; # prints "ri"
$string = "bailing twine";
print $lvalue, "\n"; # prints "wi"; used to print "il"
The same thing happens with an omitted third argument. The returned
lvalue will always extend to the end of the string, even if the string
becomes longer.
=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
change was deemed acceptable.
=head2 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].
=head2 Anonymous handles
Automatically generated file handles are now named __ANONIO__ when the
variable name cannot be determined, rather than $__ANONIO__.
=head2 Last-accessed filehandle
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.
It used to be possible to set this internal variable to a glob copy and
then modify that glob copy to be something other than a glob, and still
have the last-accessed filehandle associated with the variable after
assigning a glob to it again:
my $foo = *STDOUT; # $foo is a glob copy
<$foo>; # $foo is now the last-accessed handle
$foo = 3; # no longer a glob
$foo = *STDERR; # still the last-accessed handle
Now the C<$foo = 3> assignment unsets that internal variable, so there
is no last-accessed filehandle, just as if C<< <$foo> >> had never
happened.
=head2 C<__SUB__>
The new C<__SUB__> token, available under the "current_sub" feature
(see L<feature>) or C<use v5.15>, returns a reference to the current
subroutine, making it easier to write recursive closures.
=head2 New option for the debugger's B<t> command
The B<t> command in the debugger, which toggles tracing mode, now
accepts a numeric argument that determines how many levels of
subroutine calls to trace.
=head2 Return value of C<tied>
The value returned by C<tied> on a tied variable is now the actual
scalar that holds the object to which the variable is tied. This
allows ties to be weakened with C<Scalar::Util::weaken(tied
$tied_variable)>.
=head2 More consistent C<eval>
The C<eval> operator sometimes treats a string argument as a sequence of
characters and sometimes as a sequence of bytes, depending on the internal
encoding. The internal encoding is not supposed to make any difference,
but there is code that relies on this inconsistency.
Under C<use v5.15> and higher, the C<unicode_eval> and C<evalbytes>
features resolve this. The C<unicode_eval> feature causes C<eval $string>
to treat the string always as Unicode. The C<evalbytes> features provides
a function, itself called C<evalbytes>, which evaluates its argument always
as a string of bytes.
These features also fix oddities with source filters leaking to outer
dynamic scopes.
See L<feature> for more detail.
=head2 $^X converted to an absolute path on FreeBSD, OS X and Solaris
C<$^X> is now converted to an absolute path on OS X, FreeBSD (without
needing F</proc> mounted) and Solaris 10 and 11. This augments the
previous approach of using F</proc> on Linux, FreeBSD and NetBSD
(in all cases, where mounted).
This makes relocatable perl installations more useful on these platforms.
(See "Relocatable @INC" in F<INSTALL>)
=head2 Unicode Symbol Names
Perl now has proper support for Unicode in symbol names. It used to be
that C<*{$foo}> would ignore the internal UTF8 flag and use the bytes of
the underlying representation to look up the symbol. That meant that
C<*{"\x{100}"}> and C<*{"\xc4\x80"}> would return the same thing. All
these parts of Perl have been fixed to account for Unicode:
=over
=item *
Method names (including those passed to C<use overload>)
=item *
Typeglob names (including names of variables, subroutines and filehandles)
=item *
Package names
=item *
Constant subroutine names (not null-clean yet)
=item *
C<goto>
=item *
Symbolic dereferencing
=item *
Second argument to C<bless()> and C<tie()>
=item *
Return value of C<ref()>
=item *
Package names returned by C<caller()>
=item *
Subroutine prototypes
=item *
Attributes
=item *
Various warnings and error messages that mention variable names or values,
methods, etc.
=back
In addition, a parsing bug has been fixed that prevented C<*{é}> from
implicitly quoting the name, but instead interpreted it as C<*{+é}>, which
would cause a strict violation.
C<*{"*a::b"}> automatically strips off the * if it is followed by an ASCII
letter. That has been extended to all Unicode identifier characters.
C<$é> is now subject to "Used only once" warnings. It used to be exempt,
as it was treated as a punctuation variable.
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.
=head2 Support for Embedded Nulls
Some parts of Perl did not work correctly with nulls (C<chr 0>) embedded in
strings. That meant that, for instance, C<< $m = "a\0b"; foo->$m >> would
call the "a" method, instead of the actual method name contained in $m.
These parts of perl have been fixed to support nulls:
=over
=item *
Method names
=item *
Typeglob names (including filehandle names)
=item *
Package names
=item *
Autoloading
=item *
Return value of C<ref()>
=item *
Package names returned by C<caller()>
=item *
Filehandle warnings
=item *
Typeglob elements (C<*foo{"THING\0stuff"}>)
=item *
Signal names
=item *
Various warnings and error messages that mention variable names or values,
methods, etc.
=back
One side effect of these changes is that blessing into "\0" no longer
causes C<ref()> to return false.
=head2 Autoloaded sort Subroutines
Custom sort subroutines can now be autoloaded [perl #30661]:
sub AUTOLOAD { ... }
@sorted = sort foo @list; # uses AUTOLOAD
=head2 Improved typemaps for Some Builtin Types
Most XS authors will be aware that there is a longstanding bug
in the OUTPUT typemap for T_AVREF (C<AV*>), T_HVREF (C<HV*>),
T_CVREF (C<CV*>), and T_SVREF (C<SVREF> or C<\$foo>) that requires
manually decrementing the reference count of the return value
instead of the typemap taking care of this. For
backwards-compatibility, this cannot be changed in the default
typemaps. But we now provide additional typemaps
C<T_AVREF_REFCOUNT_FIXED>, etc. that do not exhibit this bug.
Using them in your extension is as simple as having one line
in your C<TYPEMAP> section:
HV* T_HVREF_REFCOUNT_FIXED
=head1 Performance Enhancements
=over 4
=item *
Version declarations with the C<use> keyword (e.g., C<use 5.012>) are now
faster, as they enable features without loading F<feature.pm>.
=item *
C<local $_> is faster now, as it no longer iterates through magic that it
is not going to copy anyway.
=item *
Perl 5.12.0 sped up the destruction of objects whose classes define
empty C<DESTROY> methods (to prevent autoloading), by simply not
calling such empty methods. This release takes this optimisation a
step further, by not calling any C<DESTROY> method that begins with a
C<return> statement. This can be useful for destructors that are only
used for debugging:
use constant DEBUG => 1;
sub DESTROY { return unless DEBUG; ... }
Constant-folding will reduce the first statement to C<return;> if DEBUG
is set to 0, triggering this optimisation.
=item *
Assigning to a variable that holds a typeglob or copy-on-write scalar
is now much faster. Previously the typeglob would be stringified or
the copy-on-write scalar would be copied before being clobbered.
=item *
Assignment to C<substr> in void context is now more than twice its
previous speed. Instead of creating and returning a special lvalue
scalar that is then assigned to, C<substr> modifies the original string
itself.
=item *
C<substr> no longer calculates a value to return when called in void
context.
=back
=head2 C<CORE::> works on all keywords
The C<CORE::> prefix can now be used on keywords enabled by
L<feature.pm|feature>, even outside the scope of C<use feature>. Relevant
documentation files L<CORE>, L<feature>, L<perlfunc>, L<perlsub>, and
L<perlsyn> have been updated.
Perl 5.15.2 introduced subroutines in the CORE namespace. Most of them
could only be called as barewords; i.e., they could be aliased at compile
time and then inlined under new names.
Almost all of these functions can now be called through references and via
C<&foo()> syntax, bypassing the prototype. See L<CORE> for a list of the
exceptions.
=head2 C<continue> no longer requires the "switch" feature
The C<continue> keyword has two meanings. It can introduce a C<continue>
block after a loop, or it can exit the current C<when> block. Up till now,
the latter meaning was only valid with the "switch" feature enabled, and
was a syntax error otherwise. Since the main purpose of feature.pm is to
avoid conflicts with user-defined subroutines, there is no reason for
C<continue> to depend on it.
=head2 New debugger commands
The debugger now has C<disable> and C<enable> commands for disabling
existing breakpoints and reënabling them. See L<perldebug>.
=head2 C<$$> can be assigned to
C<$$> was made read-only in Perl 5.8.0. But only sometimes: C<local $$>
would make it writable again. Some CPAN modules were using C<local $$> or
XS code to bypass the read-only check, so there is no reason to keep C<$$>
read-only. (This change also allowed a bug to be fixed while maintaining
backward compatibility.)
=head2 Features inside the debugger
The current Perl's feature bundle is now enabled for commands entered in
the interactive debugger.
=head2 C<\N{...}> can now have Unicode loose name matching
This is described in the C<charnames> item in
L</Updated Modules and Pragmata> below.
=head2 Breakpoints with file names
The debugger's "b" command for setting breakpoints now allows a line number
to be prefixed with a file name. See
L<perldebug/"b [file]:[line] [condition]">.
=head2 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.
=head2 The C<\$> prototype accepts any scalar lvalue
The C<\$> and C<\[$]> subroutine prototypes now accept any scalar lvalue
argument. Previously they only accepted scalars beginning with C<$> and
hash and array elements. This change makes them consistent with the way
the built-in C<read> and C<recv> functions (among others) parse their
arguments. This means that one can override the built-in functions with
custom subroutines that parse their arguments the same way.
=head2 You can now C<study> more than one string
The restriction that you can only have one C<study> active at a time has been
removed. You can now usefully C<study> as many strings as you want (until you
exhaust memory).
=head2 The Unicode C<Script_Extensions> property is now supported.
New in Unicode 6.0, this is an improved C<Script> property. Details
are in L<perlunicode/Scripts>.
=head2 DTrace probes for interpreter phase change
The C<phase-change> probes will fire when the interpreter's phase
changes, which tracks the C<${^GLOBAL_PHASE}> variable. C<arg0> is
the new phase name; C<arg1> is the old one. This is useful mostly
for limiting your instrumentation to one or more of: compile time,
run time, destruct time.
=head2 New Pad API
Many new functions have been added to the API for manipulating lexical
pads. See L<perlapi/Pad Data Structures> for more information.
=head2 Subroutines in the CORE namespace
Many Perl keywords are now available as subroutines in the CORE namespace.
Most of these cannot be called through references or via C<&foo> syntax
yet, but must be called as barewords. In other words, you can now do
this:
BEGIN { *entangle = \&CORE::tie }
entangle $variable, $package, @args;
This currently works for overridable keywords other than C<dump> and the
infix operators. Calling through references only works for functions that
take no arguments (like C<wantarray>).
Work is under way to allow more of these subroutines to be called through
references.
=head2 C<__FILE__()> Syntax
The C<__FILE__>, C<__LINE__> and C<__PACKAGE__> tokens can now be written
with an empty pair of parentheses after them. This makes them parse the
same way as C<time>, C<fork> and other built-in functions.
=head1 Security
=head2 Privileges are now set correctly when assigning to C<$(>
A hypothetical bug (probably non-exploitable in practice) due to the
incorrect setting of the effective group ID while setting C<$(> has been
fixed. The bug would only have affected systems that have C<setresgid()>
but not C<setregid()>, but no such systems are known of.
=head2 C<File::Glob::bsd_glob()> memory error with GLOB_ALTDIRFUNC (CVE-2011-2728).
Calling C<File::Glob::bsd_glob> with the unsupported flag
GLOB_ALTDIRFUNC would cause an access violation / segfault. A Perl
program that accepts a flags value from an external source could expose
itself to denial of service or arbitrary code execution attacks. There
are no known exploits in the wild. The problem has been corrected by
explicitly disabling all unsupported flags and setting unused function
pointers to null. Bug reported by Clément Lecigne.
=head1 Incompatible Changes
=head2 Certain deprecated Unicode properties are no longer supported by default
Perl should never have exposed certain Unicode properties that are used
by Unicode internally and not meant to be publicly available. Use of
these has generated deprecated warning messages since Perl 5.12. The
removed properties are Other_Alphabetic,
Other_Default_Ignorable_Code_Point, Other_Grapheme_Extend,
Other_ID_Continue, Other_ID_Start, Other_Lowercase, Other_Math, and
Other_Uppercase.
Perl may be recompiled to include any or all of them; instructions are
given in
L<perluniprops/Unicode character properties that are NOT accepted by Perl>.
=head2 Dereferencing IO thingies as typeglobs
The C<*{...}> operator, when passed a reference to an IO thingy (as in
C<*{*STDIN{IO}}>), creates a new typeglob containing just that IO object.
Previously, it would stringify as an empty string, but some operators would
treat it as undefined, producing an "uninitialized" warning.
Having a typeglob appear as an empty string is a side effect of the
implementation that has caused various bugs over the years.
The solution was to make it stringify like a normal anonymous typeglob,
like those produced by C<< open($foo->{bar}, ...) >> [perl #96326].
=head2 User-defined case changing operations.
This feature was deprecated in Perl 5.14, and has now been removed.
The CPAN module L<Unicode::Casing> provides better functionality without
the drawbacks that this feature had, as are detailed in the 5.14
documentation:
L<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
=head2 XSUBs are now 'static'
XSUB C functions are now 'static', that is, they are not visible from
outside the compilation unit. Users can use the new C<XS_EXTERNAL(name)>
and C<XS_INTERNAL(name)> macros to pick the desired linking behaviour.
The ordinary C<XS(name)> declaration for XSUBs will continue to declare
non-'static' XSUBs for compatibility, but the XS compiler,
C<ExtUtils::ParseXS> (C<xsubpp>) will emit 'static' XSUBs by default.
C<ExtUtils::ParseXS>'s behaviour can be reconfigured from XS using the
C<EXPORT_XSUB_SYMBOLS> keyword, see L<perlxs> for details.
=head2 Borland compiler
All support for the Borland compiler has been dropped. The code had not
worked for a long time anyway.
=head2 Weakening read-only references
Weakening read-only references is no longer permitted. It should never
hove worked anyway, and in some cases could result in crashes.
=head2 Tying scalars that hold typeglobs
Attempting to tie a scalar after a typeglob was assigned to it would
instead tie the handle in the typeglob's IO slot. This meant that it was
impossible to tie the scalar itself. Similar problems affected C<tied> and
C<untie>: C<tied $scalar> would return false on a tied scalar if the last
thing returned was a typeglob, and C<untie $scalar> on such a tied scalar
would do nothing.
We fixed this problem before Perl 5.14.0, but it caused problems with some
CPAN modules, so we put in a deprecation cycle instead.
Now the deprecation has been removed and this bug has been fixed. So
C<tie $scalar> will always tie the scalar, not the handle it holds. To tie
the handle, use C<tie *$scalar> (with an explicit asterisk). The same
applies to C<tied *$scalar> and C<untie *$scalar>.
=head2 IPC::Open3 no longer provides C<xfork()>, C<xclose_on_exec()>
and C<xpipe_anon()>
All three functions were private, undocumented and unexported. They do
not appear to be used by any code on CPAN. Two have been inlined and one
deleted entirely.
=head2 C<$$> no longer caches PID
Previously, if one embeds Perl or uses XS and calls fork(3) from C, Perls
notion of C<$$> could go out of sync with what getpid() returns. By always
fetching the value of C<$$> via getpid(), this potential bug is eliminated.
Code that depends on the caching behavior will break. As described in
L</Core Enhancements>, C<$$> is now writable, but it will be reset during a
fork.
=head1 Deprecations
=head2 Don't read the Unicode data base files in F<lib/unicore>
It is now deprecated to directly read the Unicode data base files.
These are stored in the F<lib/unicore> directory. Instead, you should
use the new functions in L<Unicode::UCD>. These provide a stable API,
and give complete information. (This API is, however, subject to change
somewhat during the 5.15 development cycle, as we gain experience and
get feedback from using it.)
Perl may at some point in the future change or remove the files. The
file most likely for applications to have used is F<lib/unicore/ToDigit.pl>.
L<Unicode::UCD/prop_invmap()> can be used to get at its data instead.
=head1 Future Deprecations
This section serves as a notice of feature that are I<likely> to be
L<deprecated|perlpolicy/deprecated> in the next release of perl (5.18.0). If
your code depends on these features, you should contact the Perl 5 Porters via
the L<mailing list|http://lists.perl.org/list/perl5-porters.html> or L<perlbug>
to explain your use case and inform the deprecation process.
=head2 Core Modules
These modules may be marked as deprecated I<from the core>. This only means
that they will no longer be installed by default with the core distribution,
but will remain available on the CPAN.
=over
=item CPANPLUS
=item Filter::Simple
=item PerlIO::mmap
=item Pod::Parser, Pod::LaTeX
=item SelfLoader
=item Text::Soundex
=item Thread.pm
=back
=item Platforms with no supporting programmers:
=over
=item BeOS
=item djgpp
=item dgux
=item EPOC
=item MPE/iX
=item Rhapsody
=item UTS
=item VM/ESA
=back
=head2 Other Future Deprecations
=over
=item Swapping of $< and $>
https://rt.perl.org/rt3/Ticket/Display.html?id=96212
=item sfio, stdio
=back
=head1 Performance Enhancements
=over 4
=item *
Due to changes in L<File::Glob>, Perl's C<glob> function and its
C<< <...> >> equivalent are now much faster. The splitting of the pattern
into words has been rewritten in C, resulting in speed-ups of 20% in some
cases.
This does not affect VMS, as it does not use File::Glob.
=item *
The short-circuiting operators C<&&>, C<||>, and C<//>, when chained
(such as C<$a || $b || $c>), are now considerably faster to short-circuit,
due to reduced optree traversal.
=item *
The implementation of C<s///r> makes one fewer copy of the scalar's value.
=item *
If a studied scalar is C<split> with a regex, the engine will now take
advantage of the C<study> data.
=item *
C<study> now uses considerably less memory for shorter strings. Strings shorter
than 65535 characters use roughly half the memory than previously, strings
shorter than 255 characters use roughly one quarter of the memory.
=item *
Recursive calls to lvalue subroutines in lvalue scalar context use less
memory.
=back
=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,
which is a drop-in replacement. It will be deleted from perl.git blead
in v5.17.0.
=back
=head2 New Modules and Pragmata
=over 4
=item *
L<arybase> -- this new module implements the C<$[> variable.
=back
=head2 Updated Modules and Pragmata
=over 4
=item *
L<XXX> has been upgraded from version 0.69 to version 0.70.
=back
=head2 Removed Modules and Pragmata
As promised in Perl 5.14.0's release notes, the following modules have
been removed from the core distribution, and if needed should be installed
from CPAN instead.
=over
=item *
C<Devel::DProf> has been removed from the Perl core. Prior version was 20110228.00.
=item *
C<Shell> has been removed from the Perl core. Prior version was 0.72_01.
=back
=head1 Documentation
=head2 New Documentation
=head3 L<perlootut>
This a new OO tutorial. It focuses on basic OO concepts, and then recommends
that readers choose an OO framework from CPAN.
=head3 L<perldtrace>
L<perldtrace> describes Perl's DTrace support, listing the provided probes
and gives examples of their use.
=head3 L<perlexperiment>
This document is intended to provide a list of experimental features in
Perl. It is still a work in progress.
=head2 Changes to Existing Documentation
=head3 L<perlfunc>
=over 4
=item *
C<dbmopen> treats a 0 mode as a special case, that prevents a nonexistent
file from being created. This has been the case since Perl 5.000, but was
never documented anywhere. Now the perlfunc entry mentions it
[perl #90064].
=item *
The entry for C<split> has been rewritten. It is now far clearer than
before.
=back
=head3 L<perlop> and L<perlsyn>
=over 4
=item *
Documentation of the smartmatch operator has been reworked and moved from
perlsyn to perlop where it belongs.
=item *
Documentation of the ellipsis statement (C<...>) has been reworked and
moved from perlop to perlsyn.
=back
=head3 L<perlsec/Laundering and Detecting Tainted Data>
=over 4
=item *
The example function for checking for taintedness contained a subtle
error. C<$@> needs to be localized to prevent its changing this
global's value outside the function. The preferred method to check for
this remains L<Scalar::Util/tainted>.
=back
=head3 L<perlfunc>, L<open>
=over 4
=item *
As an accident of history, C<open $fh, "<:", ...> applies the default
layers for the platform (C<:raw> on Unix, C<:crlf> on Windows), ignoring
whatever is declared by L<open.pm|open>. This seems such a useful feature
it has been documented in L<perlfunc|perlfunc/open> and L<open>.
=back
=head3 L<perlapi>
=over 4
=item *
The HV API has long accepted negative lengths to indicate that the key is
in UTF8. Now this is documented.
=item *
The C<boolSV()> macro is now documented.
=back
=head3 L<perlguts>
=over 4
=item *
A new section, L<Autoloading with XSUBs|perlguts/Autoloading with XSUBs>,
has been added, which explains the two APIs for accessing the name of the
autoloaded sub.
=back
=head3 L<perlobj>
=over 4
=item *
This document has been rewritten from scratch, and its coverage of various OO
concepts has been expanded.
=back
=head3 L<perlpragma>
=over 4
=item *
There is now a standard convention for naming keys in the C<%^H>,
documented under L<Key naming|perlpragma/Key naming>.
=back
=head3 L<perlguts>
=over
=item *
Some of the function descriptions in L<perlguts> were confusing, as it was
not clear whether they referred to the function above or below the
description. This has been clarified [perl #91790].
=back
=head3 L<perllol>
=over
=item *
L<perllol> has been expanded with examples using the new C<push $scalar>
syntax introduced in Perl 5.14.0 (5.14.1).
=back
=head3 L<perlmod>
=over
=item *
L<perlmod> now states explicitly that some types of explicit symbol table
manipulation are not supported. This codifies what was effectively already
the case [perl #78074].
=back
=head3 L<perlop>
=over 4
=item *
The explanation of bitwise operators has been expanded to explain how they
work on Unicode strings (5.14.1).
=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 *
The C<<< <<\FOO >>> here-doc syntax has been documented (5.14.1).
=back
=head3 L<perlpodstyle>
=over 4
=item *
The tips on which formatting codes to use have been corrected and greatly
expanded.
=item *
There are now a couple of example one-liners for previewing POD files after
they have been edited.
=back
=head3 L<perlsub>
=over
=item *
The L<perlsub/"Lvalue subroutines"> section has been amended to reflect
changes and bug fixes introduced in Perl 5.15.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.
=back
=head3 L<perlre>
=over
=item *
The C<(*COMMIT)> directive is now listed in the right section
(L<Verbs without an argument|perlre/Verbs without an argument>).
=back
=head3 L<perlrun>
=over
=item *
L<perlrun> has undergone a significant clean-up. Most notably, the
B<-0x...> form of the B<-0> flag has been clarified, and the final section
on environment variables has been corrected and expanded (5.14.1).
=back
=head3 L<perltie>
=over
=item *
Documented the required syntax for tying handles.
=back
=head3 L<perlvar>
=over
=item *
The documentation for L<$!|perlvar/$!> has been corrected and clarified.
It used to state that $! could be C<undef>, which is not the case. It was
also unclear as to whether system calls set C's C<errno> or Perl's C<$!>
[perl #91614].
=item *
Documentation for L<$$|perlvar/$$> has been amended with additional
cautions regarding changing the process ID.
=back
=over 4
=item *
L<perlxs> was extended with documentation on inline typemaps.
=item *
L<perlref> has a new L<Circular References|perlref/Circular References>
section explaining how circularities may not be freed and how to solve that
with weak references.
=item *
The documentation for smart match in L<perlsyn> has been corrected for the
case of C<undef> on the left-hand side. The list of different smart match
behaviours had an item in the wrong place.
=item *
Parts of L<perlapi> were clarified, and Perl equivalents of some C
functions have been added as an additional mode of exposition.
=item *
A few parts of L<perlre> and L<perlrecharclass> were clarified.
=back
=head2 Removed Documentation
=head3 Old OO Documentation
All the old OO tutorials, perltoot, perltooc, and perlboot, have been
removed. The perlbot (bag of object tricks) document has been removed as well.
=head3 Development Deltas
The old perldelta files for development cycles prior to 5.15 have been
removed.
=head1 Diagnostics
The following additions or changes have been made to diagnostic output,
including warnings and fatal error messages. For the complete list of
diagnostic messages, see L<perldiag>.
XXX New or changed warnings emitted by the core's C<C> code go here. Also
include any changes in L<perldiag> that reconcile it to the C<C> code.
[ Within each section, list entries as a =item entry that links to perldiag,
e.g.
=item *
L<Invalid version object|perldiag/"Invalid version object">
]
=head2 New Diagnostics
XXX Newly added diagnostic messages go here
=head3 New Errors
=over 4
=item *
L<Cannot set tied @DB::args|perldiag/"Cannot set tied @DB::args">
This error occurs when C<caller> tries to set C<@DB::args> but finds it
tied. Before this error was added, it used to crash instead.
=item *
L<Cannot tie unreifiable array|perldiag/"Cannot tie unreifiable array">
This error is part of a safety check that the C<tie> operator does before
tying a special array like C<@_>. You should never see this message.
=item *
L<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<That use of $[ is unsupported|perldiag/"That use of $[ is unsupported">
This previously removed error has been restored with the re-implementation
of C<$[> as a module.
=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
with C<&foo> syntax or through a reference. The subroutines
in this package cannot yet be called that way, but must be
called as barewords. Something like this will work:
BEGIN { *shove = \&CORE::push; }
shove @array, 1,2,3; # pushes on to @array
=back
=head3 New Warnings
=over 4
=item *
L<defined(@array) is deprecated|perldiag/"defined(@array) is deprecated">
The long-deprecated C<defined(@array)> now also warns for package variables.
Previously it only issued a warning for lexical variables.
=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">
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<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
Assigning to a temporary returned from an XS lvalue subroutine now produces a
warning [perl #31946].
=item *
L<length() used on %s|perldiag/length() used on %s>
This new warning occurs when C<length> is used on an array or hash, instead
of C<scalar(@array)> or C<scalar(keys %hash)>.
=item *
L<$[ 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.
=item *
L<Use of assignment to $[ is deprecated|perldiag/"Use of assignment to $[ is deprecated">
This previously removed warning has been restored with the re-implementation
of C<$[> as a module.
=back
=head2 Removed Warnings
=over
=item *
"sort is now a reserved word"
This error used to occur when C<sort> was called without arguments, followed by C<;> or C<)>. (E.g., C<sort;> would die, but C<{sort}> was
OK.) This error message was added in Perl 3 to catch code like
C<close(sort)> which would no longer work. More than two decades later,
this message is no longer appropriate. Now C<sort> without arguments is
always allowed, and returns an empty list, as it did in those cases where
it was already allowed [perl #90030].
=back
=head2 Changes to Existing Diagnostics
=over 4
=item *
Redefinition warnings for constant subroutines used to be mandatory,
even occurring under C<no warnings>. Now they respect the L<warnings>
pragma.
=item *
The "Attempt to free non-existent shared string" has had the spelling
of "non-existent" corrected to "nonexistent". It was already listed
with the correct spelling in L<perldiag>.
=item *
The '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 topicalizer' and 'Can't "when" outside a topicalizer'. They both
used to be 'Can't use when() outside a topicalizer' [perl #91514].
=item *
The uninitialized warning for C<y///r> when C<$_> is implicit and undefined
now mentions the variable name, just like the non-/r variation of the
operator.
=item *
The "Applying pattern match..." or similar warning produced when an array
or hash is on the left-hand side of the C<=~> operator now mentions the
name of the variable.
=item *
The L<Invalid version format|perldiag/"Invalid version format (%s)">
error message now says "negative version number" within the parentheses,
rather than "non-numeric data", for negative numbers.
=item *
The two warnings
L<Possible attempt to put comments in qw() list|perldiag/"Possible attempt to put comments in qw() list">
and
L<Possible attempt to separate words with commas|perldiag/"Possible attempt to separate words with commas">
are no longer mutually exclusive: the same C<qw> construct may produce
both.
=item *
The 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"
=item *
Warnings that mention the names of lexical (C<my>) variables with Unicode
characters in them now respect the presence or absence of the C<:utf8>
layer on the output handle, instead of outputting UTF8 regardless. Also,
the correct names are included in the strings passed to C<$SIG{__WARN__}>
handlers, rather than the raw UTF8 bytes.
=back
=over 4
=item *
XXX Describe change here
=back
=head1 Utility Changes
=head3 L<zipdetails>
=over 4
=item *
L<zipdetails> displays information about the internal record structure
of the zip file. It is not concerned with displaying any details of
the compressed data stored in the zip file.
=back
=head3 L<h2ph>
=over 4
=item *
L<h2ph> used to generate code of the form
unless(defined(&FOO)) {
sub FOO () {42;}
}
But the subroutine is a compile-time declaration, and is hence unaffected
by the condition. It has now been corrected to emit a string C<eval>
around the subroutine [perl #99368].
=back
=head3 L<splain>
=over 4
=item *
splain no longer emits backtraces with the first line number repeated.
This:
Uncaught exception from user code:
Cannot fwiddle the fwuddle at -e line 1.
at -e line 1
main::baz() called at -e line 1
main::bar() called at -e line 1
main::foo() called at -e line 1
has become this:
Uncaught exception from user code:
Cannot fwiddle the fwuddle at -e line 1.
main::baz() called at -e line 1
main::bar() called at -e line 1
main::foo() called at -e line 1
=item *
Some error messages consist of multiple lines that are listed as separate
entries in L<perldiag>. splain has been taught to find the separate
entries in these cases, instead of simply failing to find the message.
=back
=head1 Configuration and Compilation
=over 4
=item *
The -Dusesitecustomize and -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 *
C<USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}> have been added the output of perl -V
as they have affect the behaviour of the interpreter binary (albeit only
in a small area).
=item *
The code and tests for L<IPC::Open2> have been moved from F<ext/IPC-Open2>
into F<ext/IPC-Open3>, as C<IPC::Open2::open2()> is implemented as a thin
wrapper around C<IPC::Open3::_open3()>, and hence is very tightly coupled to
it.
=item *
The magic types and magic vtables are now generated from data in a new script
F<regen/mg_vtable.pl>, instead of being maintained by hand. As different EBCDIC
variants can't agree on the code point for '~', the character to code point
conversion is done at build time by F<generate_uudmap> to a new generated header
F<mg_data.h>. C<PL_vtbl_bm> and C<PL_vtbl_fm> are now defined by the
pre-processor as C<PL_vtbl_regexp>, instead of being distinct C variables.
C<PL_vtbl_sig> has been removed.
=item *
Building with C<-DPERL_GLOBAL_STRUCT> works again. This configuration is not
generally used.
=item *
Perl configured with I<MAD> now correctly frees C<MADPROP> structures when
OPs are freed. C<MADPROP>s are now allocated with C<PerlMemShared_malloc()>
=back
=head1 Testing
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.
[ List each test improvement as a =item entry ]
=over 4
=item *
XXX
=back
=head1 Platform Support
XXX Any changes to platform support should be listed in the sections below.
[ Within the sections, list each platform as a =item entry with specific
changes as paragraphs below it. ]
=head2 New Platforms
XXX List any platforms that this version of perl compiles on, that previous
versions did not. These will either be enabled by new files in the F<hints/>
directories, or new subdirectories and F<README> files at the top level of the
source tree.
=over 4
=item XXX-some-platform
XXX
=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
=head2 Platform-Specific Notes
=head3 VMS
=over 4
=item *
Remove unnecessary includes, fix miscellaneous compiler warnings and
close some unclosed comments on F<vms/vms.c>.
Remove sockadapt layer from the VMS build.
=item *
A link-time error on VMS versions without C<symlink> support was
introduced in 5.15.1, but has now been corrected.
=item *
Explicit support for VMS versions prior to v7.0 and DEC C versions
prior to v6.0 has been removed.
=item *
Since Perl 5.10.1, the home-grown C<stat> wrapper has been unable to
distinguish between a directory name containing an underscore and an
otherwise-identical filename containing a dot in the same position
(e.g., t/test_pl as a directory and t/test.pl as a file). This problem
has been corrected.
=back
=head3 GNU/Hurd
Numerous build and test failures on GNU/Hurd have been resolved with hints
for building DBM modules, detection of the library search path, and enabling
of large file support.
=head3 OpenVOS
Perl is now built with dynamic linking on OpenVOS, the minimum supported
version of which is now Release 17.1.0.
=head3 SunOS
The CC workshop C++ compiler is now detected and used on systems that ship
without cc.
=head1 Internal Changes
=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 C<HINT_FEATURE_MASK> macro is defined in F<perl.h> along with other
hints. Other macros for setting and testing features and bundles are in
the new F<feature.h>. C<FEATURE_IS_ENABLED> (which has moved to
F<feature.h>) is no longer used throughout the codebase, but more specific
macros, e.g., C<FEATURE_SAY_IS_ENABLED>, that are defined in F<feature.h>.
=item *
F<lib/feature.pm> is now a generated file, created by the new
F<regen/feature.pl> script, which also generates F<feature.h>.
=item *
Tied arrays are now always C<AvREAL>. If C<@_> or C<DB::args> is tied, it
is reified first, to make sure this is always the case.
=item *
The C<is_gv_magical_sv> function has been eliminated and merged with
C<gv_fetchpvn_flags>. It used to be called to determine whether a GV
should be autovivified in rvalue context. Now it has been replaced with a
new C<GV_ADDMG> flag (not part of the API).
=item *
Padlists are now marked C<AvREAL>; i.e., reference-counted. They have
always been reference-counted, but were not marked real, because F<pad.c>
did its own clean-up, instead of using the usual clean-up code in F<sv.c>.
That caused problems in thread cloning, so now the C<AvREAL> flag is on,
but is turned off in F<pad.c> right before the padlist is freed (after
F<pad.c> has done its custom freeing of the pads).
=item *
All the C files that make up the Perl core have been converted to UTF-8.
=back
=head1 Selected Bug Fixes
=head2 Regular expressions and character classes
=over 4
=item *
The new (in 5.14.0) regular expression modifier C</a> when repeated like
C</aa> forbids the characters outside the ASCII range that match
characters inside that range from matching under C</i>. This did not
work under some circumstances, all involving alternation, such as:
"\N{KELVIN SIGN}" =~ /k|foo/iaa;
succeeded inappropriately. This is now fixed.
=item *
5.14.0 introduced some memory leaks in regular expression character
classes such as C<[\w\s]>, which have now been fixed (5.14.1)
=item *
An edge case in regular expression matching could potentially loop.
This happened only under C</i> in bracketed character classes that have
characters with multi-character folds, and the target string to match
against includes the first portion of the fold, followed by another
character that has a multi-character fold that begins with the remaining
portion of the fold, plus some more.
"s\N{U+DF}" =~ /[\x{DF}foo]/i
is one such case. C<\xDF> folds to C<"ss">. (5.14.1)
=item *
A few characters in regular expression pattern matches did not
match correctly in some circumstances, all involving C</i>. The
affected characters are:
COMBINING GREEK YPOGEGRAMMENI,
GREEK CAPITAL LETTER IOTA,
GREEK CAPITAL LETTER UPSILON,
GREEK PROSGEGRAMMENI,
GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA,
GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
LATIN SMALL LETTER LONG S,
LATIN SMALL LIGATURE LONG S T,
and
LATIN SMALL LIGATURE ST.
=item *
Fixed memory leak regression in regular expression compilation
under threading
=back
=head2 Formats
=over
=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].
=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].
=back
=head2 Copy-on-write scalars
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.
=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].
=item *
Lvalue subroutines were not allowing COW scalars to be returned. This was
fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0, but list context
was not fixed until this release.
=item *
Elements of restricted hashes (see the L<fields> pragma) containing
copy-on-write values couldn't be deleted, nor could such hashes be cleared
(C<%hash = ()>).
=item *
Localising a tied variable used to make it read-only if it contained a
copy-on-write string.
=item *
L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
See L</Updated Modules and Pragmata>, above.
=back
=head2 lvalue subroutines
There have been various fixes to lvalue subroutines.
=over
=item *
Explicit return now returns the actual argument passed to return, instead
of copying it [perl #72724] [perl #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.
=item *
Lvalue subroutines used to enforce lvalue syntax (i.e., whatever can go on
the left-hand side of C<=>) for the last statement and the arguments to
return. Since lvalue subroutines are not always called in lvalue context,
this restriction has been lifted.
=item *
Lvalue subroutines are less restrictive 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 *
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 *
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 *
Autovivification now works on values returned from lvalue subroutines
[perl #7946].
=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].
=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.
=item *
Assignment to C<keys> returned from an lvalue sub used not to work, but now
it does.
=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.
=back
=head2 Fixes related to hashes
=over
=item *
A bug has been fixed that would cause a "Use of freed value in iteration"
error if the next two hash elements that would be iterated over are
deleted [perl #85026]. (5.14.1)
=item *
Freeing deeply nested hashes no longer crashes [perl #44225].
=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].
=back
=head2 Other notable fixes
=over
=item * "b . COND" in the debugger has been fixed
Breaking on the current line with C<b . COND> was broken by previous work and
has now been fixed.
=item * Tying C<%^H>
Tying C<%^H> no longer causes perl to crash or ignore
the contents of C<%^H> when entering a compilation
scope [perl #106282].
=item * C<~> on vstrings
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 * Vstrings blowing away magic
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 * C<newHVhv> and tied hashes
The C<newHVhv> XS function now works on tied hashes, instead of crashing or
returning an empty hash.
=item * Hashes will null elements
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 * No warning for C<open(foo::bar)>
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<select> and package aliasing
After package aliasing (C<*foo:: = *bar::>), C<select> with 0 or 1 argument
would sometimes return a name that could not be used to refer to the
filehandle, or sometimes it would return C<undef> even when a filehandle
was selected. Now it returns a typeglob reference in such cases.
=item * C<PerlIO::get_layers> and tied variables
C<PerlIO::get_layers> no longer ignores FETCH on tied variables as it used
to most of the time [perl #97956].
=item * C<PerlIO::get_layers> and numbers
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 * Lvalue subs and strict mode
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 * Non-lvalue sub calls in potentially lvalue context
Sub calls whose subs are not visible at compile time, if
they occurred in the last statement of an lvalue subroutine,
would reject non-lvalue subroutines and die with "Can't modify non-lvalue
subroutine call" [perl #102486].
Non-lvalue sub calls whose subs I<are> visible at compile time exhibited
the opposite bug. If the call occurred in the last statement of an lvalue
subroutine, there would be no error when the lvalue sub was called in
lvalue context. Perl would blindly assign to the temporary value returned
by the non-lvalue subroutine.
=item * AUTOLOADing lvalue subs
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 * C<caller> and tied C<@DB::args>
C<caller> sets C<@DB::args> to the subroutine arguments when called from
the DB package. It used to crash when doing so if C<@DB::args> happened to
be tied. Now it croaks instead.
=item * Tying C<@_>
Under debugging builds, this code:
sub TIEARRAY{bless[]}
sub {
tie @_, "";
\@_;
}->(1);
use to produce an "av_reify called on tied array" warning. It doesn't any
more.
=item * Unrecognised switches on C<#!> line
If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
there, perl dies with "Can't emulate...".
It used to produce the same message for switches that perl did not
recognise at all, whether on the command line or the C<#!> line.
Now it produces the "Unrecognized switch" error message [perl #104288].
=item * C<system> and SIGCHLD
C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
signal handler from stealing the exit status [perl #105700].
=item * Deleting methods via C<delete>
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.
=item * Hash element deletion and destructors
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 * C<(s)printf>'s %n formatting code
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.
It also works now with special lvalue functions like C<substr> and with
nonexistent hash and array elements [perl #3471, #103492].
=item * Typeglobs and threads
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 * 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].
=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].
=item * C<{@a = sort}> no longer crashes
This particular piece of code (C<sort> with no arguments assigned to an
array, inside a block with no C<;>) started crashing in an earlier 5.15.x
release. It has been fixed.
=item * C<utf8::decode> and read-only scalars
C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
=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].
=item * Freeing an aggregate during list assignment
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 * Confused internal bookkeeping with @ISA arrays
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 * DELETE on scalar ties
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 * Freeing $_ inside C<grep> or C<map>
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].
=item * Warnings with C<+=>
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 * Tying and autovivification
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 * C<@&> and C<$&>
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 * Stacked filetests
C<-T> and C<-B> now work when stacked up with other filetest operators
[perl #77388].
=item * Filetests and stat buffers
Perl keeps several internal variables to keep track of the last stat
buffer, from which file(handle) it originated, what type it was, and
whether the last stat succeeded.
There were various cases where these could get out of synch, resulting in
inconsistent or erratic behaviour in edge cases (every mention of C<-T>
applies to C<-B> as well):
=over
=item *
C<-T I<HANDLE>>, even though it does a C<stat>, was not resetting the last
stat type, so an C<lstat _> following it would merrily return the wrong
results. Also, it was not setting the success status.
=item *
Freeing the handle last used by C<stat> or a filetest could result in
S<C<-T _>> using an unrelated handle.
=item *
C<stat> with an IO reference (as returned by C<*STDIO{IO}>, for instance)
would not reset the stat type.
=item *
C<stat> with an IO reference was not recording the filehandle for
S<C<-T _>> to use.
=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.
=item *
Fatal warnings would stop C<-T> from setting C<$!>.
=item *
When the last stat was on an unreadable file, C<-T _> is supposed to
return C<undef>, leaving the last stat buffer unchanged. But it was
setting the stat type, causing C<lstat _> to stop working.
=item *
C<-T I<FILENAME>> was not resetting the internal stat buffers for
unreadable files.
=back
These have all been fixed.
=item * C<defined *{"!"}>
An earlier 5.15.x release caused this construct to stop the C<%!> hash
from working. Likewise C<defined *{"+"}> and C<defined *{"-"}> caused
C<%+> and C<%->, respectively, to stop working. This has been 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.
=item * C<stat I<HANDLE>> and fstat failures
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.
=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.
=item * Crashes with warnings
Two warning messages that mention variable names started crashing in
5.15.5, but have been fixed [perl #106726, #107656].
=item * Bitwise assignment operators and copy-on-write
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 * Three problematic Unicode characters now work better in regex pattern matching under C</i>
In the past, three Unicode characters:
LATIN SMALL LETTER SHARP S,
GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
and
GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
along with the sequences that they fold to
(including "ss" in the case of LATIN SMALL LETTER SHARP S),
did not properly match under C</i>. 5.14.0 fixed some of these cases,
but introduced others, including a panic when one of the characters or
sequences was used in the C<(?(DEFINE)> regular expression predicate.
The known bugs that were introduced in 5.14 have now been fixed; as well
as some other edge cases that have never worked until now. All these
involve using the characters and sequences outside bracketed character
classes under C</i>. This closes [perl #98546].
There remain known problems when using certain characters with
multi-character folds inside bracketed character classes, including such
constructs as C<qr/[\N{LATIN SMALL LETTER SHARP}a-z]/i>. These
remaining bugs are addressed in [perl #89774].
=item *
RT #78266: The regex engine has been leaking memory when accessing
named captures that weren't matched as part of a regex ever since 5.10
when they were introduced, e.g. this would consume over a hundred MB of
memory:
for (1..10_000_000) {
if ("foo" =~ /(foo|(?<capture>bar))?/) {
my $capture = $+{capture}
}
}
system "ps -o rss $$"'
=item *
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 *
Redefinition warnings triggered by the creation of XSUBs now respect
Unicode glob names, instead of using the internal representation. This
was missed in 5.15.4, partly because this warning was so hard to
trigger. (See the previous item.)
=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.
=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}
=item *
A bug fix in Perl 5.14 introduced a new bug, causing "uninitialized"
warnings to report the wrong variable if the operator in question had
two operands and one was C<%{...}> or C<@{...}>. This has been fixed
[perl #103766].
=item *
C<< version->new("version") >> and C<printf "%vd", "version"> no longer
crash [perl #102586].
=item *
C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> now call FETCH
just once when $tied holds a reference.
=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.
=item *
Four-argument C<select> no longer produces its "Non-string passed as
bitmask" warning on tied or tainted variables that are strings.
=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.
=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.
=item *
The C<evalbytes> keyword added in 5.15.5 was respecting C<use utf8>
declarations from the outer scope, when it should have been ignoring
them.
=item *
C<goto &func> no longer crashes, but produces an error message, when
the unwinding of the current subroutine's scope fires a destructor that
undefines the subroutine being "goneto" [perl #99850].
=item *
Arithmetic assignment (C<$left += $right>) involving overloaded objects
that rely on the 'nomethod' override no longer segfault when the left
operand is not overloaded.
=item *
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.
=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.
=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.
=item *
Doing a substitution on a tied variable returning a copy-on-write
scalar used to cause an assertion failure or an "Attempt to free
nonexistent shared string" warning.
=item *
A change in perl 5.15.4 caused C<caller()> to produce malloc errors and
a crash with Perl's own malloc, and possibly with other malloc
implementations, too [perl #104034].
=item *
A bug fix in 5.15.5 could sometimes result in assertion failures under
debugging builds of perl for certain syntax errors in C<eval>, such as
C<eval q|""!=!~//|>
=item *
The "c [line num]" debugger command was broken by other debugger
changes released in 5.15.3. This is now fixed.
=item *
Breakpoints were not properly restored after a debugger restart using
the "R" command. This was broken in 5.15.3. This is now fixed.
=item *
The debugger prompt did not display the current line. This was broken
in 5.15.3. This is now fixed.
=item *
Class method calls still suffered from the Unicode bug with Latin-1
package names. This was missed in the Unicode package name cleanup in
5.15.4 [perl #105922].
=item *
The debugger no longer tries to do C<local $_> when dumping data
structures.
=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 *
A regression in 5.14 caused these statements not to set the internal
variable that holds the handle used by C<$.>:
my $fh = *STDOUT;
tell $fh;
eof $fh;
seek $fh, 0,0;
tell *$fh;
eof *$fh;
seek *$fh, 0,0;
readline *$fh;
This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
is not clear how to fix it [perl #106536].
=item *
Version comparisons, such as those that happen implicitly with C<use
v5.43>, no longer cause locale settings to change [perl #105784].
=item *
F<pod/buildtoc>, which generates L<perltoc>, put path names in the
L<perltoc> file. This bug was introduced in 5.15.1.
=item *
Perl now holds an extra reference count on the package that code is
currently compiling in. This means that the following code no longer crashes [perl #101486]:
package Foo;
BEGIN {*Foo:: = *Bar::}
sub foo;
=item *
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].
=item *
The C<x> repetition operator no longer crashes on 64-bit builds with large
repeat counts [perl #94560].
=item *
A fix to C<glob> under miniperl (used to configure modules when perl itself
is built) in Perl 5.15.3 stopped C<< <~> >> from returning the home
directory, because it cleared %ENV before calling csh. Now C<$ENV{HOME}>
is preserved. This fix probably does not affect anything. If
L<File::Glob> fails to load for some reason, Perl reverts to using csh.
So it would apply in that case.
=item *
On OSes other than VMS, Perl's C<glob> operator (and the C<< <...> >> form)
use L<File::Glob> underneath. L<File::Glob> splits the pattern into words,
before feeding each word to its C<bsd_glob> function.
There were several inconsistencies in the way the split was done. Now
quotation marks (' and ") are always treated as shell-style word delimiters
(that allow whitespace as part of a word) and backslashes are always
preserved, unless they exist to escape quotation marks. Before, those
would only sometimes be the case, depending on whether the pattern
contained whitespace. Also, escaped whitespace at the end of the pattern
is no longer stripped [perl #40470].
=item *
C<CORE::glob> now works as a way to call the default globbing function. It
used to respect overrides, despite the C<CORE::> prefix.
=item *
In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
opposite case. This has been fixed [perl #101970].
=item *
A regular expression match with an overloaded object on the right-hand side
would in some cases stringify the object too many times.
=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].
=item *
A regression has been fixed that was introduced in 5.14, in C</i>
regular expression matching, in which a match improperly fails if the
pattern is in UTF-8, the target string is not, and a Latin-1 character
precedes a character in the string that should match the pattern. [perl
#101710]
=item *
C<@{"..."} = reverse ...> started crashing in 5.15.3. This has been fixed.
=item *
C<ref> in a tainted expression started producing an "sv_upgrade" error in
5.15.4. This has been fixed.
=item *
Weak references to lexical hashes going out of scope were not going stale
(becoming undefined), but continued to point to the hash.
=item *
Weak references to lexical variables going out of scope are now broken
before any magical methods (e.g., DESTROY on a tie object) are called.
This prevents such methods from modifying the variable that will be seen
the next time the scope is entered.
=item *
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.
=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.
=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].
=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.
=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].
=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].
=item *
Localising a tied scalar that returns a typeglob no longer stops it from
being tied till the end of the scope.
=item *
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).
=item *
C<sort> no longer ignores FETCH when passed a reference to a tied glob for
the comparison routine.
=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.
=item *
C<Internals::SvREFCNT> now behaves consistently in 'get' and 'set' scenarios
[perl #103222] and also treats the reference count as unsigned.
=item *
Calling C<require> on an implicit C<$_> when C<*CORE::GLOBAL::require> has
been overridden does not segfault anymore, and C<$_> is now passed to the
overriding subroutine [perl #78260].
=item *
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].
=item *
Perl 5.15.0 introduced a minor regression, in that an object referenced by
a deleted hash element would be able to access the freed element from its
DESTROY method, causing panic errors [perl #99660].
=item *
Functions in the CORE package can now be called as methods. That used to
work only when they had been called or referenced already. So
C<< "foo"->CORE::ucfirst >> returns Foo.
=item *
C<use> and C<require> are no longer affected by the I/O layers active in
the caller's scope (enabled by L<open.pm|open>) [perl #96008].
=item *
Errors that occur when methods cannot be found during overloading now
mention the correct package name, as they did in 5.8.x, instead of
erroneously mentioning the "overload" package, as they have since 5.10.0.
=item *
Undefining C<%overload::> no longer causes a crash.
=item *
C<our $::é; $é> (which is invalid) no longer produces the "Compilation
error at lib/utf8_heavy.pl..." error message, which it started emitting in
5.10.0 [perl #99984].
=item *
A minor regression, introduced Perl 5.15.0, has been fixed in which some
regular expression Unicode property matches (C<\p{...}>) matched
non-Unicode code points.
=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.
=item *
On 64-bit systems, C<read()> now understands large string offsets beyond
the 32-bit range.
=item *
Errors that occur when processing subroutine attributes no longer cause the
subroutine's op tree to leak.
=item *
C<sort> now works once more with custom sort routines that are XSUBs. It
stopped working in 5.10.0.
=item *
C<sort> with a constant for a custom sort routine, although it produces
unsorted results, no longer crashes. It started crashing in 5.10.0.
=item *
Warnings produced when a custom sort routine returns a non-numeric value
now contain "in sort"; e.g., "Use of uninitialized value in sort".
=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].
=item *
C<..> and C<...> in list context now call FETCH only once on tied
arguments, instead of three or four times [perl #53554].
=item *
C<..> and C<...> in list context now mention the name of the variable in
"uninitialized" warnings for string (as opposed to numeric) ranges.
=item *
Passing the same constant subroutine to both C<index> and C<formline> no
longer causes one or the other to fail [perl #89218]. (5.14.1)
=item *
List assignment to lexical variables declared with attributes in the same
statement (C<my ($x,@y) : blimp = (72,94)>) stopped working in Perl 5.8.0.
It has now been fixed.
=item *
Perl 5.10.0 introduced some faulty logic that made "U*" in the middle of
a pack template equivalent to "U0" if the input string was empty. This has
been fixed [perl #90160].
=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].
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).
=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 *
The "R" command for restarting a debugger session has been fixed to work on
Windows, or any other system lacking a C<POSIX::_SC_OPEN_MAX> constant
[perl #87740].
=item *
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 *
The C<study> function could become confused if fed a string longer than
2**31 characters. Now it simply skips such strings.
=item *
C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
inside a C<while> condition [perl #90888].
=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].
=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].
=item *
The abbreviations for four C1 control characters
C<MW>
C<PM>,
C<RI>,
and
C<ST>
were previously unrecognized by C<\N{}>,
vianame(), and string_vianame().
=item *
Some cases of threads crashing due to memory allocation during cloning have
been fixed [perl #90006].
=item *
Attempting to C<goto> out of a tied handle method used to cause memory
corruption or crashes. Now it produces an error message instead
[perl #8611].
=item *
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].
=item *
Applying the :lvalue attribute to subroutine that is already defined does
not work properly, as the attribute changes the way the sub is compiled.
Hence, Perl 5.12 began warning when an attempt is made to apply the
attribute to an already defined sub. In such cases, the attribute is
discarded.
But the change in 5.12 missed the case where custom attributes are also
present: that case still silently and ineffectively applied the attribute.
That omission has now been corrected. C<sub foo :lvalue :Whatever> (when
C<foo> is already defined) now warns about the :lvalue attribute, and does
not apply it.
L<attributes.pm|attributes> has likewise been updated to warn and not apply
the attribute.
=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.
=item *
Explicitly returning a tied C<my> variable from an lvalue subroutine in
list lvalue context used to clear the variable before the assignment could
happen. This is something that was missed when explicit return was made to
work in 5.15.0.
=item *
A minor memory leak, introduced in 5.15.0, has been fixed. It would occur
when a hash is freed that has had its current iterator deleted
[perl #93454].
=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>.
=item *
C<prototype> now returns C<undef> for all overridable infix operators,
such as C<eq>, which are not callable in any way resembling functions.
It used to return incorrect prototypes for some and die for others
[perl #94984].
=item *
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.
=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.
=item *
C<when> blocks are now capable of returning variables declared inside the
enclosing C<given> block [perl #93548].
=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>.
=item *
Calling C<index> with a tainted constant no longer causes constants in
subsequently compiled code to become tainted [perl #64804].
=item *
Use of lexical (C<my>) variables in code blocks embedded in regular
expressions will no longer result in memory corruption or crashes.
Nevertheless, these code blocks are still experimental, as there are still
problems with the wrong variables being closed over (in loops for instance)
and with abnormal exiting (e.g., C<die>) causing memory corruption.
=item *
The C<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 *
Assignment to C<$^A> (the format output accumulator) now recalculates
the number of lines output.
=item *
The regexp optimiser no longer crashes on debugging builds when merging
fixed-string nodes with inconvenient contents.
=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.
=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.
=item *
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.
=item *
A minor regression introduced in 5.15.0 has been fixed. Dereferencing a
magical mortal (e.g., the return value of C<delete> on a tied hash element)
explicitly returned from a subroutine called recursively was not calling
C<FETCH>. This would affect code like C<@{ foo() }> where the C<foo> sub
contains C<return delete $hash{elem}> and is calling itself.
=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].
=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]
=item *
The combination of the regular expression modifiers C</aa> and the C<\b>
and C<\B> escape sequences did not work properly on UTF-8 encoded
strings. All non-ASCII characters under C</aa> should be treated as
non-word characters, but what was happening was that Unicode rules were
used to determine wordness/non-wordness for non-ASCII characters. This
is now fixed [perl #95968].
=item *
Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
working for the rest of the block.t
=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].
=item *
For list assignments like C<($a,$b) = ($b,$a)>, Perl has to make a copy of
the items on the right-hand side before assignment them to the left. For
efficiency's sake, it assigns the values on the right straight to the items
on the left 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.
=item *
Perl no longer tries to apply lvalue context to the string in
C<("string", $variable) ||= 1> (which used to be an error). Since the
left-hand side of C<||=> is evaluated in scalar context, that's a scalar
comma operator, which gives all but the last item void context. There is
no such thing as void lvalue context, so it was a mistake for Perl to try
to force it [perl #96942].
=item *
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].
=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].
=item *
In Perl 5.15.0 C<defined(${'$'})> stopped returning true if the C<$$>
variable had not been used yet. This has been fixed.
=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<${"::!"}>) and for subroutines in the
CORE package [perl #97978] [perl #97492] [perl #97484].
=item *
Perl 5.10.0 introduced a similar bug: C<defined(*{"foo"})> where "foo"
represents the name of a built-in global variable used to return false if
the variable had never been used before, but only on the I<first> call.
This, too, has been fixed.
=item *
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].
=item *
C<close> and similar filehandle functions, when called on built-in global
variables (like C<$+>), used to die if the variable happened to hold the
undefined value, instead of producing the usual "Use of uninitialized
value" warning.
=item *
When autovivified file handles were introduced in Perl 5.6.0, C<readline>
was inadvertently made to autovivify when called as C<readline($foo)> (but
not as C<E<lt>$fooE<gt>>). It has now been fixed never to autovivify.
=item *
C<defined ${ $tied_variable }> used to call C<FETCH> multiple times, but
now calls it just once.
=item *
Some cases of dereferencing a complex expression, such as
C<${ (), $tied } = 1>, used to call C<FETCH> multiple times, but now call
it once.
=item *
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.
=item *
Calling an undefined anonymous subroutine (e.g., what $x holds after
C<undef &{$x = sub{}}>) used to cause a "Not a CODE reference" error, which
has been corrected to "Undefined subroutine called" [perl #71154].
=item *
Causing C<@DB::args> to be freed between uses of C<caller> no longer
results in a crash [perl #93320].
=item *
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.
=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.
=item *
C<setpgrp($foo)> used to be equivalent to C<($foo, setpgrp)>, because
C<setpgrp> was ignoring its argument if there was just one. Now it is
equivalent to C<setpgrp($foo,0)>.
=item *
Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied> now call FETCH
only once.
=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.
=item *
Perl 5.15.1 inadvertently stopped C<*foo =~ s/\*//r> from working, as it
would try to force the *foo glob into a string. This has been fixed
[perl #97954].
=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].
=item *
CORE:: subs were introduced in the previous development release, but
C<defined &{"CORE::..."}> did not return true. That has been rectified
[perl #97484].
=item *
Lvalue subroutines were made to autovivify in 5.15.0, but it did not work
in some cases involving an intervening list operator between the
dereference operator and the subroutine call (C<${(), lvsub()}>)
[perl #98184].
=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.
=item *
C<given> was not scoping its implicit $_ properly, resulting in memory
leaks or "Variable is not available" warnings [perl #94682].
=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.
=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<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 *
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 *
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 *
C<++> and C<--> now work on copies of globs, instead of dying.
=item *
The subroutines in the CORE:: namespace that were introduced in the
previous development release run with the lexical hints (strict, warnings)
of the caller, just as though the built-in function had been called. But
this was not the case for C<goto &CORE::sub>. The CORE sub would end up
running with the lexical hints of the subroutine it replaced, instead of
that subroutine's caller. This has been fixed.
=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>.
=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.
=back
=head1 Known Problems
=over 4
=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
assignment in the F<Makefile>. That happens when F<./Configure> tries to
make depends. F<Configure> then exits 0, but further F<make>-ing fails.
If F<make> is F<gmake>, F<Configure> completes, then we get errors related
to F</usr/include/stdbool.h>
=back
=head1 Obituary
XXX If any significant core contributor has died, we've added a short obituary
here.
=head1 Acknowledgements
XXX Generate this with:
perl Porting/acknowledgements.pl v5.15.8..HEAD
=head1 Reporting Bugs
If you find what you think is a bug, you might check the articles
recently posted to the comp.lang.perl.misc newsgroup and the perl
bug database at http://rt.perl.org/perlbug/ . There may also be
information at http://www.perl.org/ , the Perl Home Page.
If you believe you have an unreported bug, please run the L<perlbug>
program included with your release. Be sure to trim your bug down
to a tiny but sufficient test case. Your bug report, along with the
output of C<perl -V>, will be sent off to perlbug@perl.org to be
analysed by the Perl porting team.
If the bug you are reporting has security implications, which make it
inappropriate to send to a publicly archived mailing list, then please send
it to perl5-security-report@perl.org. This points to a closed subscription
unarchived mailing list, which includes
all the core committers, who will be able
to help assess the impact of issues, figure out a resolution, and help
co-ordinate the release of patches to mitigate or fix the problem across all
platforms on which Perl is supported. Please only use this address for
security issues in the Perl core, not for modules independently
distributed on CPAN.
=head1 SEE ALSO
The F<Changes> file for an explanation of how to view exhaustive details
on what changed.
The F<INSTALL> file for how to build Perl.
The F<README> file for general stuff.
The F<Artistic> and F<Copying> files for copyright information.
=cut