=head1 Notice
-XXX Any important notices here
+As described in L<perlpolicy>, the release of Perl 5.14.0 marks the
+official end of support for Perl 5.10. Users of Perl 5.10 or earlier
+should consider upgrading to a more recent release of Perl.
=head1 Core Enhancements
phones. This conflicts with the long-standing Perl usage of having
C<BELL> mean the ASCII C<BEL> character, U+0007. In Perl 5.14,
C<\N{BELL}> will continue to mean U+0007, but its use will generate a
-deprecated warning message, unless such warnings are turned off. The
-new name for U+0007 in Perl
will be C<ALERT>, which corresponds nicely
-with the existing shorthand sequence for it, C<"\a">. C<\N{BEL}> will
-mean U+0007, with no warning given. The character at U+1F514 will not
-have a name in 5.14, but can be referred to by C<\N{U+1F514}>. The plan
-is that in Perl 5.16, C<\N{BELL}> will refer to U+1F514, and so all code
-that uses C<\N{BELL}> should convert by then to using C<\N{ALERT}>,
-C<\N{BEL}>, or C<"\a"> instead.
+deprecation warning message, unless such warnings are turned off. The
+new name for U+0007 in Perl
is C<ALERT>, which corresponds nicely
+with the existing shorthand sequence for it, C<"\a">. C<\N{BEL}>
+means U+0007, with no warning given. The character at U+1F514 will not
+have a name in 5.14, but can be referred to by C<\N{U+1F514}>.
+In Perl 5.16, C<\N{BELL}> will refer to U+1F514; all code
+that uses C<\N{BELL}> should be converted to use C<\N{ALERT}>,
+C<\N{BEL}>, or C<"\a"> before upgrading.
=head3 Full functionality for C<use feature 'unicode_strings'>
This release provides full functionality for C<use feature
'unicode_strings'>. Under its scope, all string operations executed and
regular expressions compiled (even if executed outside its scope) have
-Unicode semantics. See L<feature>.
+Unicode semantics. See L<feature/"the 'unicode_strings' feature">.
This feature avoids most forms of the "Unicode Bug" (See
L<perlunicode/The "Unicode Bug"> for details.) If there is a
=item *
C<\N{}>, C<charnames::vianame>, C<charnames::viacode> now know about every
-character in Unicode. Previously, they didn't know about the Hangul syllables
+character in Unicode. In earlier releases of Perl, they didn't know about the Hangul syllables
nor a number of CJK (Chinese/Japanese/Korean) characters.
=item *
-In the past, it was ineffective to override one of Perl's abbreviations
-with your own custom alias. Now it works.
+It is now possible to override Perl's abbreviations with your own custom aliases.
=item *
-You can also create a custom alias of the ordinal of a
+You can now create a custom alias of the ordinal of a
character, known by C<\N{...}>, C<charnames::vianame()>, and
-C<charnames::viacode()>. Previously, an alias had to be to an official
-Unicode character name. This made it impossible to create an alias for
-a code point that had no name, such as those reserved for private
+C<charnames::viacode()>. Previously, aliases had to be to official
+Unicode character names. This made it impossible to create an alias for
+unnamed code points, such as those reserved for private
use.
=item *
-A new function, C<charnames::string_vianame()>, has been added.
-This function is a run-time version of C<\N{...}>, returning the string
+The new function C<charnames::string_vianame()>
+is a run-time version of C<\N{...}>, returning the string
of characters whose Unicode name is its parameter. It can handle
Unicode named character sequences, whereas the pre-existing
C<charnames::vianame()> cannot, as the latter returns a single code
will generate a warning. Attempting to input these using strict rules
(such as with the C<:encoding('UTF-8')> layer) will continue to fail.
Prior to this release the handling was very inconsistent, and incorrect
-in places. Also, the Unicode non-characters, some of which previously were
-erroneously considered illegal in places by Perl, contrary to the Unicode
-standard, are now always legal internally. But inputting or outputting
-them will work the same as for the non-legal Unicode code points, as the
-Unicode standard says they are illegal for "open interchange".
+in places.
+
+Unicode non-characters, some of which previously were erroneously
+considered illegal in places by Perl, contrary to the Unicode standard,
+are now always legal internally. Inputting or outputting them will
+work the same as for the non-legal Unicode code points, as the Unicode
+standard says they are illegal for "open interchange".
=head3 Unicode database files not installed
The Unicode database files are no longer installed with Perl. This
doesn't affect any functionality in Perl and saves significant disk
-space. If you previously were explicitly opening and reading those
-files, you can download them from
+space. If you need these files, you can download them from
L<http://www.unicode.org/Public/zipped/6.0.0/>.
=head2 Regular Expressions
-=head3 C<(?^...)> construct to signify default modifiers
+=head3 C<(?^...)> construct signifies default modifiers
-An ASCII caret (also called a "circumflex accent") C<"^">
-immediately following a C<"(?"> in a regular expression
-now means that the subexpression does not inherit the
-surrounding modifiers such as C</i>, but reverts to the
-Perl defaults. Any modifiers following the caret override the defaults.
+An ASCII caret C<"^"> immediately following a C<"(?"> in a regular
+expression now means that the subexpression does not inherit surrounding
+modifiers such as C</i>, but reverts to the Perl defaults. Any modifiers
+following the caret override the defaults.
-The stringification of regular expressions now uses this
-notation. E.g., before, C<qr/hlagh/i> would be stringified as
-C<(?i-xsm:hlagh)>, but now it's stringified as C<(?^i:hlagh)>.
+Stringification of regular expressions now uses this notation. E.g.,
+before, C<qr/hlagh/i> would be stringified as C<(?i-xsm:hlagh)>, but
+now it's stringified as C<(?^i:hlagh)>.
The main purpose of this is to allow tests that rely on the
stringification not to have to change when new modifiers are added.
See L<perlre/Extended Patterns>.
+This change is likely to break code which compares stringified regular
+expressions with fixed strings containing C<?-xism>.
+
+
=head3 C</d>, C</l>, C</u>, C</a>, and C</aa> modifiers
Four new regular expression modifiers have been added. These are mutually
affected. Otherwise, C</a> behaves like the C</u> modifier, in that
case-insensitive matching uses Unicode semantics.
-The C</aa> modifier is like C</a>, except that, in case-insensitive matching, no ASCII character will match a
-non-ASCII character. For example,
+The C</aa> modifier is like C</a>, except that, in case-insensitive
+matching, no ASCII character will match a non-ASCII character.
+For example,
'k' =~ /\N{KELVIN SIGN}/ai
-will match; it won't under C</aa>.
+will match.
+
+ 'k' =~ /\N{KELVIN SIGN}/aai
+
+will not match.
See L<perlre/Modifiers> for more detail.
=head3 Array and hash container functions accept references
All built-in functions that operate directly on array or hash
-containers now also accept hard references to arrays or hashes:
+containers now also accept unblessed hard references to arrays
+or hashes:
|----------------------------+---------------------------|
| Traditional syntax | Terse syntax |
underlying reftype. Warnings are issued about assumptions made in
ambiguous cases.
+XXX TODO - fix this once the code is fixed
+
=head3 Single term prototype
The C<+> prototype is a special alternative to C<$> that will act like
Several changes have been made to the way C<die>, C<warn>, and C<$@>
behave, in order to make them more reliable and consistent.
+=over
+
+=item *
+
When an exception is thrown inside an C<eval>, the exception is no
longer at risk of being clobbered by code running during unwinding
(e.g., destructors). Previously, the exception was written into C<$@>
In addition to object destructors, this also affects any function call
performed by XS code using the C<G_KEEPERR> flag.
+=item *
+
Warnings for C<warn> can now be objects, in the same way as exceptions
for C<die>. If an object-based warning gets the default handling,
of writing to standard error, it is stringified as
object-based warning as an object, where previously it was passed the
result of stringifying the object.
+=back
+
=head2 Other Enhancements
=head3 Assignment to C<$0> sets the legacy process name with C<prctl()> on Linux
-On Linux the legacy process name
will be set with L<prctl(2)>, in
+On Linux the legacy process name
is now set with C<prctl(2)>, in
addition to altering the POSIX name via C<argv[0]> as perl has done
-since version 4.000. Now system utilities that read the legacy process
+since version 4.000. Now system utilities that read the legacy process
name such as ps, top and killall will recognize the name you set when
-assigning to C<$0>. The string you supply will be cut off at 16 bytes,
+assigning to C<$0>. The string you supply will be cut off at 16 bytes;
this is a limitation imposed by Linux.
=head3 C<srand()> now returns the seed
This allows programs that need to have repeatable results not to have to come
up with their own seed-generating mechanism. Instead, they can use C<srand()>
-and stash the return value for future use. Typical is a test program which
+and stash the return value for future use. One example is a test program which
has too many combinations to test comprehensively in the time available to it
each run. It can test a random subset each time and, should there be a failure,
log the seed used for that run so that it can later be used to reproduce the
open my $fh, ">", $file;
$fh->autoflush(1); # IO::File not loaded
-=head3 IPv6 support
+=head3 Improved IPv6 support
The C<Socket> module provides new affordances for IPv6,
including implementations of the C<Socket::getaddrinfo()> and
=head2 User-defined regular expression properties
-In L<perlunicode/"User-Defined Character Properties">, it says you can
+L<perlunicode/"User-Defined Character Properties"> documented that you can
create custom properties by defining subroutines whose names begin with
-"In" or "Is". However, Perl did not actually enforce that naming
-restriction, so \p{foo::bar} could call foo::bar() if it existed. Now this
-convention has been enforced.
+"In" or "Is". However, Perl did not actually enforce that naming
+restriction, so \p{foo::bar} could call foo::bar() if it existed. The documented
+convention is now enforced.
-Also, Perl no longer allows a tainted regular expression to invoke a
-user-defined. It simply dies instead [perl #82616].
+Also, Perl no longer allows tainted regular expressions to invoke a
+user-defined property. It simply dies instead [perl #82616].
=head1 Incompatible Changes
=head3 \400-\777
-Use of C<\400>-C<\777> in regexes in certain circumstances has given
-different, anomalous behavior than their use in all other
-double-quote-like contexts. Since 5.10.1, a deprecated warning message
-has been raised when this happens. Now, all double-quote-like contexts
-have the same behavior, namely to be equivalent to C<\x{100}> -
-C<\x{1FF}>, with no deprecation warning. Use of these values in the
-command line option C<"-0"> retains the current meaning to slurp input
-files whole; previously, this was documented only for C<"-0777">. It is
-recommended, however, because of various ambiguities, to use the new
-C<\o{...}> construct to represent characters in octal.
+In certain circumstances, C<\400>-C<\777> in regexes have behaved
+differently than they behave in all other double-quote-like contexts.
+Since 5.10.1, Perl has issued a deprecation warning when this happens.
+Now, these literals behave the same in all double-quote-like contexts,
+namely to be equivalent to C<\x{100}> - C<\x{1FF}>, with no deprecation
+warning.
+
+Use of C<\400>-C<\777> in the command line option C<"-0"> retain their
+conventional meaning. They slurp whole input files; previously, this
+was documented only for C<"-0777">.
+
+Because of various ambiguities, you should use the new
+C<\o{...}> construct to represent characters in octal instead.
=head3 Most C<\p{}> properties are now immune to case-insensitive matching
For most Unicode properties, it doesn't make sense to have them match
-differently under C</i> case-insensitive matching than not. And doing
-so leads to unexpected results and potential security holes. For
-example
+differently under C</i> case-insensitive matching. Doing so can lead
+to unexpected results and potential security holes. For example
m/\p{ASCII_Hex_Digit}+/i
the exact same code points, namely those matched by C<m/\p{Cased}/i>.
Details are in L<perlrecharclass/Unicode Properties>.
-User-defined property handlers that need to match differently under
-C</i> must change to read the new boolean parameter passed to them which is
-non-zero if case-insensitive matching is in effect or 0 otherwise. See
-L<perluniprops/User-Defined Character Properties>.
+User-defined property handlers that need to match differently under C</i>
+must be changed to read the new boolean parameter passed to them which
+is non-zero if case-insensitive matching is in effect or 0 otherwise.
+
See L<perluniprops/User-Defined Character Properties>.
=head3 \p{} implies Unicode semantics
=head3 Run-time code blocks in regular expressions inherit pragmata
-Code blocks in regular expressions (C<(?{...})> and C<(??{...})>) used not
-to inherit any pragmata (strict, warnings, etc.) if the regular expression
+Code blocks in regular expressions (C<(?{...})> and C<(??{...})>) previously
+did not inherit pragmata (strict, warnings, etc.) if the regular expression
was compiled at run time as happens in cases like these two:
use re 'eval';
$foo =~ $bar; # when $bar contains (?{...})
$foo =~ /$bar(?{ $finished = 1 })/;
-This was a bug, which has now been fixed. But it has the potential to break
-any code that was relying on it.
+This bug has now been fixed, but code which relied on the buggy behavior
+may need to be fixed to account for the correct behavior.
=head2 Stashes and Package Variables
tie @a, ...;
{
- local @a;
- # here, @a is a now a new, untied array
+ local @a;
+ # here, @a is a now a new, untied array
}
# here, @a refers again to the old, tied array
-The new local array used to be made tied too, which was fairly pointless,
-and has now been fixed. This fix could however potentially cause a change
-in behaviour of some code.
+Earlier versions of perl incorrectly tied the new local array. This has
+now been fixed. This fix could however potentially cause a change in
+behaviour of some code.
=head3 Stashes are now always defined
This is a side effect of removing a special case kludge in the tokeniser,
added for 5.10.0, to hide side effects of changes to the internal storage of
-hashes that drastically reduce their memory usage overhead.
+hashes. The fix drastically reduces hashes' memory overhead.
Calling defined on a stash has been deprecated since 5.6.0, warned on
lexicals since 5.6.0, and warned for stashes (and other package
-variables) since 5.12.0. C<defined %hash> has always exposed an
+variables) since 5.12.0. C<defined %hash> has always exposed an
implementation detail - emptying a hash by deleting all entries from it does
not make C<defined %hash> false, hence C<defined %hash> is not valid code to
-determine whether an arbitrary hash is empty. Instead, use the behaviour
+determine whether an arbitrary hash is empty. Instead, use the behaviour
that an empty C<%hash> always returns false in a scalar context.
+=head3 Clearing stashes
+
+Stash list assignment C<%foo:: = ()> used to make the stash anonymous
+temporarily while it was being emptied. Consequently, any of its
+subroutines referenced elsewhere would become anonymous (showing up as
+"(unknown)" in C<caller>). Now they retain their package names, such that
+C<caller> will return the original sub name if there is still a reference
+to its typeglob, or "foo::__ANON__" otherwise [perl #79208].
+
=head3 Dereferencing typeglobs
If you assign a typeglob to a scalar variable:
$glob = *foo;
the glob that is copied to C<$glob> is marked with a special flag
-indicating that the glob is just a copy. This allows subsequent assignments
-to C<$glob> to overwrite the glob. The original glob, however, is
-immutable.
+indicating that the glob is just a copy. This allows subsequent
+assignments to C<$glob> to overwrite the glob. The original glob,
+however, is immutable.
-Many Perl operators did not distinguish between these two types of globs.
+Some Perl operators did not distinguish between these two types of globs.
This would result in strange behaviour in edge cases: C<untie $scalar>
-would do nothing if the last thing assigned to the scalar was a glob
+would not untie the scalar if the last thing assigned to it was a glob
(because it treated it as C<untie *$scalar>, which unties a handle).
Assignment to a glob slot (e.g., C<*$glob = \@some_array>) would simply
assign C<\@some_array> to C<$glob>.
copy. This allows operators that make a distinction between globs and
scalars to be modified to treat only immutable globs as globs. (C<tie>,
C<tied> and C<untie> have been left as they are for compatibility's sake,
-but will warn. See L</Deprecations>.)
+but will warn. See L</Deprecations>.)
This causes an incompatible change in code that assigns a glob to the
-return value of C<*{}> when that operator was passed a glob copy. Take the
+return value of C<*{}> when that operator was passed a glob copy. Take the
following code, for instance:
$glob = *foo;
*$glob = *bar;
The C<*$glob> on the second line returns a new immutable glob. That new
-glob is made an alias to C<*bar>. Then it is discarded. So the second
+glob is made an alias to C<*bar>. Then it is discarded. So the second
assignment has no effect.
-See L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for even
+See L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for
more detail.
-=head3 Clearing stashes
-
-Stash list assignment C<%foo:: = ()> used to make the stash anonymous
-temporarily while it was being emptied. Consequently, any of its
-subroutines referenced elsewhere would become anonymous (showing up as
-"(unknown)" in C<caller>). Now they retain their package names, such that
-C<caller> will return the original sub name if there is still a reference
-to its typeglob, or "foo::__ANON__" otherwise [perl #79208].
-
=head3 Magic variables outside the main package
In previous versions of Perl, magic variables like C<$!>, C<%SIG>, etc. would
This has been fixed (or the feature has been removed, depending on how you see
it).
+=head3 local($_) will strip all magic from $_
+
+local() on scalar variables will give them a new value, but keep all
+their magic intact. This has proven to be problematic for the default
+scalar variable $_, where L<perlsub> recommends that any subroutine
+that assigns to $_ should localize it first. This would throw an
+exception if $_ is aliased to a read-only variable, and could have
+various unintentional side-effects in general.
+
+Therefore, as an exception to the general rule, local($_) will not
+only assign a new value to $_, but also remove all existing magic from
+it as well.
+
+=head3 Parsing of package and variable names
+
+The parsing of the names of packages and package variables has changed, in
+that multiple adjacent pairs of colons (as in foo::::bar) are all treated
+as package separators.
+
+Regardless of this change, the exact parsing of package separators has
+never been guaranteed and is subject to change in future Perl versions.
+
=head2 Changes to Syntax or to Perl Operators
=head3 C<given> return values
Due to this bug fix [perl #75904], functions
using the C<(*)>, C<(;$)> and C<(;*)> prototypes
-are parsed with higher precedence than before. So in the following example:
+are parsed with higher precedence than before. So
+in the following example:
sub foo($);
foo $a < $b;
the second line is now parsed correctly as C<< foo($a) < $b >>, rather than
-C<< foo($a < $b) >>. This happens when one of these operators is used in
+C<< foo($a < $b) >>. This happens when one of these operators is used in
an unparenthesised argument:
< > <= >= lt gt le ge
=head3 Negative zero
Negative zero (-0.0), when converted to a string, now becomes "0" on all
-platforms. It used to become "-0" on some, but "0" on others.
+platforms. It used to become "-0" on some, but "0" on others.
If you still need to determine whether a zero is negative, use
C<sprintf("%g", $zero) =~ /^-/> or the L<Data::Float> module on CPAN.
Previously C<my $pi := 4;> was exactly equivalent to C<my $pi : = 4;>,
with the C<:> being treated as the start of an attribute list, ending before
-the C<=>. The use of C<:=> to mean C<: => was deprecated in 5.12.0, and is now
-a syntax error. This will allow the future use of C<:=> as a new token.
+the C<=>. The use of C<:=> to mean C<: => was deprecated in 5.12.0, and is
+now a syntax error. This will allow the future use of C<:=> as a new
+token.
We find no Perl 5 code on CPAN using this construction, outside the core's
tests for it, so we believe that this change will have very little impact on
because of a code generator) then avoid the error by adding a space before
the C<=>.
+=head3 Change in the parsing of identifiers
+
+Characters outside the Unicode "XIDStart" set are no longer allowed at the
+beginning of an identifier. This means that certain accents and marks
+that normally follow an alphabetic character may no longer be the first
+character of an identifier.
+
=head2 Threads and Processes
=head3 Directory handles not copied to threads
On systems other than Windows that do not have
a C<fchdir> function, newly-created threads no
-longer inherit directory handles from their parent threads. Such programs
+longer inherit directory handles from their parent threads. Such programs
would usually have crashed anyway [perl #75154].
=head3 C<close> on shared pipes
The C<close> function no longer waits for the child process to exit if the
underlying file descriptor is still in use by another thread, to avoid
-deadlocks. It returns true in such cases.
+deadlocks. It returns true in such cases.
=head3 fork() emulation will not wait for signalled children
On Windows parent processes would not terminate until all forked
childred had terminated first. However, C<kill('KILL', ...)> is
inherently unstable on pseudo-processes, and C<kill('TERM', ...)>
-might not get delivered if the child if blocked in a system call.
+might not get delivered if the child is blocked in a system call.
To avoid the deadlock and still provide a safe mechanism to terminate
the hosting process, Perl will now no longer wait for children that
have been sent a SIGTERM signal. It is up to the parent process to
waitpid() for these children if child clean-up processing must be
-allowed to finish. However, it is also the responsibility of the
+allowed to finish. However, it is also the responsibility of the
parent then to avoid the deadlock by making sure the child process
can't be blocked on I/O either.
been fixed, standardizing on the variable names used in config.sh.
This will change the behavior of Policy.sh if you happen to have been
-accidentally relying on the Policy.sh incorrect behavior.
+accidentally relying on its incorrect behavior.
=head3 Perl source code is read in text mode on Windows
(not in a bracketed character class) or a C<"\B{"> is now deprecated
to allow for its future use by Perl itself.
-=head2 Deprecation warning added for deprecated-in-core .pl libs
+=head2 Deprecation warning added for deprecated-in-core Perl 4-era .pl libraries
This is a mandatory warning, not obeying -X or lexical warning bits.
The warning is modelled on that supplied by deprecate.pm for
deprecated-in-core .pm libraries. It points to the specific CPAN
-distribution that contains the .pl libraries. The CPAN version, of
-course, does not generate the warning.
+distribution that contains the .pl libraries. The CPAN versions, of
+course, do not generate the warning.
=head2 List assignment to C<$[>
for $x (qw(a b c)) { ... }
-=head2 C<\N{BELL}> is deprecated
+This is being deprecated because C<qw(a b c)> is supposed to mean
+C<"a", "b", "c"> not C<("a", "b", "c")>. I.e. this doesn't compile:
+
+ for my $i "a", "b", "c" { }
+
+So neither should this:
+
+ for my $i qw(a b c) {}
+
+But these both work:
+
+ for my $i ("a", "b", "c") { }
+ for my $i (qw(a b c)) {}
+
+Note that this does not change the behavior of cases like:
+
+ use POSIX qw(setlocale localeconv)
+ our @EXPORT = qw(foo bar baz);
+
+Where a list with our without parentheses could have been provided.
+
+=head2 C<\N{BELL}>
This is because Unicode is using that name for a different character.
See L</Unicode Version 6.0 is now supported (mostly)> for more
explanation.
-=head2 C<?PATTERN?> is deprecated
+=head2 C<?PATTERN?>
C<?PATTERN?> (without the initial m) has been deprecated and now produces
a warning. This is to allow future use of C<?> in new operators.
This feature is being deprecated due to its many issues, as documented in
L<perlunicode/User-Defined Case Mappings (for serious hackers only)>.
-It is planned to remove this feature in Perl 5.16. Instead use the CPAN module
+This feature will be removed in Perl 5.16. Instead use the CPAN module
L<Unicode::Casing>, which provides improved functionality.
=head2 Deprecated modules
The following modules will be removed from the core distribution in a
future release, and should be installed from CPAN instead. Distributions
-on CPAN which require these should add them to their prerequisites. The
+on CPAN which require these should add them to their prerequisites. The
core versions of these modules will issue a deprecation warning.
If you ship a packaged version of Perl, either alone or as part of a
=item L<Devel::DProf>
-We strongly recommend that you install and used L<Devel::NYTProf> in
-preference, as it offers significantly improved profiling and reporting.
+We strongly recommend that you install and used L<Devel::NYTProf> instead
+of this module, as it offers significantly improved profiling and reporting.
=back
=head2 "Safe signals" optimisation
-Signal dispatch has been moved from the runloop into control ops. This
+Signal dispatch has been moved from the runloop into control ops. This
should give a few percent speed increase, and eliminates almost all of
the speed penalty caused by the introduction of "safe signals" in
-5.8.0. Signals should still be dispatched within the same statement as
+5.8.0. Signals should still be dispatched within the same statement as
they were previously - if this is not the case, or it is possible to
create uninterruptible loops, this is a bug, and reports are encouraged
of how to recreate such issues.
=head2 String appending is 100 times faster
-When doing a lot of string appending, perl could end up allocating a lot more
-memory than needed in a very inefficient way, if perl was configured to use the
-system's C<malloc> implementation instead of its own.
+When doing a lot of string appending, perls built to use the system's
+C<malloc> could end up allocating a lot more memory than needed in a
+very inefficient way.
-C<sv_grow>, which is what's being used to allocate more memory if necessary
-when appending to a string, has now been taught how to round up the memory
+C<sv_grow>, the function used to allocate more memory if necessary
+when appending to a string, has been taught how to round up the memory
it requests to a certain geometric progression, making it much faster on
certain platforms and configurations. On Win32, it's now about 100 times
faster.
=head2 Eliminate C<PL_*> accessor functions under ithreads
When C<MULTIPLICITY> was first developed, and interpreter state moved into
-an interpreter struct, thread and interpreter local C<PL_*> variables were
-defined as macros that called accessor functions, returning the address of
-the value, outside of the perl core. The intent was to allow members
-within the interpreter struct to change size without breaking binary
-compatibility, so that bug fixes could be merged to a maintenance branch
-that necessitated such a size change.
-
-However, some non-core code defines C<PERL_CORE>, sometimes intentionally
-to bypass this mechanism for speed reasons, sometimes for other reasons but
-with the inadvertent side effect of bypassing this mechanism. As some of
-this code is widespread in production use, the result is that the core
-I<can't> change the size of members of the interpreter struct, as it will
-break such modules compiled against a previous release on that maintenance
-branch. The upshot is that this mechanism is redundant, and well-behaved
-code is penalised by it. Hence it can and should be removed (and has
-been).
+an interpreter struct, thread and interpreter local C<PL_*> variables
+were defined as macros that called accessor functions, returning the
+address of the value, outside of the perl core. The intent was to allow
+members within the interpreter struct to change size without breaking
+binary compatibility, so that bug fixes could be merged to a maintenance
+branch that necessitated such a size change. This mechanism was redundant
+and penalised well-behaved code. It has been removed.
=head2 Freeing weak references
-When an object has many weak references to it, freeing that object
+When there are many weak references to an object, freeing that object
can under some some circumstances take O(N^2) time to free (where N is the
-number of references). The number of circumstances has been reduced
-[perl #75254]
+number of references). The number of circumstances in which this can happen
+has been reduced [perl #75254]
=head2 Lexical array and hash assignments
=head2 Size optimisations to SV and HV structures
xhv_fill has been eliminated from struct xpvhv, saving 1 IV per hash and
-on some systems will cause struct xpvhv to become cache-aligned. To avoid
+on some systems will cause struct xpvhv to become cache-aligned. To avoid
this memory saving causing a slowdown elsewhere, boolean use of HvFILL
now calls HvTOTALKEYS instead (which is equivalent) - so while the fill
data when actually required are now calculated on demand, the cases when
=head2 Memory savings for weak references
-For weak references, the common case of just a single weak reference per
-referent has been optimised to reduce the storage required. In this case it
-saves the equivalent of one small Perl array per referent.
+For weak references, the common case of just a single weak reference
+per referent has been optimised to reduce the storage required. In this
+case it saves the equivalent of one small Perl array per referent.
=head2 C<%+> and C<%-> use less memory
C<CPAN::Meta::YAML> 0.003 has been added as a dual-life module. It supports a
subset of YAML sufficient for reading and writing META.yml and MYMETA.yml files
included with CPAN distributions or generated by the module installation
-toolchain. It should not be used for any other general YAML parsing or
+toolchain. It should not be used for any other general YAML parsing or
generation task.
=item *
-C<CPAN::Meta> version 2.110440 has been added as a dual-life module. It
+C<CPAN::Meta> version 2.110440 has been added as a dual-life module. It
provides a standard library to read, interpret and write CPAN distribution
metadata files (e.g. META.json and META.yml) which describes a
distribution, its contents, and the requirements for building it and
-installing it. The latest CPAN distribution metadata specification is
+installing it. The latest CPAN distribution metadata specification is
included as C<CPAN::Meta::Spec> and notes on changes in the specification
over time are given in C<CPAN::Meta::History>.
=item *
-C<HTTP::Tiny> 0.011 has been added as a dual-life module. It is a very
+C<HTTP::Tiny> 0.012 has been added as a dual-life module. It is a very
small, simple HTTP/1.1 client designed for simple GET requests and file
mirroring. It has has been added to enable CPAN.pm and CPANPLUS to
"bootstrap" HTTP access to CPAN using pure Perl without relying on external
=item *
-C<JSON::PP> 2.27105 has been added as a dual-life module, for the sake of
-reading F<META.json> files in CPAN distributions.
+C<JSON::PP> 2.27105 has been added as a dual-life module to allow CPAN
+clients to read F<META.json> files in CPAN distributions.
=item *
=item *
The following modules were added by the C<Unicode::Collate>
-upgrade. See below for details.
+upgrade. See below for details.
C<Unicode::Collate::CJK::Big5>
=item *
-C<bignum> has been upgraded from version 0.23 to 0.26.
+C<Benchmark> has been upgraded from version 1.11 to 1.12.
+
+=item *
+
+C<bignum> has been upgraded from version 0.23 to 0.27.
=item *
=item *
+C<constant> has been upgraded from version 1.20 to 1.21.
+
+Unicode constants work once more. They have been broken since perl 5.10.0
+[CPAN RT #67525].
+
+=item *
+
C<CPAN> has been upgraded from version 1.94_56 to 1.9600.
Major highlights:
=item *
+C<DBM_Filter> has been upgraded from version 0.03 to 0.04.
+
+=item *
+
C<Devel::DProf> has been upgraded from version 20080331.00 to 20110228.00.
Merely loading C<Devel::DProf> now no longer triggers profiling to start.
=item *
+C<DirHandle> has been upgraded from version 1.03 to 1.04.
+
+=item *
+
C<Dumpvalue> has been upgraded from version 1.13 to 1.16.
=item *
=item *
-C<ExtUtils::CBuilder> has been upgraded from version 0.27 to 0.280202.
+C<ExtUtils::CBuilder> has been upgraded from version 0.27 to 0.280203.
=item *
=item *
-C<ExtUtils::ParseXS> has been upgraded from version 2.21 to 2.2209.
+C<ExtUtils::ParseXS> has been upgraded from version 2.21 to 2.2210.
=item *
=item *
+C<File::Basename> has been upgraded from version 2.78 to 2.82.
+
+=item *
+
C<File::CheckTree> has been upgraded from version 4.4 to 4.41.
=item *
+C<File::Copy> has been upgraded from version 2.17 to 2.21.
+
+=item *
+
C<File::DosGlob> has been upgraded from version 1.01 to 1.04.
It allows patterns containing literal parentheses (they no longer need to
C<IO> has been upgraded from version 1.25_02 to 1.25_04.
-=item *
-
-C<IO::Select> has been upgraded from version 1.17 to 1.20.
-
-It now allows IO::Handle objects (and objects in derived classes) to be
-removed from an IO::Select set even if the underlying file descriptor is
-closed or invalid.
+This version of C<IO> includes a new C<IO::Select>, which now allows IO::Handle
+objects (and objects in derived classes) to be removed from an IO::Select set
+even if the underlying file descriptor is closed or invalid.
=item *
=item *
-C<overload> has been upgraded from 1.10 to 1.12.
+C<overload> has been upgraded from 1.10 to 1.13.
C<overload::Method> can now handle subroutines that are themselves blessed
into overloaded classes [perl #71998].
=item *
-C<Pod::Html> has been upgraded from version 1.09 to 1.1.
+C<Pod::Html> has been upgraded from version 1.09 to 1.11.
=item *
=item *
-C<re> has been upgraded from version 0.11 to 0.17.
+C<re> has been upgraded from version 0.11 to 0.18.
New C<use re "/flags"> pragma
C<Socket> has been upgraded from version 1.87 to 1.94.
-See L</IPv6 support>, above.
+See L</Improved IPv6 support>, above.
=item *
=head2 Removed Modules and Pragmata
-The following modules have been removed from the core distribution, and if
-needed should be installed from CPAN instead.
+As promised in Perl 5.12.0's release notes, the following modules have
+been removed from the core distribution, and if needed should be installed
+from CPAN instead.
=over
=head3 L<perlmodlib> is now complete
-The perlmodlib page that came with Perl 5.12.0 was missing a lot of
-modules, due to a bug in the script that generates the list. This has been
+The perlmodlib page that came with Perl 5.12.0 was missing a number of
+modules, due to a bug in the script that generates the list. This has been
fixed [perl #74332] (5.12.1).
-=head3 Replace
wrong tr/// table in L<perlebcdic>
+=head3 Replace
incorrect tr/// table in L<perlebcdic>
L<perlebcdic> contains a helpful table to use in tr/// to convert
-between EBCDIC and Latin1/ASCII. Unfortunately, the table was the
-inverse of the one it describes, though the code that used the table
-worked correctly for the specific example given.
+between EBCDIC and Latin1/ASCII. The table was the inverse of the one
+it describes, though the code that used the table worked correctly for
+the specific example given.
-The table has been changed to its inverse, and the sample code changed
-to correspond, as this is easier for the person trying to follow the
-instructions since deriving the old table is somewhat more complicated.
+The table has been corrected, and the sample code changed to correspond.
-The table has also been changed to hex from octal, as that is more the norm
-these days, and the recipes in the pod altered to print out leading
-zeros to make all the values the same length.
+The table has also been changed to hex from octal and the recipes in the
+pod have been altered to print out leading zeros to make all the values
+the same length.
=head3 Tricks for user-defined casing
conversions on Unicode data, and how to provide scoped changes to alter
one's own code's behaviour without stomping on anybody else.
-=head3 INSTALL explicitly states the requirement for C89
+=head3 INSTALL explicitly states that Perl requires a C89 compiler
This was already true but it's now Officially Stated For The Record
(5.12.2).
The documentation for the C<SvTRUE> macro in
L<perlapi> was simply wrong in stating that
-get-magic is not processed. It has been corrected.
+get-magic is not processed. It has been corrected.
=head3 L<perlvar> revamp
=head3 L<overload>
-L<overload>'s documentation has practically undergone a rewrite. It
+L<overload>'s documentation has practically undergone a rewrite. It
is now much more straightforward and clear.
=head3 perlhack and perlrepository revamp
-The L<perlhack> and perlrepository documents have been heavily edited and
-split up into several new documents.
-
The L<perlhack> document is now much shorter, and focuses on the Perl 5
-development process and submitting patches to Perl. The technical content has
-been moved to several new documents, L<perlsource>, L<perlinterp>,
-L<perlhacktut>, and L<perlhacktips>. This technical content has only been
-lightly edited.
+development process and submitting patches to Perl. The technical content
+
has been moved to several new documents, L<perlsource>, L<perlinterp>,
+L<perlhacktut>, and L<perlhacktips>. This technical content has only
+been lightly edited.
-The perlrepository document has been renamed to L<perlgit>. This new document
-is just a how-to on using git with the Perl source code. Any other content
-that used to be in perlrepository has been moved to perlhack.
+The perlrepository document has been renamed to L<perlgit>. This new
+document is just a how-to on using git with the Perl source code.
+Any other content that used to be in perlrepository has been moved
+to L<perlhack>.
=head3 Time::Piece examples
=item Operation "%s" returns its argument for ...
Performing an operation requiring Unicode semantics (such as case-folding)
-on a Unicode surrogate or a non-Unicode character now triggers a warning:
-'Operation "%s" returns its argument for ...'.
+on a Unicode surrogate or a non-Unicode character now triggers this
+warning.
=item Use of qw(...) as parentheses is deprecated
=item *
-CCINCDIR and CCLIBDIR for the mingw64
-cross-compiler are now correctly under
-$(CCHOME)\mingw\include and \lib rather than immediately below $(CCHOME).
+CCINCDIR and CCLIBDIR for the mingw64 cross-compiler are now correctly
+under $(CCHOME)\mingw\include and \lib rather than immediately below
+$(CCHOME).
This means the 'incpath', 'libpth', 'ldflags', 'lddlflags' and
'ldflags_nolargefiles' values in Config.pm and Config_heavy.pl are now
=item Apollo DomainOS
-The last vestiges of support for this platform have been excised from the
-Perl distribution. It was officially discontinued in version 5.12.0. It had
-not worked for years before that.
+The last vestiges of support for this platform have been excised from
+the Perl distribution. It was officially discontinued in version 5.12.0.
+It had not worked for years before that.
=item MacOS Classic
The last vestiges of support for this platform have been excised from the
-Perl distribution. It was officially discontinued in an earlier version.
+Perl distribution. It was officially discontinued in an earlier version.
=back
=head3 IRIX
+=over
+
+=item *
+
Conversion of strings to floating-point numbers is now more accurate on
IRIX systems [perl #32380].
+=back
+
=head3 Mac OS X
+=over
+
+=item *
+
Early versions of Mac OS X (Darwin) had buggy implementations of the
C<setregid>, C<setreuid>, C<setrgid> and C<setruid> functions, so perl
would pretend they did not exist.
These functions are now recognised on Mac OS 10.5 (Leopard; Darwin 9) and
higher, as they have been fixed [perl #72990].
+=back
+
=head3 MirBSD
+=over
+
+=item *
+
Previously if you built perl with a shared libperl.so on MirBSD (the
default config), it would work up to the installation; however, once
installed, it would be unable to find libperl. So path handling is now
treated as in the other BSD dialects.
+=back
+
=head3 NetBSD
+=over
+
+=item *
+
The NetBSD hints file has been changed to make the system's malloc the
default.
-=head3 Recent OpenBSDs now use perl's malloc
+=back
+
+=head3 OpenBSD
+
+=over
+
+=item *
OpenBSD E<gt> 3.7 has a new malloc implementation which is mmap-based
and as such can release memory back to the OS; however, perl's use of
this malloc causes a substantial slowdown so we now default to using
perl's malloc instead [perl #75742].
+=back
+
=head3 OpenVOS
+=over
+
+=item *
+
perl now builds again with OpenVOS (formerly known as Stratus VOS)
[perl #78132] (5.12.3).
+=back
+
=head3 Solaris
-DTrace is now supported on Solaris. There used to be build failures, but
+=over
+
+=item *
+
+DTrace is now supported on Solaris. There used to be build failures, but
these have been fixed [perl #73630] (5.12.3).
+=back
+
=head3 VMS
=over
=item *
-F<git_version.h> is now installed on VMS. This was an oversight in v5.12.0 which
+F<git_version.h> is now installed on VMS. This
+was an oversight in v5.12.0 which
caused some extensions to fail to build (5.12.2).
=item *
It is now possible for XS code to hook into Perl's lexical scope
mechanism at compile time, using the new C<Perl_blockhook_register>
-function. See L<perlguts/"Compile-time scope hooks">.
+function.
See L<perlguts/"Compile-time scope hooks">.
=head3 The recursive part of the peephole optimizer is now hookable
C<UNICODE_IS_ILLEGAL> have been removed, as they stem from a
fundamentally broken model of how the Unicode non-character code points
should be handled, which is now described in
-L<perlunicode/Non-character code points>. See also L</Selected Bug Fixes>.
-
-XXX Which bugs in particular? Selected Bug Fixes is too long for this link
-to be meaningful right now
-I don't see the bugs in that section currently -- khw
+L<perlunicode/Non-character code points>. See also the Unicode section
+under L</Selected Bug Fixes>.
=head2 Deprecated C APIs
run-time.
Use the new C<find_rundefsv> function or the C<UNDERBAR> macro
-instead. They directly return the right SV representing C<$_>, whether it's
+instead. They directly return the right SV
+representing C<$_>, whether it's
lexical or dynamic.
=item C<CALL_FPTR> and C<CPERLscope>
=item *
PerlIO no longer crashes when called recursively, e.g., from a signal
-handler. Now it just leaks memory [perl #75556].
+handler. Now it just leaks memory [perl #75556].
=item *
Most I/O functions were not warning for unopened handles unless the
-'closed' and 'unopened' warnings categories were both enabled. Now only
+'closed' and 'unopened' warnings categories were both enabled. Now only
C<use warnings 'unopened'> is necessary to trigger these warnings (as was
always meant to be the case).
A regular expression match in the right-hand side of a global substitution
(C<s///g>) that is in the same scope will no longer cause match variables
-to have the wrong values on subsequent iterations. This can happen when an
+to have the wrong values on subsequent iterations. This can happen when an
array or hash subscript is interpolated in the right-hand side, as in
C<s|(.)|@a{ print($1), /./ }|g> [perl #19078].
=item *
The C<(?|...)> regular expression construct no longer crashes if the final
-branch has more sets of capturing parentheses than any other branch. This
+branch has more sets of capturing parentheses than any other branch. This
was fixed in Perl 5.10.1 for the case of a single branch, but that fix did
not take multiple branches into account [perl #84746].
$text =~ /phoo/
-at compile time. Now it correctly matches against C<$_> [perl #20444].
+at compile time. Now it correctly matches against C<$_> [perl #20444].
=item *
=item *
-Several contexts no longer allow a Unicode character to begin a word
-that should never begin words, for an example an accent that must follow
-another character previously could precede all other characters.
-
-=item *
-
Defining a constant with the same name as one of perl's special blocks
(e.g., INIT) stopped working in 5.12.0, but has now been fixed
[perl #78634].
=item *
-C<state> can now be used with attributes. It used to mean the same thing as
+C<state> can now be used with attributes. It
+used to mean the same thing as
C<my> if attributes were present [perl #68658].
=item *
C<PL_isarev>, which is accessible to Perl via C<mro::get_isarev> is now
updated properly when packages are deleted or removed from the C<@ISA> of
-other classes. This allows many packages to be created and deleted without
+other classes. This allows many packages to be created and deleted without
causing a memory leak [perl #75176].
=back
=item *
Assigning a glob to a PVLV used to convert it to a plain string. Now it
-works correctly, and a PVLV can hold a glob. This would happen when a
+works correctly, and a PVLV can hold a glob. This would happen when a
nonexistent hash or array element was passed to a subroutine:
sub { $_[0] = *foo }->($hash{key});
During the restoration of a localised typeglob on scope exit, any
destructors called as a result would be able to see the typeglob in an
inconsistent state, containing freed entries, which could result in a
-crash. This would affect code like this:
+crash. This would affect code like this:
local *@;
eval { die bless [] }; # puts an object in $@
}
Now the glob entries are cleared before any destructors are called. This
-also means that destructors can vivify entries in the glob. So perl tries
+also means that destructors can vivify entries in the glob. So perl tries
again and, if the entries are re-created too many times, dies with a
'panic: gp_free...' error message.
+=item *
+
+If a typeglob is freed while a subroutine attached to it is still
+referenced elsewhere, the subroutine is renamed to __ANON__ in the same
+package, unless the package has been undefined, in which case the __ANON__
+package is used. This could cause packages to be autovivified in some
+cases; e.g., if the package had been deleted. Now this is no longer the
+case. The __ANON__ package is now used also when the original package is
+no longer attached to the symbol table. This avoids memory leaks in some
+cases [perl #87664].
+
+=item *
+
+Subroutines and package variables inside a package whose name ends with
+"::" can now be accessed with a fully qualified name.
+
=back
=head2 Unicode
=item *
-What has become known as the "Unicode Bug" is mostly resolved in this release.
-Under C<use feature 'unicode_strings'>, the internal storage format of a
-string no longer affects the external semantics. There are two known
-exceptions. User-defined case changing functions, which are planned to
-be deprecated in 5.14, require utf8-encoded strings to function; and the
-character C<LATIN SMALL LETTER SHARP S> in regular expression
-case-insensitive matching has a somewhat different set of bugs depending
-on the internal storage format. Case-insensitive matching of all
-characters that have multi-character matches, as this one does, is
-problematical in Perl [perl #58182].
+What has become known as the "Unicode Bug" is almost completely resolved in
+this release. Under C<use feature 'unicode_strings'> (which is
+automatically selected by C<use 5.012> and above), the internal
+storage format of a string no longer affects the external semantics.
+[perl #58182].
+
+There are two known exceptions:
+
+=over
+
+=item 1
+
+The now-deprecated user-defined case changing
+functions require utf8-encoded strings to function. The CPAN module
+L<Unicode::Casing> has been written to replace this feature, without its
+drawbacks, and the feature is scheduled to be removed in 5.16.
+
+=item 2
+
+C<quotemeta> (and its in-line equivalent C<\Q>) also can give different
+results if a string is encoded in UTF-8 or not. See
+L<perlunicode/The "Unicode Bug">.
+
+=back
=item *
-The handling of Unicode non-characters has changed.
+The handling of Unicode non-character code points has changed.
Previously they were mostly considered illegal, except that only one of
the 66 of them was known about in places. The Unicode standard
considers them legal, but forbids the "open interchange" of them.
=item *
+Case-insensitive C<"/i"> regular expression matching of Unicode
+characters which match multiple characters now works much more as
+intended. For example
+
+ "\N{LATIN SMALL LIGATURE FFI}" =~ /ffi/ui
+
+and
+
+ "ffi" =~ /\N{LATIN SMALL LIGATURE FFI}/ui
+
+are both true. Previously, there were many bugs with this feature.
+What hasn't been fixed are the places where the pattern contains the
+multiple characters, but the characters are split up by other things,
+such as in
+
+ "\N{LATIN SMALL LIGATURE FFI}" =~ /(f)(f)i/ui
+
+or
+
+ "\N{LATIN SMALL LIGATURE FFI}" =~ /ffi*/ui
+
+or
+
+ "\N{LATIN SMALL LIGATURE FFI}" =~ /[a-f][f-m][g-z]/ui
+
+None of these match.
+
+Also, this matching doesn't fully conform to the current Unicode
+standard, which asks that the matching be made upon the NFD
+(Normalization Form Decomposed) of the text. However, as of this
+writing, March 2010, the Unicode standard is currently in flux about
+what they will recommend doing with regard to such cases. It may be
+that they will throw out the whole concept of multi-character matches.
+[perl #71736].
+
+=item *
+
Naming a deprecated character in \N{...} no longer leaks memory.
=item *
=item *
-FETCH is no longer called on tied variables in void context.
-
-=item *
-
C<$tied-E<gt>()> did not always call FETCH [perl #8438].
=item *
In-memory files created by C<open $fh, 'E<gt>' \$buffer> were not calling
FETCH/STORE at all [perl #43789] (5.12.2).
+=item *
+
+utf8::is_utf8 now respects get-magic (e.g. $1) (5.12.1).
+
=back
=item *
+Non-commutative binary operators used to swap their operands if the same
+tied scalar was used for both operands and returned a different value for
+each FETCH. For instance, if C<$t> returned 2 the first time and 3 the
+second, then C<$t/$t> would evaluate to 1.5. This has been fixed
+[perl #87708].
+
+=item *
+
String C<eval> now detects taintedness of overloaded or tied
arguments [perl #75716].
=item *
String C<eval> and regular expression matches against objects with string
-overloading no longer cause memory corruption or crashes [perl 77084].
+overloading no longer cause memory corruption or crashes [perl #77084].
=item *
=item *
-C<sprintf> now dies when passed a tainted scalar for the format. It did
+C<sprintf> now dies when passed a tainted scalar for the format. It did
already die for arbitrary expressions, but not for simple scalars
[perl #82250].
=item *
-utf8::is_utf8 now respects get-magic (e.g. $1) (5.12.1).
+C<lc>, C<uc>, C<lcfirst> and C<ucfirst> no longer return untainted strings
+when the argument is tainted. This has been broken since perl 5.8.9
+[perl #87336].
=back
C<#line> directives in string evals were not properly updating the arrays
of lines of code (C<< @{"_<..."} >>) that the debugger (or any debugging or
-profiling module) uses. In threaded builds, they were not being updated at
-all. In non-threaded builds, the line number was ignored, so any change to
+profiling module) uses. In threaded builds, they were not being updated at
+all. In non-threaded builds, the line number was ignored, so any change to
the existing line number would cause the lines to be misnumbered
[perl #79442].
crash, because the handles were not cloned, but simply passed to the new
thread, resulting in a double free.
-Now directory handles are cloned properly, on systems that have a C<fchdir>
-function. On other systems, new threads simply do not inherit directory
+Now directory handles are cloned properly, on Windows
+and on systems that have a C<fchdir> function. On other
+systems, new threads simply do not inherit directory
handles from their parent threads [perl #75154].
=item *
=item *
Perl now does a timely cleanup of SVs that are cloned into a new thread but
-then discovered to be orphaned (i.e., their owners are I<not> cloned). This
+then discovered to be orphaned (i.e., their
+owners are I<not> cloned). This
eliminates several "scalars leaked" warnings when joining threads.
=back
=item *
A signal handler called within a signal handler could cause leaks or
-double-frees. Now fixed. [perl #76248].
+double-frees. Now fixed [perl #76248].
=back
L<pos()|perlfunc/"index STR,SUBSTR,POSITION">, L<keys()|perlfunc/"keys HASH">,
and L<vec()|perlfunc/"vec EXPR,OFFSET,BITS"> could, when used in combination
with lvalues, result in leaking the scalar value they operate on, and cause its
-destruction to happen too late. This has now been fixed.
+destruction to happen too late. This has now been fixed.
=item *
=item *
C<sv_catsv_flags> no longer calls C<mg_get> on its second argument (the
-source string) if the flags passed to it do not include SV_GMAGIC. So it
+source string) if the flags passed to it do not include SV_GMAGIC. So it
now matches the documentation.
=item *
This is actually a change introduced in perl 5.12.0, but it was missed from
that release's perldelta.
+=head2 C<split> and C<@_>
+
+C<split> no longer modifies C<@_> when called in scalar or void context.
+In void context it now produces a "Useless use of split" warning.
+This was also a perl 5.12.0 changed that missed the perldelta.
+
=head1 Obituary
-Randy Kobes, creator of the kobesearch alternative to search.cpan.org and
-contributor/maintainer to several core Perl toolchain modules, passed away
-on September 18, 2010 after a battle with lung cancer. His contributions
-to the Perl community will be missed.
+Randy Kobes, creator of http://kobesearch.cpan.org/ and
+contributor/maintainer to several core Perl toolchain modules, passed
+away on September 18, 2010 after a battle with lung cancer. The community
+was richer for his involvement. He will be missed.
=head1 Acknowledgements
https://perl5.git.perl.org / perl5.git / blobdiff