This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perldelta: Cull bug fix entries that do not apply
[perl5.git] / pod / perldelta.pod
CommitLineData
44691e6f
AB
1=encoding utf8
2
3=head1 NAME
4
5076a392 5perldelta - what is new for perl v5.14.0
c71a852f 6
5076a392
FC
7=head1 DESCRIPTION
8
9This document describes differences between the 5.12.0 release and
10the 5.14.0 release.
11
12Some of the bug fixes in this release have been backported to subsequent
13releases of 5.12.x. Those are indicated with the 5.12.x version in
14parentheses.
15
16XXX Go through the perl512*delta files and do that.
17
18=head1 Notice
19
20XXX Any important notices here
21
22=head1 Core Enhancements
23
1f539a1a 24=head2 Unicode
5076a392 25
1f539a1a 26=head3 Unicode Version 6.0 is now supported (mostly)
5076a392 27
1f539a1a
FC
28Perl comes with the Unicode 6.0 data base updated with
29L<Corrigendum #8|http://www.unicode.org/versions/corrigendum8.html>,
30with one exception noted below.
31See L<http://unicode.org/versions/Unicode6.0.0> for details on the new
32release. Perl does not support any Unicode provisional properties,
33including the new ones for this release, but their database files are
34packaged with Perl.
5076a392 35
1f539a1a 36Unicode 6.0 has chosen to use the name C<BELL> for the character at U+1F514,
e1b1739f 37which is a symbol that looks like a bell, and is used in Japanese cell
1f539a1a
FC
38phones. This conflicts with the long-standing Perl usage of having
39C<BELL> mean the ASCII C<BEL> character, U+0007. In Perl 5.14,
40C<\N{BELL}> will continue to mean U+0007, but its use will generate a
41deprecated warning message, unless such warnings are turned off. The
42new name for U+0007 in Perl will be C<ALERT>, which corresponds nicely
43with the existing shorthand sequence for it, C<"\a">. C<\N{BEL}> will
44mean U+0007, with no warning given. The character at U+1F514 will not
45have a name in 5.14, but can be referred to by C<\N{U+1F514}>. The plan
46is that in Perl 5.16, C<\N{BELL}> will refer to U+1F514, and so all code
47that uses C<\N{BELL}> should convert by then to using C<\N{ALERT}>,
48C<\N{BEL}>, or C<"\a"> instead.
5076a392 49
1f539a1a 50=head3 Full functionality for C<use feature 'unicode_strings'>
5076a392 51
1f539a1a
FC
52This release provides full functionality for C<use feature
53'unicode_strings'>. Under its scope, all string operations executed and
54regular expressions compiled (even if executed outside its scope) have
55Unicode semantics. See L<feature>.
5076a392 56
1f539a1a
FC
57This feature avoids most forms of the "Unicode Bug" (See
58L<perlunicode/The "Unicode Bug"> for details.) If there is a
59possibility that your code will process Unicode strings, you are
60B<strongly> encouraged to use this subpragma to avoid nasty surprises.
5076a392 61
1f539a1a 62=head3 C<\N{I<name>}> and C<charnames> enhancements
5076a392 63
1f539a1a 64=over
5076a392 65
1f539a1a 66=item *
5076a392
FC
67
68C<\N{}> and C<charnames::vianame> now know about the abbreviated
e1b1739f
FC
69character names listed by Unicode, such as NBSP, SHY, LRO, ZWJ, etc., all
70the customary abbreviations for the C0 and C1 control characters (such as
71ACK, BEL, CAN, etc.), and a few new variants of some C1 full names that
72are in common usage.
5076a392 73
1f539a1a
FC
74=item *
75
959ad7d5
FC
76Unicode has a number of named character sequences, in which particular sequences
77of code points are given names. C<\N{...}> now recognizes these.
78
1f539a1a
FC
79=item *
80
959ad7d5
FC
81C<\N{}>, C<charnames::vianame>, C<charnames::viacode> now know about every
82character in Unicode. Previously, they didn't know about the Hangul syllables
83nor a number of CJK (Chinese/Japanese/Korean) characters.
84
1f539a1a
FC
85=item *
86
5076a392
FC
87In the past, it was ineffective to override one of Perl's abbreviations
88with your own custom alias. Now it works.
89
1f539a1a
FC
90=item *
91
e1b1739f 92You can also create a custom alias of the ordinal of a
5076a392
FC
93character, known by C<\N{...}>, C<charnames::vianame()>, and
94C<charnames::viacode()>. Previously, an alias had to be to an official
95Unicode character name. This made it impossible to create an alias for
e1b1739f
FC
96a code point that had no name, such as those reserved for private
97use.
5076a392 98
1f539a1a
FC
99=item *
100
959ad7d5
FC
101A new function, C<charnames::string_vianame()>, has been added.
102This function is a run-time version of C<\N{...}>, returning the string
103of characters whose Unicode name is its parameter. It can handle
104Unicode named character sequences, whereas the pre-existing
105C<charnames::vianame()> cannot, as the latter returns a single code
106point.
107
1f539a1a
FC
108=back
109
5076a392
FC
110See L<charnames> for details on all these changes.
111
1f539a1a 112=head3 Any unsigned value can be encoded as a character
5076a392 113
1f539a1a
FC
114With this release, Perl is adopting a model that any unsigned value can
115be treated as a code point and encoded internally (as utf8) without
54c7bb16 116warnings - not just the code points that are legal in Unicode.
1f539a1a
FC
117However, unless utf8 warnings have been
118explicitly lexically turned off, outputting or performing a
119Unicode-defined operation (such as upper-casing) on such a code point
120will generate a warning. Attempting to input these using strict rules
121(such as with the C<:encoding('UTF-8')> layer) will continue to fail.
122Prior to this release the handling was very inconsistent, and incorrect
123in places. Also, the Unicode non-characters, some of which previously were
124erroneously considered illegal in places by Perl, contrary to the Unicode
125standard, are now always legal internally. But inputting or outputting
126them will work the same as for the non-legal Unicode code points, as the
127Unicode standard says they are illegal for "open interchange".
5076a392 128
1f539a1a 129=head3 New warnings categories for problematic (non-)Unicode code points.
5076a392 130
e1b1739f
FC
131Three new warnings subcategories of "utf8" have been added. These
132allow you to turn off some "utf8" warnings, while allowing
133others warnings to remain on. The three categories are:
1f539a1a
FC
134C<surrogate> when UTF-16 surrogates are encountered;
135C<nonchar> when Unicode non-character code points are encountered;
136and C<non_unicode> when code points that are above the legal Unicode
137maximum of 0x10FFFF are encountered.
5076a392 138
1f539a1a 139=head2 Regular Expressions
5076a392 140
1f539a1a 141=head3 C<(?^...)> construct to signify default modifiers
5076a392 142
e1b1739f
FC
143An ASCII caret (also called a "circumflex accent") C<"^">
144immediately following a C<"(?"> in a regular expression
145now means that the subexpression does not inherit the
146surrounding modifiers such as C</i>, but reverts to the
5076a392
FC
147Perl defaults. Any modifiers following the caret override the defaults.
148
149The stringification of regular expressions now uses this
150notation. E.g., before, C<qr/hlagh/i> would be stringified as
151C<(?i-xsm:hlagh)>, but now it's stringified as C<(?^i:hlagh)>.
152
153The main purpose of this is to allow tests that rely on the
e1b1739f 154stringification not to have to change when new modifiers are added.
5076a392
FC
155See L<perlre/Extended Patterns>.
156
1f539a1a 157=head3 C</d>, C</l>, C</u>, C</a>, and C</aa> modifiers
5076a392 158
959ad7d5
FC
159Four new regular expression modifiers have been added. These are mutually
160exclusive; one only can be turned on at a time.
5076a392 161
959ad7d5 162The C</l> modifier says to compile the regular expression as if it were
5076a392
FC
163in the scope of C<use locale>, even if it is not.
164
959ad7d5 165The C</u> modifier says to compile the regular expression as if it were
5076a392
FC
166in the scope of a C<use feature "unicode_strings"> pragma.
167
e1b1739f 168The C</d> (default) modifier is used to override any C<use locale> and
5076a392
FC
169C<use feature "unicode_strings"> pragmas that are in effect at the time
170of compiling the regular expression.
171
959ad7d5
FC
172The C</a> regular expression modifier restricts C<\s>, C<\d> and C<\w> and
173the Posix (C<[[:posix:]]>) character classes to the ASCII range. The
174complements and C<\b> and C<\B> are correspondingly
175affected. Otherwise, C</a> behaves like the C</u> modifier, in that
e1b1739f 176case-insensitive matching uses Unicode semantics.
5076a392 177
959ad7d5
FC
178The C</aa> modifier is like C</a>, except that, in case-insensitive matching, no ASCII character will match a
179non-ASCII character. For example,
5076a392 180
959ad7d5 181 'k' =~ /\N{KELVIN SIGN}/ai
5076a392 182
959ad7d5 183will match; it won't under C</aa>.
5076a392 184
959ad7d5 185See L<perlre/Modifiers> for more detail.
5076a392 186
1f539a1a 187=head3 Non-destructive substitution
5076a392 188
1f539a1a
FC
189The substitution (C<s///>) and transliteration
190(C<y///>) operators now support an C</r> option that
191copies the input variable, carries out the substitution on
192the copy and returns the result. The original remains unmodified.
5076a392 193
1f539a1a
FC
194 my $old = 'cat';
195 my $new = $old =~ s/cat/dog/r;
196 # $old is 'cat' and $new is 'dog'
5076a392 197
1f539a1a 198This is particularly useful with C<map>. See L<perlop> for more examples.
5076a392 199
1f539a1a 200=head3 Reentrant regular expression engine
5076a392 201
1f539a1a
FC
202It is now safe to use regular expressions within C<(?{...})> and
203C<(??{...})> code blocks inside regular expressions.
5076a392 204
1f539a1a 205These block are still experimental, however, and still have problems with
e1b1739f 206lexical (C<my>) variables and abnormal exiting.
5076a392 207
1f539a1a 208=head3 C<use re '/flags';>
5076a392
FC
209
210The C<re> pragma now has the ability to turn on regular expression flags
211till the end of the lexical scope:
212
213 use re '/x';
214 "foo" =~ / (.+) /; # /x implied
215
216See L<re/"'/flags' mode"> for details.
217
1f539a1a 218=head3 \o{...} for octals
5076a392 219
e1b1739f
FC
220There is a new octal escape sequence, C<"\o">, in double-quote-like
221contexts. This construct allows large octal ordinals beyond the
1f539a1a
FC
222current max of 0777 to be represented. It also allows you to specify a
223character in octal which can safely be concatenated with other regex
224snippets and which won't be confused with being a backreference to
225a regex capture group. See L<perlre/Capture groups>.
226
227=head3 Add C<\p{Titlecase}> as a synonym for C<\p{Title}>
228
229This synonym is added for symmetry with the Unicode property names
230C<\p{Uppercase}> and C<\p{Lowercase}>.
5076a392 231
1f539a1a
FC
232=head3 Regular expression debugging output improvement
233
234Regular expression debugging output (turned on by C<use re 'debug';>) now
235uses hexadecimal when escaping non-ASCII characters, instead of octal.
236
1e463951
FC
237=head3 Return value of C<delete $+{...}>
238
239Custom regular expression engines can now determine the return value of
240C<delete> on an entry of C<%+> or C<%->.
241
1f539a1a
FC
242=head2 Syntactical Enhancements
243
244=head3 Array and hash container functions accept references
5076a392
FC
245
246All built-in functions that operate directly on array or hash
247containers now also accept hard references to arrays or hashes:
248
249 |----------------------------+---------------------------|
250 | Traditional syntax | Terse syntax |
251 |----------------------------+---------------------------|
252 | push @$arrayref, @stuff | push $arrayref, @stuff |
253 | unshift @$arrayref, @stuff | unshift $arrayref, @stuff |
254 | pop @$arrayref | pop $arrayref |
255 | shift @$arrayref | shift $arrayref |
256 | splice @$arrayref, 0, 2 | splice $arrayref, 0, 2 |
257 | keys %$hashref | keys $hashref |
258 | keys @$arrayref | keys $arrayref |
259 | values %$hashref | values $hashref |
260 | values @$arrayref | values $arrayref |
261 | ($k,$v) = each %$hashref | ($k,$v) = each $hashref |
262 | ($k,$v) = each @$arrayref | ($k,$v) = each $arrayref |
263 |----------------------------+---------------------------|
264
265This allows these built-in functions to act on long dereferencing chains
266or on the return value of subroutines without needing to wrap them in
267C<@{}> or C<%{}>:
268
269 push @{$obj->tags}, $new_tag; # old way
270 push $obj->tags, $new_tag; # new way
271
272 for ( keys %{$hoh->{genres}{artists}} ) {...} # old way
273 for ( keys $hoh->{genres}{artists} ) {...} # new way
274
275For C<push>, C<unshift> and C<splice>, the reference will auto-vivify
276if it is not defined, just as if it were wrapped with C<@{}>.
277
5076a392
FC
278For C<keys>, C<values>, C<each>, when overloaded dereferencing is
279present, the overloaded dereference is used instead of dereferencing the
e1b1739f
FC
280underlying reftype. Warnings are issued about assumptions made in
281ambiguous cases.
5076a392 282
1f539a1a
FC
283=head3 Single term prototype
284
285The C<+> prototype is a special alternative to C<$> that will act like
286C<\[@%]> when given a literal array or hash variable, but will otherwise
e1b1739f 287force scalar context on the argument. See L<perlsub/Prototypes>.
1f539a1a
FC
288
289=head3 C<package> block syntax
290
291A package declaration can now contain a code block, in which case the
292declaration is in scope only inside that block. So C<package Foo { ... }>
293is precisely equivalent to C<{ package Foo; ... }>. It also works with
294a version number in the declaration, as in C<package Foo 1.2 { ... }>.
e1b1739f 295See L<perlfunc>.
1f539a1a
FC
296
297=head3 Statement labels can appear in more places
298
299Statement labels can now occur before any type of statement or declaration,
300such as C<package>.
301
302=head3 Stacked labels
303
304Multiple statement labels can now appear before a single statement.
305
306=head3 Uppercase X/B allowed in hexadecimal/binary literals
307
308Literals may now use either upper case C<0X...> or C<0B...> prefixes,
309in addition to the already supported C<0x...> and C<0b...>
e1b1739f 310syntax [perl #76296].
1f539a1a
FC
311
312C, Ruby, Python and PHP already supported this syntax, and it makes
313Perl more internally consistent. A round-trip with C<eval sprintf
e1b1739f 314"%#X", 0x10> now returns C<16>, the way C<eval sprintf "%#x", 0x10> does.
1f539a1a 315
1e463951
FC
316=head3 Overridable tie functions
317
318C<tie>, C<tied> and C<untie> can now be overridden [perl #75902].
319
1f539a1a
FC
320=head2 Exception Handling
321
322Several changes have been made to the way C<die>, C<warn>, and C<$@>
323behave, in order to make them more reliable and consistent.
324
325When an exception is thrown inside an C<eval>, the exception is no
326longer at risk of being clobbered by code running during unwinding
327(e.g., destructors). Previously, the exception was written into C<$@>
328early in the throwing process, and would be overwritten if C<eval> was
329used internally in the destructor for an object that had to be freed
330while exiting from the outer C<eval>. Now the exception is written
331into C<$@> last thing before exiting the outer C<eval>, so the code
332running immediately thereafter can rely on the value in C<$@> correctly
333corresponding to that C<eval>. (C<$@> is still also set before exiting the
334C<eval>, for the sake of destructors that rely on this.)
335
336Likewise, a C<local $@> inside an C<eval> will no longer clobber any
337exception thrown in its scope. Previously, the restoration of C<$@> upon
338unwinding would overwrite any exception being thrown. Now the exception
339gets to the C<eval> anyway. So C<local $@> is safe before a C<die>.
340
341Exceptions thrown from object destructors no longer modify the C<$@>
342of the surrounding context. (If the surrounding context was exception
343unwinding, this used to be another way to clobber the exception being
344thrown.) Previously such an exception was
345sometimes emitted as a warning, and then either was
346string-appended to the surrounding C<$@> or completely replaced the
347surrounding C<$@>, depending on whether that exception and the surrounding
348C<$@> were strings or objects. Now, an exception in this situation is
349always emitted as a warning, leaving the surrounding C<$@> untouched.
350In addition to object destructors, this also affects any function call
351performed by XS code using the C<G_KEEPERR> flag.
352
353Warnings for C<warn> can now be objects, in the same way as exceptions
354for C<die>. If an object-based warning gets the default handling,
355of writing to standard error, it is stringified as
356before, with the file and line number appended. But
357a C<$SIG{__WARN__}> handler will now receive an
358object-based warning as an object, where previously it was passed the
359result of stringifying the object.
360
361=head2 Other Enhancements
362
363=head3 Assignment to C<$0> sets the legacy process name with C<prctl()> on Linux
364
365On Linux the legacy process name will be set with L<prctl(2)>, in
366addition to altering the POSIX name via C<argv[0]> as perl has done
367since version 4.000. Now system utilities that read the legacy process
368name such as ps, top and killall will recognize the name you set when
369assigning to C<$0>. The string you supply will be cut off at 16 bytes,
370this is a limitation imposed by Linux.
371
372=head3 C<srand()> now returns the seed
373
e1b1739f
FC
374This allows programs that need to have repeatable results not to have to come
375up with their own seed-generating mechanism. Instead, they can use C<srand()>
376and stash the return value for future use. Typical is a test program which
1f539a1a 377has too many combinations to test comprehensively in the time available to it
e1b1739f 378each run. It can test a random subset each time and, should there be a failure,
1f539a1a 379log the seed used for that run so that it can later be used to reproduce the
e1b1739f 380same results.
1f539a1a
FC
381
382=head3 printf-like functions understand post-1980 size modifiers
383
384Perl's printf and sprintf operators, and Perl's internal printf replacement
385function, now understand the C90 size modifiers "hh" (C<char>), "z"
386(C<size_t>), and "t" (C<ptrdiff_t>). Also, when compiled with a C99
387compiler, Perl now understands the size modifier "j" (C<intmax_t>).
388
389So, for example, on any modern machine, C<sprintf('%hhd', 257)> returns '1'.
390
391=head3 New global variable C<${^GLOBAL_PHASE}>
5076a392
FC
392
393A new global variable, C<${^GLOBAL_PHASE}>, has been added to allow
394introspection of the current phase of the perl interpreter. It's explained in
395detail in L<perlvar/"${^GLOBAL_PHASE}"> and
396L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT and END">.
397
1f539a1a 398=head3 C<-d:-foo> calls C<Devel::foo::unimport>
5076a392
FC
399
400The syntax C<-dI<B<:>foo>> was extended in 5.6.1 to make C<-dI<:fooB<=bar>>>
401equivalent to C<-MDevel::foo=bar>, which expands
402internally to C<use Devel::foo 'bar';>.
403F<perl> now allows prefixing the module name with C<->, with the same
404semantics as C<-M>, I<i.e.>
405
406=over 4
407
408=item C<-d:-foo>
409
410Equivalent to C<-M-Devel::foo>, expands to
411C<no Devel::foo;>, calls C<< Devel::foo->unimport() >>
412if the method exists.
413
414=item C<-d:-foo=bar>
415
416Equivalent to C<-M-Devel::foo=bar>, expands to C<no Devel::foo 'bar';>,
417calls C<< Devel::foo->unimport('bar') >> if the method exists.
418
419=back
420
e1b1739f 421This is particularly useful for suppressing the default actions of a
5076a392
FC
422C<Devel::*> module's C<import> method whilst still loading it for debugging.
423
1f539a1a 424=head3 Filehandle method calls load L<IO::File> on demand
5076a392
FC
425
426When a method call on a filehandle would die because the method cannot
427be resolved, and L<IO::File> has not been loaded, Perl now loads L<IO::File>
428via C<require> and attempts method resolution again:
429
430 open my $fh, ">", $file;
431 $fh->binmode(":raw"); # loads IO::File and succeeds
432
433This also works for globs like STDOUT, STDERR and STDIN:
434
435 STDOUT->autoflush(1);
436
437Because this on-demand load only happens if method resolution fails, the
438legacy approach of manually loading an L<IO::File> parent class for partial
439method support still works as expected:
440
441 use IO::Handle;
442 open my $fh, ">", $file;
443 $fh->autoflush(1); # IO::File not loaded
444
1984204c
FC
445=head3 IPv6 support
446
447The C<Socket> module provides new affordances for IPv6,
448including implementations of the C<Socket::getaddrinfo()> and
449C<Socket::getnameinfo()> functions, along with related constants, and a
450handful of new functions. See L<Socket>.
451
1f539a1a 452=head3 DTrace probes now include package name
5076a392
FC
453
454The DTrace probes now include an additional argument (C<arg3>) which contains
455the package the subroutine being entered or left was compiled in.
456
457For example using the following DTrace script:
458
459 perl$target:::sub-entry
460 {
461 printf("%s::%s\n", copyinstr(arg0), copyinstr(arg3));
462 }
463
464and then running:
465
466 perl -e'sub test { }; test'
467
468DTrace will print:
469
470 main::test
471
9378886b
FC
472=head2 New C APIs
473
1e463951 474See L</Internal Changes>.
9378886b 475
5076a392
FC
476=head1 Security
477
948b8455 478=head2 User-defined regular expression properties
5076a392
FC
479
480In L<perlunicode/"User-Defined Character Properties">, it says you can
481create custom properties by defining subroutines whose names begin with
948b8455
FC
482"In" or "Is". However, Perl did not actually enforce that naming
483restriction, so \p{foo::bar} could call foo::bar() if it existed. Now this
484convention has been enforced.
5076a392 485
948b8455
FC
486Also, Perl no longer allows a tainted regular expression to invoke a
487user-defined. It simply dies instead [perl #82616].
5076a392
FC
488
489=head1 Incompatible Changes
490
61752d82
FC
491Perl 5.14.0 is not binary-compatible with any previous stable release.
492
1e463951
FC
493In addition to the sections that follow, see L</C API Changes>.
494
61752d82
FC
495=head2 Regular Expressions and String Escapes
496
497=head3 C<\cI<X>>
5076a392
FC
498
499The backslash-c construct was designed as a way of specifying
500non-printable characters, but there were no restrictions (on ASCII
501platforms) on what the character following the C<c> could be. Now, that
502character must be one of the ASCII characters.
503
54c7bb16 504=head3 \400-\777
5076a392 505
54c7bb16 506Use of C<\400>-C<\777> in regexes in certain circumstances has given
5076a392
FC
507different, anomalous behavior than their use in all other
508double-quote-like contexts. Since 5.10.1, a deprecated warning message
509has been raised when this happens. Now, all double-quote-like contexts
510have the same behavior, namely to be equivalent to C<\x{100}> -
511C<\x{1FF}>, with no deprecation warning. Use of these values in the
512command line option C<"-0"> retains the current meaning to slurp input
513files whole; previously, this was documented only for C<"-0777">. It is
514recommended, however, because of various ambiguities, to use the new
515C<\o{...}> construct to represent characters in octal.
5076a392 516
61752d82 517=head3 Most C<\p{}> properties are now immune to case-insensitive matching
5076a392 518
61752d82
FC
519For most Unicode properties, it doesn't make sense to have them match
520differently under C</i> case-insensitive matching than not. And doing
521so leads to unexpected results and potential security holes. For
522example
5076a392 523
61752d82 524 m/\p{ASCII_Hex_Digit}+/i
5076a392 525
61752d82
FC
526could previously match non-ASCII characters because of the Unicode
527matching rules. There were a number of bugs in this feature until an
528earlier release in the 5.13 series. Now this release reverts, and
529removes the feature completely except for the few properties where
530people have come to expect it, namely the ones where casing is an
531integral part of their functionality, such as C<m/\p{Uppercase}/i> and
532C<m/\p{Lowercase}/i>, both of which match the exact same code points,
533namely those matched by C<m/\p{Cased}/i>. Details are in
534L<perlrecharclass/Unicode Properties>.
5076a392 535
61752d82
FC
536XXX The mention of ‘until an earlier release in the 5.13 series’ needs to
537change, but I do not fully understand what happened here.
5076a392 538
61752d82
FC
539User-defined property handlers that need to match differently under
540C</i> must change to read the new boolean parameter passed to it which is
541non-zero if case-insensitive matching is in effect or 0 otherwise. See
542L<perluniprops/User-Defined Character Properties>.
5076a392 543
61752d82 544=head3 \p{} implies Unicode semantics
5076a392 545
61752d82
FC
546Now, a Unicode property match specified in the pattern will indicate
547that the pattern is meant for matching according to Unicode rules, the way
548C<\x{}> does.
5076a392 549
61752d82 550=head3 Regular expressions retain their localeness when interpolated
5076a392 551
61752d82
FC
552Regular expressions compiled under C<"use locale"> now retain this when
553interpolated into a new regular expression compiled outside a
554C<"use locale">, and vice-versa.
5076a392 555
61752d82
FC
556Previously, a regular expression interpolated into another one inherited
557the localeness of the surrounding one, losing whatever state it
558originally had. This is considered a bug fix, but may trip up code that
559has come to rely on the incorrect behavior.
5076a392 560
61752d82 561=head3 Stringification of regexes has changed
5076a392
FC
562
563Default regular expression modifiers are now notated by using
564C<(?^...)>. Code relying on the old stringification will fail. The
565purpose of this is so that when new modifiers are added, such code will
566not have to change (after this one time), as the stringification will
567automatically incorporate the new modifiers.
568
569Code that needs to work properly with both old- and new-style regexes
f318e2e6 570can avoid the whole issue by using (for Perls since 5.9.5; see L<re>):
5076a392
FC
571
572 use re qw(regexp_pattern);
573 my ($pat, $mods) = regexp_pattern($re_ref);
574
5076a392
FC
575If the actual stringification is important, or older Perls need to be
576supported, you can use something like the following:
577
578 # Accept both old and new-style stringification
579 my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? '^' : '-xism';
580
581And then use C<$modifiers> instead of C<-xism>.
582
61752d82 583=head3 Run-time code blocks in regular expressions inherit pragmata
5076a392 584
61752d82
FC
585Code blocks in regular expressions (C<(?{...})> and C<(??{...})>) used not
586to inherit any pragmata (strict, warnings, etc.) if the regular expression
587was compiled at run time as happens in cases like these two:
5076a392 588
61752d82
FC
589 use re 'eval';
590 $foo =~ $bar; # when $bar contains (?{...})
591 $foo =~ /$bar(?{ $finished = 1 })/;
592
593This was a bug, which has now been fixed. But it has the potential to break
594any code that was relying on it.
5076a392 595
61752d82 596=head2 Stashes and Package Variables
5076a392 597
61752d82 598=head3 Localised tied hashes and arrays are no longed tied
5076a392 599
61752d82 600In the following:
5076a392 601
61752d82
FC
602 tie @a, ...;
603 {
604 local @a;
605 # here, @a is a now a new, untied array
606 }
607 # here, @a refers again to the old, tied array
5076a392 608
61752d82
FC
609The new local array used to be made tied too, which was fairly pointless,
610and has now been fixed. This fix could however potentially cause a change
611in behaviour of some code.
5076a392 612
61752d82 613=head3 Stashes are now always defined
5076a392 614
61752d82
FC
615C<defined %Foo::> now always returns true, even when no symbols have yet been
616defined in that package.
5076a392 617
61752d82
FC
618This is a side effect of removing a special case kludge in the tokeniser,
619added for 5.10.0, to hide side effects of changes to the internal storage of
620hashes that drastically reduce their memory usage overhead.
621
622Calling defined on a stash has been deprecated since 5.6.0, warned on
623lexicals since 5.6.0, and warned for stashes (and other package
624variables) since 5.12.0. C<defined %hash> has always exposed an
625implementation detail - emptying a hash by deleting all entries from it does
626not make C<defined %hash> false, hence C<defined %hash> is not valid code to
627determine whether an arbitrary hash is empty. Instead, use the behaviour
628that an empty C<%hash> always returns false in a scalar context.
629
630=head3 Dereferencing typeglobs
5076a392
FC
631
632If you assign a typeglob to a scalar variable:
633
634 $glob = *foo;
635
636the glob that is copied to C<$glob> is marked with a special flag
637indicating that the glob is just a copy. This allows subsequent assignments
638to C<$glob> to overwrite the glob. The original glob, however, is
639immutable.
640
641Many Perl operators did not distinguish between these two types of globs.
642This would result in strange behaviour in edge cases: C<untie $scalar>
643would do nothing if the last thing assigned to the scalar was a glob
644(because it treated it as C<untie *$scalar>, which unties a handle).
f318e2e6 645Assignment to a glob slot (e.g., C<*$glob = \@some_array>) would simply
5076a392
FC
646assign C<\@some_array> to C<$glob>.
647
648To fix this, the C<*{}> operator (including the C<*foo> and C<*$foo> forms)
649has been modified to make a new immutable glob if its operand is a glob
650copy. Various operators that make a distinction between globs and scalars
61752d82
FC
651have been modified to treat only immutable globs as globs. (C<tie>,
652C<tied> and C<untie> has been left as they are for compatibility's sake,
653but will warn. See L</Deprecations>.)
5076a392
FC
654
655This causes an incompatible change in code that assigns a glob to the
656return value of C<*{}> when that operator was passed a glob copy. Take the
657following code, for instance:
658
659 $glob = *foo;
660 *$glob = *bar;
661
662The C<*$glob> on the second line returns a new immutable glob. That new
663glob is made an alias to C<*bar>. Then it is discarded. So the second
664assignment has no effect.
665
5076a392
FC
666The upside to this incompatible change is that bugs [perl #77496],
667[perl #77502], [perl #77508], [perl #77688], and [perl #77812],
668and maybe others, too, have been fixed.
669
670See L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for even
671more detail.
672
61752d82 673=head3 Clearing stashes
5076a392
FC
674
675Stash list assignment C<%foo:: = ()> used to make the stash anonymous
676temporarily while it was being emptied. Consequently, any of its
677subroutines referenced elsewhere would become anonymous (showing up as
678"(unknown)" in C<caller>). Now they retain their package names, such that
679C<caller> will return the original sub name if there is still a reference
680to its typeglob, or "foo::__ANON__" otherwise [perl #79208].
681
61752d82
FC
682=head3 Magic variables outside the main package
683
684In previous versions of Perl, magic variables like C<$!>, C<%SIG>, etc. would
685'leak' into other packages. So C<%foo::SIG> could be used to access signals,
686C<${"foo::!"}> (with strict mode off) to access C's C<errno>, etc.
687
688This was a bug, or an 'unintentional' feature, which caused various ill effects,
689such as signal handlers being wiped when modules were loaded, etc.
690
691This has been fixed (or the feature has been removed, depending on how you see
692it).
693
694=head2 Changes to Syntax or to Perl Operators
695
696=head3 C<given> return values
697
698C<given> blocks now return the last evaluated
699expression, or an empty list if the block was exited by C<break>. Thus you
700can now write:
701
702 my $type = do {
703 given ($num) {
704 break when undef;
705 'integer' when /^[+-]?[0-9]+$/;
706 'float' when /^[+-]?[0-9]+(?:\.[0-9]+)?$/;
707 'unknown';
708 }
709 };
710
711See L<perlsyn/Return value> for details.
712
713=head3 Change in the parsing of certain prototypes
714
715Functions declared with the following prototypes now behave correctly as unary
716functions:
717
718 *
719 \$ \% \@ \* \&
720 \[...]
721 ;$ ;*
722 ;\$ ;\% etc.
723 ;\[...]
724
725Due to this bug fix [perl #75904], functions
726using the C<(*)>, C<(;$)> and C<(;*)> prototypes
727are parsed with higher precedence than before. So in the following example:
728
729 sub foo($);
730 foo $a < $b;
731
732the second line is now parsed correctly as C<< foo($a) < $b >>, rather than
733C<< foo($a < $b) >>. This happens when one of these operators is used in
734an unparenthesised argument:
735
736 < > <= >= lt gt le ge
737 == != <=> eq ne cmp ~~
738 &
739 | ^
740 &&
741 || //
742 .. ...
743 ?:
744 = += -= *= etc.
745
746=head3 Smart-matching against array slices
747
748Previously, the following code resulted in a successful match:
749
750 my @a = qw(a y0 z);
751 my @b = qw(a x0 z);
752 @a[0 .. $#b] ~~ @b;
753
754This odd behaviour has now been fixed [perl #77468].
755
756=head3 Negation treats strings differently from before
757
758The unary negation operator C<-> now treats strings that look like numbers
759as numbers [perl #57706].
760
761=head3 Negative zero
762
763Negative zero (-0.0), when converted to a string, now becomes "0" on all
764platforms. It used to become "-0" on some, but "0" on others.
765
766If you still need to determine whether a zero is negative, use
767C<sprintf("%g", $zero) =~ /^-/> or the L<Data::Float> module on CPAN.
768
769=head3 C<:=> is now a syntax error
5076a392
FC
770
771Previously C<my $pi := 4;> was exactly equivalent to C<my $pi : = 4;>,
772with the C<:> being treated as the start of an attribute list, ending before
773the C<=>. The use of C<:=> to mean C<: => was deprecated in 5.12.0, and is now
774a syntax error. This will allow the future use of C<:=> as a new token.
775
776We find no Perl 5 code on CPAN using this construction, outside the core's
777tests for it, so we believe that this change will have very little impact on
778real-world codebases.
779
780If it is absolutely necessary to have empty attribute lists (for example,
781because of a code generator) then avoid the error by adding a space before
782the C<=>.
783
61752d82 784=head2 Threads and Processes
5076a392 785
61752d82 786=head3 Directory handles not copied to threads
5076a392 787
61752d82
FC
788On systems other than Windows that do not have
789a C<fchdir> function, newly-created threads no
790longer inherit directory handles from their parent threads. Such programs
791would usually have crashed anyway [perl #75154].
5076a392 792
61752d82 793=head3 C<close> on shared pipes
5076a392 794
61752d82
FC
795The C<close> function no longer waits for the child process to exit if the
796underlying file descriptor is still in use by another thread, to avoid
797deadlocks. It returns true in such cases.
5076a392 798
144b6ea2
FC
799=head3 fork() emulation will not wait for signalled children
800
801On Windows parent processes would not terminate until all forked
802childred had terminated first. However, C<kill('KILL', ...)> is
803inherently unstable on pseudo-processes, and C<kill('TERM', ...)>
804might not get delivered if the child if blocked in a system call.
805
806To avoid the deadlock and still provide a safe mechanism to terminate
807the hosting process, Perl will now no longer wait for children that
808have been sent a SIGTERM signal. It is up to the parent process to
809waitpid() for these children if child clean-up processing must be
810allowed to finish. However, it is also the responsibility of the
811parent then to avoid the deadlock by making sure the child process
812can't be blocked on I/O either.
813
814See L<perlfork> for more information about the fork() emulation on
815Windows.
816
61752d82 817=head2 Configuration
5076a392 818
61752d82 819=head3 Naming fixes in Policy_sh.SH may invalidate Policy.sh
5076a392 820
61752d82
FC
821Several long-standing typos and naming confusions in Policy_sh.SH have
822been fixed, standardizing on the variable names used in config.sh.
5076a392 823
61752d82
FC
824This will change the behavior of Policy.sh if you happen to have been
825accidentally relying on the Policy.sh incorrect behavior.
f318e2e6 826
5a1f7719
FC
827=head3 Perl source code is read in text mode on Windows
828
829Perl scripts used to be read in binary mode on Windows for the benefit
830of the ByteLoader module (which is no longer part of core Perl). This
831had the side effect of breaking various operations on the DATA filehandle,
832including seek()/tell(), and even simply reading from DATA after file handles
833have been flushed by a call to system(), backticks, fork() etc.
834
835The default build options for Windows have been changed to read Perl source
836code on Windows in text mode now. Hopefully ByteLoader will be updated on
837CPAN to automatically handle this situation [perl #28106].
838
5076a392
FC
839=head1 Deprecations
840
1e463951
FC
841See also L</Deprecated C APIs>.
842
5076a392
FC
843=head2 Omitting a space between a regular expression and subsequent word
844
18139a1b
FC
845Omitting a space between a regular expression operator or
846its modifiers and the following word is deprecated. For
847example, C<< m/foo/sand $bar >> will still be parsed
848as C<< m/foo/s and $bar >> but will issue a warning.
5076a392
FC
849
850=head2 Deprecation warning added for deprecated-in-core .pl libs
851
852This is a mandatory warning, not obeying -X or lexical warning bits.
853The warning is modelled on that supplied by deprecate.pm for
854deprecated-in-core .pm libraries. It points to the specific CPAN
823d0e46
FC
855distribution that contains the .pl libraries. The CPAN version, of
856course, does not generate the warning.
5076a392
FC
857
858=head2 List assignment to C<$[>
859
823d0e46
FC
860Assignment to C<$[> was deprecated and started to give warnings in
861Perl version 5.12.0. This version of perl also starts to emit a warning when
862assigning to C<$[> in list context. This fixes an oversight in 5.12.0.
5076a392
FC
863
864=head2 Use of qw(...) as parentheses
865
866Historically the parser fooled itself into thinking that C<qw(...)> literals
867were always enclosed in parentheses, and as a result you could sometimes omit
868parentheses around them:
869
870 for $x qw(a b c) { ... }
871
872The parser no longer lies to itself in this way. Wrap the list literal in
823d0e46 873parentheses, like this:
5076a392
FC
874
875 for $x (qw(a b c)) { ... }
876
877=head2 C<\N{BELL}> is deprecated
878
879This is because Unicode is using that name for a different character.
880See L</Unicode Version 6.0 is now supported (mostly)> for more
881explanation.
882
883=head2 C<?PATTERN?> is deprecated
884
885C<?PATTERN?> (without the initial m) has been deprecated and now produces
886a warning. This is to allow future use of C<?> in new operators.
887The match-once functionality is still available in the form of C<m?PATTERN?>.
888
5076a392
FC
889=head2 Tie functions on scalars holding typeglobs
890
891Calling a tie function (C<tie>, C<tied>, C<untie>) with a scalar argument
892acts on a file handle if the scalar happens to hold a typeglob.
893
894This is a long-standing bug that will be removed in Perl 5.16, as
895there is currently no way to tie the scalar itself when it holds
896a typeglob, and no way to untie a scalar that has had a typeglob
897assigned to it.
898
823d0e46 899Now there is a deprecation warning whenever a tie
5076a392
FC
900function is used on a handle without an explicit C<*>.
901
18139a1b 902=head2 User-defined case-mapping
5076a392 903
18139a1b
FC
904This feature is being deprecated due to its many issues, as documented in
905L<perlunicode/User-Defined Case Mappings (for serious hackers only)>.
906It is planned to remove this feature in Perl 5.16. A CPAN module
907providing improved functionality is being prepared for release by the
908time 5.14 is.
909
823d0e46
FC
910XXX What module is that?
911
18139a1b 912=head2 Deprecated modules
5076a392
FC
913
914The following modules will be removed from the core distribution in a
915future release, and should be installed from CPAN instead. Distributions
916on CPAN which require these should add them to their prerequisites. The
823d0e46 917core versions of these modules will issue a deprecation warning.
5076a392
FC
918
919If you ship a packaged version of Perl, either alone or as part of a
920larger system, then you should carefully consider the repercussions of
823d0e46 921core module deprecations. You may want to consider shipping your default
5076a392 922build of Perl with packages for some or all deprecated modules which
823d0e46 923install into C<vendor> or C<site> perl library directories. This will
5076a392
FC
924inhibit the deprecation warnings.
925
926Alternatively, you may want to consider patching F<lib/deprecate.pm>
927to provide deprecation warnings specific to your packaging system
928or distribution of Perl, consistent with how your packaging system
929or distribution manages a staged transition from a release where the
930installation of a single package provides the given functionality, to
931a later release where the system administrator needs to know to install
932multiple packages to get that same functionality.
933
934You can silence these deprecation warnings by installing the modules
935in question from CPAN. To install the latest version of all of them,
936just install C<Task::Deprecations::5_14>.
937
938=over
939
940=item L<Devel::DProf>
941
942We strongly recommend that you install and used L<Devel::NYTProf> in
943preference, as it offers significantly improved profiling and reporting.
944
945=back
946
5076a392
FC
947=head1 Performance Enhancements
948
54c7bb16 949=head2 "Safe signals" optimisation
df91d470
FC
950
951Signal dispatch has been moved from the runloop into control ops. This
952should give a few percent speed increase, and eliminates almost all of
953the speed penalty caused by the introduction of "safe signals" in
9545.8.0. Signals should still be dispatched within the same statement as
955they were previously - if this is not the case, or it is possible to
956create uninterruptible loops, this is a bug, and reports are encouraged
957of how to recreate such issues.
958
54c7bb16 959=head2 Optimisation of shift; and pop; calls without arguments
df91d470 960
111b6aa7
FC
961Two fewer OPs are used for shift and pop calls with no argument (with
962implicit C<@_>). This change makes C<shift;> 5% faster than C<shift @_;>
963on non-threaded perls and 25% faster on threaded.
df91d470 964
fa232254 965=head2 Optimisation of regexp engine string comparison work
df91d470 966
fa232254
FC
967The foldEQ_utf8 API function for case-insensitive comparison of strings (which
968is used heavily by the regexp engine) was substantially refactored and
969optimised - and its documentation much improved as a free bonus gift.
df91d470 970
fa232254 971=head2 Regular expression compilation speed-up
df91d470 972
fa232254
FC
973Compiling regular expressions has been made faster for the case where upgrading
974the regex to utf8 is necessary but that isn't known when the compilation begins.
df91d470 975
fa232254 976=head2 String appending is 100 times faster
df91d470 977
fa232254
FC
978When doing a lot of string appending, perl could end up allocating a lot more
979memory than needed in a very inefficient way, if perl was configured to use the
980system's C<malloc> implementation instead of its own.
981
982C<sv_grow>, which is what's being used to allocate more memory if necessary
983when appending to a string, has now been taught how to round up the memory
984it requests to a certain geometric progression, making it much faster on
985certain platforms and configurations. On Win32, it's now about 100 times
986faster.
987
988=head2 Eliminate C<PL_*> accessor functions under ithreads
989
990When C<MULTIPLICITY> was first developed, and interpreter state moved into
991an interpreter struct, thread and interpreter local C<PL_*> variables were
992defined as macros that called accessor functions, returning the address of
993the value, outside of the perl core. The intent was to allow members
994within the interpreter struct to change size without breaking binary
995compatibility, so that bug fixes could be merged to a maintenance branch
996that necessitated such a size change.
997
998However, some non-core code defines C<PERL_CORE>, sometimes intentionally
999to bypass this mechanism for speed reasons, sometimes for other reasons but
1000with the inadvertent side effect of bypassing this mechanism. As some of
1001this code is widespread in production use, the result is that the core
1002I<can't> change the size of members of the interpreter struct, as it will
1003break such modules compiled against a previous release on that maintenance
1004branch. The upshot is that this mechanism is redundant, and well-behaved
1005code is penalised by it. Hence it can and should be removed (and has
1006been).
1007
1008=head2 Freeing weak references
1009
1010When an object has many weak references to it, freeing that object
1011can under some some circumstances take O(N^2) time to free (where N is the
1012number of references). The number of circumstances has been reduced
1013[perl #75254]
1014
1015=head2 Lexical array and hash assignments
1016
1017An earlier optimisation to speed up C<my @array = ...> and
1018C<my %hash = ...> assignments caused a bug and was disabled in Perl 5.12.0.
1019
1020Now we have found another way to speed up these assignments [perl #82110].
df91d470 1021
111b6aa7 1022=head2 C<@_> uses less memory
df91d470 1023
111b6aa7
FC
1024Previously, C<@_> was allocated for every subroutine at compile time with
1025enough space for four entries. Now this allocation is done on demand when
1026the subroutine is called [perl #72416].
5076a392 1027
5076a392
FC
1028=head2 Size optimisations to SV and HV structures
1029
1030xhv_fill has been eliminated from struct xpvhv, saving 1 IV per hash and
111b6aa7 1031on some systems will cause struct xpvhv to become cache-aligned. To avoid
5076a392
FC
1032this memory saving causing a slowdown elsewhere, boolean use of HvFILL
1033now calls HvTOTALKEYS instead (which is equivalent) - so while the fill
111b6aa7
FC
1034data when actually required are now calculated on demand, the cases when
1035this needs to be done should be few and far between.
5076a392 1036
111b6aa7
FC
1037The order of structure elements in SV bodies has changed. Effectively,
1038the NV slot has swapped location with STASH and MAGIC. As all access to
1039SV members is via macros, this should be completely transparent. This
5076a392
FC
1040change allows the space saving for PVHVs documented above, and may reduce
1041the memory allocation needed for PVIVs on some architectures.
1042
fa232254
FC
1043C<XPV>, C<XPVIV>, and C<XPVNV> now only allocate the parts of the C<SV> body
1044they actually use, saving some space.
5076a392 1045
fa232254
FC
1046Scalars containing regular expressions now only allocate the part of the C<SV>
1047body they actually use, saving some space.
5076a392
FC
1048
1049=head2 Memory consumption improvements to Exporter
1050
1051The @EXPORT_FAIL AV is no longer created unless required, hence neither is
111b6aa7
FC
1052the typeglob backing it. This saves about 200 bytes for every package that
1053uses Exporter but doesn't use this functionality.
5076a392 1054
111b6aa7 1055=head2 Memory savings for weak references
5076a392
FC
1056
1057For weak references, the common case of just a single weak reference per
1058referent has been optimised to reduce the storage required. In this case it
111b6aa7 1059saves the equivalent of one small Perl array per referent.
5076a392 1060
111b6aa7 1061=head2 C<%+> and C<%-> use less memory
5076a392
FC
1062
1063The bulk of the C<Tie::Hash::NamedCapture> module used to be in the perl
111b6aa7 1064core. It has now been moved to an XS module, to reduce the overhead for
5076a392
FC
1065programs that do not use C<%+> or C<%->.
1066
fa232254 1067=head2 Multiple small improvements to threads
5076a392 1068
fa232254
FC
1069The internal structures of threading now make fewer API calls and fewer
1070allocations, resulting in noticeably smaller object code. Additionally,
1071many thread context checks have been deferred so that they're only done
1072when required (although this is only possible for non-debugging builds).
5076a392 1073
fa232254 1074=head2 Adjacent pairs of nextstate opcodes are now optimized away
5076a392 1075
fa232254 1076Previously, in code such as
5076a392 1077
fa232254 1078 use constant DEBUG => 0;
5076a392 1079
fa232254
FC
1080 sub GAK {
1081 warn if DEBUG;
1082 print "stuff\n";
1083 }
5076a392 1084
fa232254
FC
1085the ops for C<warn if DEBUG;> would be folded to a C<null> op (C<ex-const>), but
1086the C<nextstate> op would remain, resulting in a runtime op dispatch of
1087C<nextstate>, C<nextstate>, ....
5076a392 1088
fa232254
FC
1089The execution of a sequence of C<nextstate> ops is indistinguishable from just
1090the last C<nextstate> op so the peephole optimizer now eliminates the first of
1091a pair of C<nextstate> ops, except where the first carries a label, since labels
1092must not be eliminated by the optimizer and label usage isn't conclusively known
1093at compile time.
5076a392
FC
1094
1095=head1 Modules and Pragmata
1096
1097=head2 New Modules and Pragmata
1098
1099=over 4
1100
1101=item *
1102
1103C<CPAN::Meta::YAML> 0.003 has been added as a dual-life module. It supports a
1104subset of YAML sufficient for reading and writing META.yml and MYMETA.yml files
1105included with CPAN distributions or generated by the module installation
1106toolchain. It should not be used for any other general YAML parsing or
1107generation task.
1108
1109=item *
1110
1111C<CPAN::Meta> version 2.110440 has been added as a dual-life module. It
1112provides a standard library to read, interpret and write CPAN distribution
1113metadata files (e.g. META.json and META.yml) which describes a
1114distribution, its contents, and the requirements for building it and
1115installing it. The latest CPAN distribution metadata specification is
1116included as C<CPAN::Meta::Spec> and notes on changes in the specification
1117over time are given in C<CPAN::Meta::History>.
1118
1119=item *
1120
1121C<HTTP::Tiny> 0.010 has been added as a dual-life module. It is a very
1122small, simple HTTP/1.1 client designed for simple GET requests and file
1123mirroring. It has has been added to enable CPAN.pm and CPANPLUS to
1124"bootstrap" HTTP access to CPAN using pure Perl without relying on external
1125binaries like F<curl> or F<wget>.
1126
1127=item *
1128
1129C<JSON::PP> 2.27105 has been added as a dual-life module, for the sake of
1130reading F<META.json> files in CPAN distributions.
1131
1132=item *
1133
1134C<Module::Metadata> 1.000003 has been added as a dual-life module. It gathers
1135package and POD information from Perl module files. It is a standalone module
1136based on Module::Build::ModuleInfo for use by other module installation
1137toolchain components. Module::Build::ModuleInfo has been deprecated in
1138favor of this module instead.
1139
1140=item *
1141
1142C<Perl::OSType> 1.002 has been added as a dual-life module. It maps Perl
1143operating system names (e.g. 'dragonfly' or 'MSWin32') to more generic types
1144with standardized names (e.g. "Unix" or "Windows"). It has been refactored
1145out of Module::Build and ExtUtils::CBuilder and consolidates such mappings into
1146a single location for easier maintenance.
1147
1148=item *
1149
1150The following modules were added by the C<Unicode::Collate>
1151upgrade. See below for details.
1152
1153C<Unicode::Collate::CJK::Big5>
1154
1155C<Unicode::Collate::CJK::GB2312>
1156
1157C<Unicode::Collate::CJK::JISX0208>
1158
1159C<Unicode::Collate::CJK::Korean>
1160
1161C<Unicode::Collate::CJK::Pinyin>
1162
1163C<Unicode::Collate::CJK::Stroke>
1164
1165=item *
1166
1167C<Version::Requirements> version 0.101020 has been added as a dual-life
1168module. It provides a standard library to model and manipulates module
1169prerequisites and version constraints as defined in the L<CPAN::Meta::Spec>.
1170
1171=back
1172
d622514a 1173=head2 Selected Module and Pragma Updates
5076a392
FC
1174
1175=over 4
1176
1177=item *
1178
5076a392
FC
1179C<Archive::Extract> has been upgraded from version 0.38 to 0.48.
1180
1181Updates since 0.38 include: a safe print method that guards
1182Archive::Extract from changes to $\; a fix to the tests when run in core
1984204c
FC
1183perl; support for TZ files; a modification for the lzma
1184logic to favour IO::Uncompress::Unlzma; and a fix
1185for an issue with NetBSD-current and its new unzip
5076a392
FC
1186executable.
1187
1188=item *
1189
1190C<Archive::Tar> has been upgraded from version 1.54 to 1.76.
1191
1984204c
FC
1192Important changes since 1.54 include the following:
1193
1194=over
1195
1196=item *
1197
1198Compatibility with busybox implementations of tar
1199
1200=item *
1201
1202A fix so that C<write()> and C<create_archive()>
1203close only handles they opened
1204
1205=item *
1206
1207A bug was fixed regarding the exit code of extract_archive.
5076a392 1208
1984204c
FC
1209=item *
1210
1211C<ptar> has a new option to allow safe
5076a392
FC
1212creation of tarballs without world-writable files on Windows, allowing those
1213archives to be uploaded to CPAN.
1214
1984204c
FC
1215=item *
1216
1217A new ptargrep utility for using regular expressions against
5076a392
FC
1218the contents of files in a tar archive.
1219
1984204c
FC
1220=item *
1221
1222Pax extended headers are now skipped.
1223
1224=back
5076a392
FC
1225
1226=item *
1227
5076a392
FC
1228C<B> has been upgraded from version 1.23 to 1.27.
1229
1230It no longer crashes when taking apart a C<y///> containing characters
1231outside the octet range or compiled in a C<use utf8> scope.
1232
1233The size of the shared object has been reduced by about 40%, with no
1234reduction in functionality.
1235
1236=item *
1237
1238C<B::Concise> has been upgraded from version 0.78 to 0.82.
1239
1240B::Concise marks rv2sv, rv2av and rv2hv ops with the new OPpDEREF flag
1241as "DREFed".
1242
1243It no longer produces mangled output with the C<-tree> option
1244[perl #80632].
1245
1246=item *
1247
5076a392
FC
1248C<B::Deparse> has been upgraded from version 0.96 to 1.02.
1249
1984204c 1250The deparsing of a nextstate op has changed when it has both a
5076a392
FC
1251change of package (relative to the previous nextstate), or a change of
1252C<%^H> or other state, and a label. Previously the label was emitted
1984204c 1253first, but now the label is emitted last.
5076a392 1254
1984204c 1255The C<no 5.13.2> or similar form is now correctly handled by B::Deparse.
5076a392
FC
1256
1257B::Deparse now properly handles the code that applies a conditional
1258pattern match against implicit C<$_> as it was fixed in [perl #20444].
1259
1984204c
FC
1260Deparsing of C<our> followed by a variable with funny characters
1261(as permitted under the C<utf8> pragma) has also been fixed [perl #33752].
5076a392
FC
1262
1263=item *
1264
5076a392
FC
1265C<Carp> has been upgraded from version 1.18 to 1.19.
1266
1267L<Carp> now detects incomplete L<caller()|perlfunc/"caller EXPR"> overrides and
1268avoids using bogus C<@DB::args>. To provide backtraces, Carp relies on
1269particular behaviour of the caller built-in. Carp now detects if other code has
1270overridden this with an incomplete implementation, and modifies its backtrace
1271accordingly. Previously incomplete overrides would cause incorrect values in
1272backtraces (best case), or obscure fatal errors (worst case)
1273
1274This fixes certain cases of C<Bizarre copy of ARRAY> caused by modules
1275overriding C<caller()> incorrectly.
1276
1984204c 1277It now also avoids using regular expressions that cause perl to
5076a392
FC
1278load its Unicode tables, in order to avoid the 'BEGIN not safe after
1279errors' error that will ensue if there has been a syntax error
1280[perl #82854].
1281
1282=item *
1283
1284C<CGI> has been upgraded from version 3.48 to 3.51.
1285
1286This provides the following security fixes: the MIME boundary in
1984204c
FC
1287multipart_init is now random and the handling of
1288newlines embedded in header values has been improved.
5076a392
FC
1289
1290=item *
1291
5076a392
FC
1292C<Compress::Raw::Bzip2> has been upgraded from version 2.024 to 2.033.
1293
1984204c 1294It has been updated to use bzip2 1.0.6.
5076a392
FC
1295
1296=item *
1297
1984204c
FC
1298C<CPAN> has been upgraded from version 1.94_56 to 1.9600.-
1299
1300Major highlights:
5076a392
FC
1301
1302=over 4
1303
1984204c 1304=item * much less configuration dialog hassle
5076a392 1305
1984204c 1306=item * support for META/MYMETA.json
5076a392 1307
1984204c 1308=item * support for local::lib
5076a392 1309
1984204c 1310=item * support for HTTP::Tiny to reduce the dependency on ftp sites
5076a392 1311
1984204c 1312=item * automatic mirror selection
5076a392 1313
1984204c 1314=item * iron out all known bugs in configure_requires
5076a392 1315
1984204c
FC
1316=item * support for distributions compressed with bzip2
1317
1318=item * allow Foo/Bar.pm on the commandline to mean Foo::Bar
1319
1320=back
5076a392
FC
1321
1322=item *
1323
1324C<CPANPLUS> has been upgraded from version 0.90 to 0.9102.
1325
1984204c
FC
1326A dependency on Config was not recognised as a
1327core module dependency. This has been fixed.
5076a392 1328
1984204c 1329CPANPLUS now includes support for META.json and MYMETA.json.
5076a392
FC
1330
1331=item *
1332
5076a392
FC
1333C<Data::Dumper> has been upgraded from version 2.125 to 2.130_02.
1334
4ed2cea4
FC
1335The indentation used to be off when C<$Data::Dumper::Terse> was set. This
1336has been fixed [perl #73604].
1337
1984204c
FC
1338This upgrade also fixes a crash when using custom sort functions that might
1339cause the stack to change [perl #74170].
5076a392
FC
1340
1341C<Dumpxs> no longer crashes with globs returned by C<*$io_ref>
1342[perl #72332].
1343
1344=item *
1345
5076a392
FC
1346C<Devel::DProf> has been upgraded from version 20080331.00 to 20110228.00.
1347
1348Merely loading C<Devel::DProf> now no longer triggers profiling to start.
1349C<use Devel::DProf> and C<perl -d:DProf ...> still behave as before and start
1350the profiler.
1351
1352NOTE: C<Devel::DProf> is deprecated and will be removed from a future
1984204c 1353version of Perl. We strongly recommend that you install and use
5076a392
FC
1354L<Devel::NYTProf> instead, as it offers significantly improved
1355profiling and reporting.
1356
1357=item *
1358
5076a392
FC
1359C<diagnostics> has been upgraded from version 1.19 to 1.22.
1360
1361It now renders pod links slightly better, and has been taught to find
1362descriptions for messages that share their descriptions with other
1363messages.
1364
1365=item *
1366
1367C<Digest::MD5> has been upgraded from version 2.39 to 2.51.
1368
1369It is now safe to use this module in combination with threads.
1370
1371=item *
1372
1373C<Digest::SHA> has been upgraded from version 5.47 to 5.61.
1374
1375C<shasum> now more closely mimics C<sha1sum>/C<md5sum>.
1376
1377C<Addfile> accepts all POSIX filenames.
1378
1984204c
FC
1379New SHA-512/224 and SHA-512/256 transforms (ref. NIST Draft FIPS 180-4
1380[February 2011])
5076a392
FC
1381
1382=item *
1383
5076a392
FC
1384C<DynaLoader> has been upgraded from version 1.10 to 1.12.
1385
1386It fixes a buffer overflow when passed a very long file name.
1387
1388It no longer inherits from AutoLoader; hence it no longer
1389produces weird error messages for unsuccessful method calls on classes that
1390inherit from DynaLoader [perl #84358].
1391
1392=item *
1393
1394C<Encode> has been upgraded from version 2.39 to 2.42.
1395
1396Now, all 66 Unicode non-characters are treated the same way U+FFFF has
1984204c
FC
1397always been treated; in cases when it was disallowed, all 66 are
1398disallowed; in those cases where it warned, all 66 warn.
5076a392
FC
1399
1400=item *
1401
5076a392
FC
1402C<Errno> has been upgraded from version 1.11 to 1.13.
1403
1404The implementation of C<Errno> has been refactored to use about 55% less memory.
5076a392
FC
1405
1406On some platforms with unusual header files, like Win32/gcc using mingw64
1407headers, some constants which weren't actually error numbers have been exposed
1408by C<Errno>. This has been fixed [perl #77416].
1409
1410=item *
1411
1412C<Exporter> has been upgraded from version 5.64_01 to 5.64_03.
1413
1414Exporter no longer overrides C<$SIG{__WARN__}> [perl #74472]
1415
1416=item *
1417
5076a392
FC
1418C<ExtUtils::Constant> has been upgraded from 0.22 to 0.23.
1419
1420The C<AUTOLOAD> helper code generated by C<ExtUtils::Constant::ProxySubs>
1421can now C<croak> for missing constants, or generate a complete C<AUTOLOAD>
1984204c
FC
1422subroutine in XS, allowing simplification of many modules that use it
1423(C<Fcntl>, C<File::Glob>, C<GDBM_File>, C<I18N::Langinfo>, C<POSIX>,
1424C<Socket>).
5076a392
FC
1425
1426C<ExtUtils::Constant::ProxySubs> can now optionally push the names of all
1984204c 1427constants onto the package's C<@EXPORT_OK>.
5076a392
FC
1428
1429=item *
1430
5076a392
FC
1431C<File::DosGlob> has been upgraded from version 1.01 to 1.03.
1432
1433It allows patterns containing literal parentheses (they no longer need to
1984204c
FC
1434be escaped). On Windows, it no longer
1435adds an extra F<./> to the file names
5076a392
FC
1436returned when the pattern is a relative glob with a drive specification,
1437like F<c:*.pl> [perl #71712].
1438
1439=item *
1440
1441C<File::Fetch> has been upgraded from version 0.24 to 0.32.
1442
1443C<HTTP::Lite> is now supported for 'http' scheme.
1444
1445The C<fetch> utility is supported on FreeBSD, NetBSD and
1446Dragonfly BSD for the C<http> and C<ftp> schemes.
1447
1448=item *
1449
1450C<File::Find> has been upgraded from version 1.15 to 1.18.
1451
1984204c 1452It improves handling of backslashes on Windows, so that paths like
5076a392
FC
1453F<c:\dir\/file> are no longer generated [perl #71710].
1454
1455=item *
1456
5076a392
FC
1457C<File::stat> has been upgraded from 1.02 to 1.04.
1458
1459The C<-x> and C<-X> file test operators now work correctly under the root
1460user.
1461
1462=item *
1463
5076a392
FC
1464C<GDBM_File> has been upgraded from 1.10 to 1.13.
1465
1466This fixes a memory leak when DBM filters are used.
1467
1468=item *
1469
1470C<Hash::Util> has been upgraded from 0.07 to 0.10.
1471
1984204c
FC
1472Hash::Util no longer emits spurious "uninitialized" warnings when
1473recursively locking hashes that have undefined values [perl #74280].
5076a392
FC
1474
1475=item *
1476
1477C<I18N::Langinfo> has been upgraded from version 0.03 to 0.07.
1478
1479C<langinfo()> now defaults to using C<$_> if there is no argument given, just
5334145a 1480as the documentation has always claimed.
5076a392
FC
1481
1482=item *
1483
1484C<IO::Select> has been upgraded from version 1.17 to 1.18.
1485
1486It now allows IO::Handle objects (and objects in derived classes) to be
1487removed from an IO::Select set even if the underlying file descriptor is
1488closed or invalid.
1489
1490=item *
1491
5076a392
FC
1492C<IPC::Cmd> has been upgraded from version 0.54 to 0.68.
1493
1984204c
FC
1494Resolves an issue with splitting Win32 command lines. An argument
1495consisting of the single character "0" used to be omitted (CPAN RT #62961).
5076a392
FC
1496
1497=item *
1498
1499C<IPC::Open3> has been upgraded from 1.05 to 1.08.
1500
4ed2cea4
FC
1501C<open3> now produces an error if the C<exec> call fails, allowing this
1502condition to be distinguished from a child process that exited with a
1503non-zero status [perl #72016].
1504
5076a392
FC
1505The internal C<xclose> routine now knows how to handle file descriptors, as
1506documented, so duplicating STDIN in a child process using its file
1507descriptor now works [perl #76474].
1508
1509=item *
1510
5076a392
FC
1511C<Locale::Maketext> has been upgraded from version 1.14 to 1.17.
1512
1984204c 1513Locale::Maketext now supports external caches.
5076a392 1514
1984204c
FC
1515This upgrade also fixes an infinite loop in
1516C<Locale::Maketext::Guts::_compile()> when
5076a392
FC
1517working with tainted values (CPAN RT #40727).
1518
1984204c 1519C<< ->maketext >> calls will now back up and restore C<$@> so that error
5076a392
FC
1520messages are not suppressed (CPAN RT #34182).
1521
1522=item *
1523
5076a392
FC
1524C<Math::BigInt> has been upgraded from version 1.89_01 to 1.994.
1525
1526This fixes, among other things, incorrect results when computing binomial
1527coefficients [perl #77640].
1528
1984204c 1529It also prevents C<sqrt($int)> from crashing under C<use bigrat;>
5076a392
FC
1530[perl #73534].
1531
1532=item *
1533
5076a392
FC
1534C<MIME::Base64> has been upgraded from 3.08 to 3.13.
1535
1536Includes new functions to calculate the length of encoded and decoded
1537base64 strings.
1538
1539Now provides C<encode_base64url> and C<decode_base64url> functions to process
1540the base64 scheme for "URL applications".
1541
1542=item *
1543
1544C<Module::Build> has been upgraded from version 0.3603 to 0.3800.
1545
1546A notable change is the deprecation of several modules.
1547Module::Build::Version has been deprecated and Module::Build now relies
1548directly upon L<version>. Module::Build::ModuleInfo has been deprecated in
1549favor of a standalone copy of it called L<Module::Metadata>.
1550Module::Build::YAML has been deprecated in favor of L<CPAN::Meta::YAML>.
1551
1552Module::Build now also generates META.json and MYMETA.json files
1553in accordance with version 2 of the CPAN distribution metadata specification,
1554L<CPAN::Meta::Spec>. The older format META.yml and MYMETA.yml files are
1555still generated, as well.
1556
1557=item *
1558
1559C<Module::CoreList> has been upgraded from version 2.29 to XXX.
1560
1561Besides listing the updated core modules of this release, it also stops listing
1984204c 1562the C<Filespec> module. That module never existed in core. The scripts
5076a392 1563generating C<Module::CoreList> confused it with C<VMS::Filespec>, which actually
1984204c 1564is a core module as of perl 5.8.7.
5076a392
FC
1565
1566=item *
1567
1984204c
FC
1568C<NDBM_File> and C<ODBM_File> have been upgraded from 1.08 to 1.11, and
1569from 1.08 to 1.09, respectively.
5076a392
FC
1570
1571This fixes a memory leak when DBM filters are used.
1572
1573=item *
1574
5076a392
FC
1575C<overload> has been upgraded from 1.11 to 1.12.
1576
1577C<overload::Method> can now handle subroutines that are themselves blessed
1578into overloaded classes [perl #71998].
1579
5076a392
FC
1580The documentation has greatly improved. See L</Documentation> below.
1581
1582=item *
1583
5076a392
FC
1584C<Parse::CPAN::Meta> has been upgraded from version 1.40 to 1.4401.
1585
1984204c 1586The latest Parse::CPAN::Meta can now read YAML and JSON files using
5076a392
FC
1587L<CPAN::Meta::YAML> and L<JSON::PP>, which are now part of the Perl core.
1588
1589=item *
1590
5076a392
FC
1591C<PerlIO::scalar> has been upgraded from 0.07 to 0.11.
1592
1593A C<read> after a C<seek> beyond the end of the string no longer thinks it
1594has data to read [perl #78716].
1595
1596=item *
1597
5076a392
FC
1598C<POSIX> has been upgraded from 1.19 to 1.23.
1599
1600It now includes constants for POSIX signal constants.
1601
1602=item *
1603
1984204c 1604C<re> has been upgraded from version 0.11 to 0.17.
5076a392
FC
1605
1606New C<use re "/flags"> pragma
1607
5076a392 1608The C<regmust> function used to crash when called on a regular expression
1984204c 1609belonging to a pluggable engine. Now it croaks instead.
5076a392
FC
1610
1611C<regmust> no longer leaks memory.
1612
1613=item *
1614
1615C<Safe> has been upgraded from version 2.25 to 2.29.
1616
1617This fixes a possible infinite loop when looking for coderefs.
1618
1619It adds C<&version::vxs::VCMP> to the default share.
1620
1621=item *
1622
5076a392
FC
1623C<SelfLoader> has been upgraded from 1.17 to 1.18.
1624
1625It now works in taint mode [perl #72062].
1626
1627=item *
1628
1629C<sigtrap> has been upgraded from version 1.04 to 1.05.
1630
1631It no longer tries to modify read-only arguments when generating a
1632backtrace [perl #72340].
1633
1634=item *
1635
1984204c 1636C<Socket> has been upgraded from version 1.87 to 1.94.
5076a392 1637
1984204c 1638See L</IPv6 support>, above.
5076a392
FC
1639
1640=item *
1641
1642C<Storable> has been upgraded from version 2.22 to 2.27.
1643
1644Includes performance improvement for overloaded classes.
1645
5076a392 1646This adds support for serialising code references that contain UTF-8 strings
1984204c
FC
1647correctly. The Storable minor version
1648number changed as a result, meaning that
5076a392
FC
1649Storable users who set C<$Storable::accept_future_minor> to a C<FALSE> value
1650will see errors (see L<Storable/FORWARD COMPATIBILITY> for more details).
1651
1652Freezing no longer gets confused if the Perl stack gets reallocated
1653during freezing [perl #80074].
1654
1655=item *
1656
5076a392
FC
1657C<Test::Simple> has been upgraded from version 0.94 to 0.98.
1658
1659Among many other things, subtests without a C<plan> or C<no_plan> now have an
1660implicit C<done_testing()> added to them.
1661
1662=item *
1663
5076a392
FC
1664C<Thread::Semaphore> has been upgraded from version 2.09 to 2.12.
1665
1984204c
FC
1666It provides two new methods that give more control over the decrementing of
1667semaphores: C<down_nb> and C<down_force>.
5076a392
FC
1668
1669=item *
1670
5076a392
FC
1671C<Tie::Hash> has been upgraded from version 1.03 to 1.04.
1672
1673Calling C<< Tie::Hash-E<gt>TIEHASH() >> used to loop forever. Now it C<croak>s.
1674
1675=item *
1676
5076a392
FC
1677C<Unicode::Collate> has been upgraded from version 0.52_01 to 0.73.
1678
1984204c 1679Unicode::Collate has been updated to use Unicode 6.0.0.
5076a392 1680
1984204c
FC
1681Unicode::Collate::Locale now supports a plethora of new locales: ar, be,
1682bg, de__phonebook, hu, hy, kk, mk, nso, om, tn, vi, hr, ig, ja, ko, ru, sq,
1683se, sr, to, uk, zh, zh__big5han, zh__gb2312han, zh__pinyin and zh__stroke.
5076a392
FC
1684
1685The following modules have been added:
1686
1687C<Unicode::Collate::CJK::Big5> for C<zh__big5han> which makes
1688tailoring of CJK Unified Ideographs in the order of CLDR's big5han ordering.
1689
1690C<Unicode::Collate::CJK::GB2312> for C<zh__gb2312han> which makes
1691tailoring of CJK Unified Ideographs in the order of CLDR's gb2312han ordering.
1692
1693C<Unicode::Collate::CJK::JISX0208> which makes tailoring of 6355 kanji
1694(CJK Unified Ideographs) in the JIS X 0208 order.
1695
1696C<Unicode::Collate::CJK::Korean> which makes tailoring of CJK Unified Ideographs
1697in the order of CLDR's Korean ordering.
1698
1699C<Unicode::Collate::CJK::Pinyin> for C<zh__pinyin> which makes
1700tailoring of CJK Unified Ideographs in the order of CLDR's pinyin ordering.
1701
1702C<Unicode::Collate::CJK::Stroke> for C<zh__stroke> which makes
1703tailoring of CJK Unified Ideographs in the order of CLDR's stroke ordering.
1704
5076a392
FC
1705This also sees the switch from using the pure-perl version of this
1706module to the XS version.
1707
1708=item *
1709
5076a392
FC
1710C<Unicode::UCD> has been upgraded from version 0.27 to 0.32.
1711
1984204c
FC
1712A new function, C<Unicode::UCD::num()>, has been added. This function
1713returns the numeric value of the string passed it or C<undef> if the string
1714in its entirety has no "safe" numeric value. (For more detail, and for the
1715definition of "safe", see L<Unicode::UCD/num>.)
5076a392 1716
1984204c 1717This upgrade also includes a number of bug fixes:
5076a392
FC
1718
1719=over 4
1720
1721=item charinfo()
1722
1723=over 4
1724
1725=item *
1726
1727It is now updated to Unicode Version 6 with Corrigendum #8, except,
1728as with Perl 5.14, the code point at U+1F514 has no name.
1729
1730=item *
1731
1732The Hangul syllable code points have the correct names, and their
1733decompositions are always output without requiring L<Lingua::KO::Hangul::Util>
1734to be installed.
1735
1736=item *
1737
54c7bb16
FC
1738The CJK (Chinese-Japanese-Korean) code points U+2A700 to U+2B734
1739and U+2B740 to U+2B81D are now properly handled.
5076a392
FC
1740
1741=item *
1742
1743The numeric values are now output for those CJK code points that have them.
1744
1745=item *
1746
1747The names that are output for code points with multiple aliases are now the
1748corrected ones.
1749
1750=back
1751
1752=item charscript()
1753
1754This now correctly returns "Unknown" instead of C<undef> for the script
1755of a code point that hasn't been assigned another one.
1756
1757=item charblock()
1758
1759This now correctly returns "No_Block" instead of C<undef> for the block
1760of a code point that hasn't been assigned to another one.
1761
1762=back
1763
5076a392
FC
1764=item *
1765
1766C<version> has been upgraded from 0.82 to 0.88.
1767
1984204c
FC
1768Due to a bug, now fixed, the C<is_strict> and C<is_lax> functions did not
1769work when exported.
5076a392
FC
1770
1771=item *
1772
1773C<warnings> and C<warnings::register> have been upgraded from version 1.09
1774to 1.11 and from version 1.01 to 1.02 respectively.
1775
1776Calling C<use warnings> without arguments is now significantly more efficient.
1777
1778It is now possible to register warning categories other than the names of
1779packages using C<warnings::register>. See L<perllexwarn> for more information.
1780
1781=item *
1782
1783C<VMS::DCLsym> has been upgraded from version 1.03 to 1.05.
1784
1785Two bugs have been fixed [perl #84086]:
1786
1787The symbol table name was lost when tying a hash, due to a thinko in
1788C<TIEHASH>. The result was that all tied hashes interacted with the
1789local symbol table.
1790
1791Unless a symbol table name had been explicitly specified in the call
1792to the constructor, querying the special key ':LOCAL' failed to
1793identify objects connected to the local symbol table.
1794
1795=item *
1796
1797C<Win32> has been upgraded from version 0.39 to 0.44.
1798
1984204c
FC
1799This release has several new functions: C<Win32::GetSystemMetrics>,
1800C<Win32::GetProductInfo>, C<Win32::GetOSDisplayName>.
5076a392 1801
1984204c
FC
1802The names returned by C<Win32::GetOSName> and C<Win32::GetOSDisplayName>
1803have been corrected.
5076a392 1804
5076a392
FC
1805=back
1806
5076a392
FC
1807=head2 Removed Modules and Pragmata
1808
1809The following modules have been removed from the core distribution, and if
1810needed should be installed from CPAN instead.
1811
1812=over
1813
1814=item C<Class::ISA>
1815
1816=item C<Pod::Plainer>
1817
1818=item C<Switch>
1819
1820=back
1821
1822The removal of C<Shell> has been deferred until after 5.14, as the
1823implementation of C<Shell> shipped with 5.12.0 did not correctly issue the
1824warning that it was to be removed from core.
1825
1826=head1 Documentation
1827
5076a392
FC
1828=head2 New Documentation
1829
41e29def 1830=head3 L<perlgpl>
5076a392
FC
1831
1832L<perlgpl> has been updated to contain GPL version 1, as is included in the
1833F<README> distributed with perl.
1834
41e29def 1835=head3 Perl 5.12.x delta files
5076a392 1836
41e29def
FC
1837The perldelta files for Perl 5.12.1 to 5.12.3 have been added from the
1838maintenance branch: L<perl5121delta>, L<perl5122delta>, L<perl5123delta>.
5076a392
FC
1839
1840=head3 L<perlpodstyle>
1841
1842New style guide for POD documentation,
1843split mostly from the NOTES section of the pod2man man page.
1844
41e29def
FC
1845=head3 L<perlsource>, L<perlinterp>, L<perlhacktut>, and L<perlhacktips>
1846
1847See L</L<perlhack> and perlrepository revamp>, below.
5076a392
FC
1848
1849=head2 Changes to Existing Documentation
1850
41e29def 1851=head3 L<perlmodlib> is now complete
4ed2cea4
FC
1852
1853The perlmodlib page that came with Perl 5.12.0 was missing a lot of
1854modules, due to a bug in the script that generates the list. This has been
1855fixed [perl #74332].
1856
41e29def 1857=head3 Replace wrong tr/// table in L<perlebcdic>
5076a392 1858
41e29def 1859L<perlebcdic> contains a helpful table to use in tr/// to convert
5076a392
FC
1860between EBCDIC and Latin1/ASCII. Unfortunately, the table was the
1861inverse of the one it describes, though the code that used the table
1862worked correctly for the specific example given.
1863
1864The table has been changed to its inverse, and the sample code changed
1865to correspond, as this is easier for the person trying to follow the
1866instructions since deriving the old table is somewhat more complicated.
1867
1868The table has also been changed to hex from octal, as that is more the norm
1869these days, and the recipes in the pod altered to print out leading
41e29def 1870zeros to make all the values the same length.
5076a392 1871
41e29def 1872=head3 Tricks for user-defined casing
5076a392 1873
41e29def
FC
1874L<perlunicode> now contains an explanation of how to override, mangle
1875and otherwise tweak the way perl handles upper-, lower- and other-case
1876conversions on Unicode data, and how to provide scoped changes to alter
1877one's own code's behaviour without stomping on anybody else.
5076a392
FC
1878
1879=head3 INSTALL explicitly states the requirement for C89
1880
41e29def 1881This was already true but it's now Officially Stated For The Record.
5076a392 1882
41e29def 1883=head3 Explanation of C<\xI<HH>> and C<\oI<OOO>> escapes
5076a392 1884
41e29def
FC
1885L<perlop> has been updated with more detailed explanation of these two
1886character escapes.
5076a392 1887
41e29def 1888=head3 C<-0I<NNN>> switch
5076a392 1889
41e29def
FC
1890In L<perlrun>, the behavior of the C<-0NNN> switch for C<-0400> or higher
1891has been clarified.
5076a392 1892
41e29def 1893=head3 Deprecation policy
5076a392 1894
41e29def
FC
1895L<perlpolicy> now contains the policy on compatibility and deprecation
1896along with definitions of terms like "deprecation"
5076a392 1897
41e29def 1898=head3 New descriptions in L<perldiag>
5076a392
FC
1899
1900The following existing diagnostics are now documented:
1901
1902=over 4
1903
1904=item *
1905
1906L<Ambiguous use of %c resolved as operator %c|perldiag/"Ambiguous use of %c resolved as operator %c">
1907
1908=item *
1909
1910L<Ambiguous use of %c{%s} resolved to %c%s|perldiag/"Ambiguous use of %c{%s} resolved to %c%s">
1911
1912=item *
1913
1914L<Ambiguous use of %c{%s%s} resolved to %c%s%s|perldiag/"Ambiguous use of %c{%s%s} resolved to %c%s%s">
1915
1916=item *
1917
1918L<Ambiguous use of -%s resolved as -&%s()|perldiag/"Ambiguous use of -%s resolved as -&%s()">
1919
1920=item *
1921
1922L<Invalid strict version format (%s)|perldiag/"Invalid strict version format (%s)">
1923
1924=item *
1925
1926L<Invalid version format (%s)|perldiag/"Invalid version format (%s)">
1927
1928=item *
1929
1930L<Invalid version object|perldiag/"Invalid version object">
1931
1932=back
1933
5076a392
FC
1934=head3 L<perlbook>
1935
41e29def 1936L<perlbook> has been expanded to cover many more popular books.
5076a392 1937
41e29def 1938=head3 C<SvTRUE> macro
5076a392 1939
41e29def
FC
1940The documentation for the C<SvTRUE> macro in
1941L<perlapi> was simply wrong in stating that
5076a392
FC
1942get-magic is not processed. It has been corrected.
1943
41e29def 1944=head3 L<perlvar> revamp
5076a392 1945
41e29def 1946L<perlvar> reorders the variables and groups them by topic. Each variable
5076a392 1947introduced after Perl 5.000 notes the first version in which it is
41e29def 1948available. L<perlvar> also has a new section for deprecated variables to
5076a392
FC
1949note when they were removed.
1950
41e29def 1951=head3 Array and hash slices in scalar context
5076a392 1952
41e29def 1953These are now documented in L<perldata>.
5076a392 1954
41e29def 1955=head3 C<use locale> and formats
5076a392
FC
1956
1957L<perlform> and L<perllocale> have been corrected to state that
1958C<use locale> affects formats.
1959
5076a392
FC
1960=head3 L<overload>
1961
5076a392
FC
1962L<overload>'s documentation has practically undergone a rewrite. It
1963is now much more straightforward and clear.
1964
41e29def 1965=head3 L<perlhack> and perlrepository revamp
5076a392
FC
1966
1967The L<perlhack> and perlrepository documents have been heavily edited and
1968split up into several new documents.
1969
1970The L<perlhack> document is now much shorter, and focuses on the Perl 5
1971development process and submitting patches to Perl. The technical content has
1972been moved to several new documents, L<perlsource>, L<perlinterp>,
1973L<perlhacktut>, and L<perlhacktips>. This technical content has only been
1974lightly edited.
1975
1976The perlrepository document has been renamed to L<perlgit>. This new document
1977is just a how-to on using git with the Perl source code. Any other content
1978that used to be in perlrepository has been moved to perlhack.
1979
41e29def 1980=head3 Time::Piece examples
5076a392
FC
1981
1982Examples in L<perlfaq4> have been updated to show the use of
41e29def 1983L<Time::Piece>.
5076a392
FC
1984
1985=head1 Diagnostics
1986
1987The following additions or changes have been made to diagnostic output,
1988including warnings and fatal error messages. For the complete list of
1989diagnostic messages, see L<perldiag>.
1990
1991=head2 New Diagnostics
1992
a593b319
FC
1993=head3 New Errors
1994
5076a392
FC
1995=over
1996
a593b319 1997=item Closure prototype called
5076a392 1998
a593b319
FC
1999This error occurs when a subroutine reference passed to an attribute
2000handler is called, if the subroutine is a closure [perl #68560].
5076a392 2001
a593b319 2002=item Insecure user-defined property %s
5076a392 2003
a593b319
FC
2004Perl detected tainted data when trying to compile a regular
2005expression that contains a call to a user-defined character property
2006function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>.
2007See L<perlunicode/User-Defined Character Properties> and L<perlsec>.
5076a392 2008
a593b319 2009=item panic: gp_free failed to free glob pointer - something is repeatedly re-creating entries
5076a392 2010
a593b319
FC
2011This new error is triggered if a destructor called on an object in a
2012typeglob that is being freed creates a new typeglob entry containing an
2013object with a destructor that creates a new entry containing an object....
5076a392 2014
a593b319 2015=item Parsing code internal error (%s)
5076a392 2016
a593b319
FC
2017This new fatal error is produced when parsing
2018code supplied by an extension violates the
2019parser's API in a detectable way.
5076a392 2020
a593b319 2021=item refcnt: fd %d%s
5076a392 2022
a593b319
FC
2023This new error only occurs if a internal consistency check fails when a
2024pipe is about to be closed.
5076a392 2025
a593b319 2026=item Regexp modifier "/%c" may not appear twice
5076a392 2027
a593b319
FC
2028The regular expression pattern has one of the
2029mutually exclusive modifiers repeated.
5076a392 2030
a593b319 2031=item Regexp modifiers "/%c" and "/%c" are mutually exclusive
5076a392 2032
a593b319
FC
2033The regular expression pattern has more than one of the mutually
2034exclusive modifiers.
5076a392 2035
a593b319 2036=item Using !~ with %s doesn't make sense
5076a392 2037
a593b319 2038This error occurs when C<!~> is used with C<s///r> or C<y///r>.
5076a392 2039
a593b319 2040=back
5076a392 2041
a593b319 2042=head3 New Warnings
5076a392 2043
a593b319 2044=over
5076a392 2045
a593b319 2046=item "\b{" is deprecated; use "\b\{" instead
5076a392 2047
a593b319 2048=item "\B{" is deprecated; use "\B\{" instead
5076a392 2049
a593b319
FC
2050Use of an unescaped "{" immediately following a C<\b> or C<\B> is now
2051deprecated so as to reserve its use for Perl itself in a future release.
5076a392 2052
a593b319 2053=item Operation "%s" returns its argument for ...
5076a392 2054
a593b319
FC
2055Performing an operation requiring Unicode semantics (such as case-folding)
2056on a Unicode surrogate or a non-Unicode character now triggers a warning:
2057'Operation "%s" returns its argument for ...'.
5076a392 2058
a593b319
FC
2059=item Use of qw(...) as parentheses is deprecated
2060
2061See L</"Use of qw(...) as parentheses">, above, for details.
5076a392
FC
2062
2063=back
2064
2065=head2 Changes to Existing Diagnostics
2066
2067=over 4
2068
2069=item *
2070
4ed2cea4
FC
2071The "Variable $foo is not imported" warning that precedes a
2072C<strict 'vars'> error has now been assigned the "misc" category, so that
2073C<no warnings> will suppress it [perl #73712].
2074
2075=item *
2076
5076a392
FC
2077C<warn> and C<die> now produce 'Wide character' warnings when fed a
2078character outside the byte range if STDERR is a byte-sized handle.
2079
2080=item *
2081
2082The 'Layer does not match this perl' error message has been replaced with
a593b319 2083these more helpful messages [perl #73754]:
5076a392
FC
2084
2085=over 4
2086
2087=item *
2088
2089PerlIO layer function table size (%d) does not match size expected by this
2090perl (%d)
2091
2092=item *
2093
2094PerlIO layer instance size (%d) does not match size expected by this perl
2095(%d)
2096
2097=back
2098
5076a392
FC
2099=item *
2100
2101The "Found = in conditional" warning that is emitted when a constant is
2102assigned to a variable in a condition is now withheld if the constant is
2103actually a subroutine or one generated by C<use constant>, since the value
2104of the constant may not be known at the time the program is written
2105[perl #77762].
2106
2107=item *
2108
2109Previously, if none of the C<gethostbyaddr>, C<gethostbyname> and
2110C<gethostent> functions were implemented on a given platform, they would
2111all die with the message 'Unsupported socket function "gethostent" called',
2112with analogous messages for C<getnet*> and C<getserv*>. This has been
2113corrected.
2114
2115=item *
2116
a593b319
FC
2117The warning message about unrecognized regular expression escapes passed
2118through has been changed to include any literal '{' following the
2119two-character escape. E.g., "\q{" is now emitted instead of "\q".
5076a392
FC
2120
2121=back
2122
2123=head1 Utility Changes
2124
0b88cc74 2125=head3 L<perlbug>
5076a392
FC
2126
2127=over 4
2128
2129=item *
2130
0b88cc74
FC
2131L<perlbug> now looks in the EMAIL environment variable for a return address
2132if the REPLY-TO and REPLYTO variables are empty.
5076a392
FC
2133
2134=item *
2135
0b88cc74
FC
2136L<perlbug> did not previously generate a From: header, potentially
2137resulting in dropped mail. Now it does include that header.
5076a392
FC
2138
2139=item *
2140
0b88cc74 2141The user's address is now used as the return-path.
4ed2cea4 2142
0b88cc74
FC
2143Many systems these days don't have a valid Internet domain name and
2144perlbug@perl.org does not accept email with a return-path that does
2145not resolve. So the user's address is now passed to sendmail so it's
2146less likely to get stuck in a mail queue somewhere [perl #82996].
5076a392
FC
2147
2148=back
2149
0b88cc74 2150=head3 L<perl5db.pl>
5076a392 2151
0b88cc74 2152=over
5076a392
FC
2153
2154=item *
2155
0b88cc74
FC
2156The remote terminal works after forking and spawns new sessions - one
2157for each forked process.
5076a392
FC
2158
2159=back
2160
0b88cc74 2161=head3 L<ptargrep>
5076a392
FC
2162
2163=over 4
2164
2165=item *
2166
0b88cc74
FC
2167L<ptargrep> is a new utility to apply pattern matching to the contents of
2168files in a tar archive. It comes with C<Archive::Tar>.
5076a392
FC
2169
2170=back
2171
2172=head1 Configuration and Compilation
2173
61752d82
FC
2174See also L</"Naming fixes in Policy_sh.SH may invalidate Policy.sh">,
2175above.
2176
5076a392
FC
2177=over 4
2178
2179=item *
2180
87595b22
FC
2181CCINCDIR and CCLIBDIR for the mingw64
2182cross-compiler are now correctly under
5076a392
FC
2183$(CCHOME)\mingw\include and \lib rather than immediately below $(CCHOME).
2184
5076a392
FC
2185This means the 'incpath', 'libpth', 'ldflags', 'lddlflags' and
2186'ldflags_nolargefiles' values in Config.pm and Config_heavy.pl are now
87595b22 2187set correctly.
5076a392
FC
2188
2189=item *
2190
87595b22
FC
2191'make test.valgrind' has been adjusted to account for cpan/dist/ext
2192separation.
5076a392
FC
2193
2194=item *
2195
2196On compilers that support it, C<-Wwrite-strings> is now added to cflags by
2197default.
2198
2199=item *
2200
2201The C<Encode> module can now (once again) be included in a static Perl
2202build. The special-case handling for this situation got broken in Perl
22035.11.0, and has now been repaired.
2204
1e463951
FC
2205=item *
2206
2207The previous default size of a PerlIO buffer (4096 bytes) has been increased
2208to the larger of 8192 bytes and your local BUFSIZ. Benchmarks show that doubling
2209this decade-old default increases read and write performance in the neighborhood
2210of 25% to 50% when using the default layers of perlio on top of unix. To choose
2211a non-default size, such as to get back the old value or to obtain an even
2212larger value, configure with:
2213
2214 ./Configure -Accflags=-DPERLIOBUF_DEFAULT_BUFSIZ=N
2215
2216where N is the desired size in bytes; it should probably be a multiple of
2217your page size.
2218
5076a392
FC
2219=back
2220
2221=head1 Testing
2222
6eff4dda
FC
2223XXX This section has not been cleaned up yet. Do we really need this
2224section? How many people are going to find a list of new test files useful?
2225Anyone hacking on the core can use
2226‘git diff v5.12.0..v5.14.0 MANIFEST|grep '^[+-]t/'’.
2227
5076a392
FC
2228XXX Any significant changes to the testing of a freshly built perl should be
2229listed here. Changes which create B<new> files in F<t/> go here as do any
2230large changes to the testing harness (e.g. when parallel testing was added).
2231Changes to existing files in F<t/> aren't worth summarising, although the bugs
2232that they represent may be covered elsewhere.
2233
2234=over 4
2235
2236=item *
2237
2238F<t/harness> clears PERL5LIB, PERLLIB, PERL5OPT as t/TEST does (a2d3de1)
2239
2240=item *
2241
2242Many common testing routines were refactored into t/lib/common.pl
2243
2244=item *
2245
2246Several test files have been modernized to use Test::More
2247
2248=item *
2249
2250F<t/op/print.t> has been added to test implicit printing of C<$_>.
2251
2252=item *
2253
2254F<t/io/errnosig.t> has been added to test for restoration of of C<$!> when
2255leaving signal handlers.
2256
2257=item *
2258
2259F<t/op/tie_fetch_count.t> has been added to see if C<FETCH> is only called once
2260on tied variables.
2261
2262=item *
2263
2264F<lib/Tie/ExtraHash.t> has been added to make sure the, previously untested,
2265L<Tie::ExtraHash> keeps working.
2266
2267=item *
2268
2269F<t/re/overload.t> has been added to test against string corruption in pattern
2270matches on overloaded objects. This is a TODO test.
2271
2272=item *
2273
2274The new F<t/lib/universal.t> script tests the Internal::* functions and other
2275things in F<universal.c>.
2276
2277=item *
2278
2279A rare race condition in F<t/op/while_readdir.t> has been fixed, stopping it
2280from failing randomly when running tests in parallel.
2281
2282=item *
2283
2284The new F<t/op/leaky-magic.t> script tests that magic applied to variables in
2285the main packages does not affect other packages.
2286
2287=item *
2288
2289The script F<t/op/threads-dirh.t> has been added, which tests interaction
2290of threads and directory handles.
2291
2292=item *
2293
2294The new F<t/mro/isa_aliases.t> has been added, which tests that
2295C<*Foo::ISA = *Bar::ISA> works properly.
2296
2297=item *
2298
2299F<t/mro/isarev.t> has been added, which tests that C<PL_isarev> (accessible
2300at the Perl level via C<mro::get_isarev>) is updated properly.
2301
2302=item *
2303
2304F<t/run/switchd-78586.t> has been added, which tests that [perl #78586]
2305has been fixed (related to line numbers in the debugger).
2306
2307=item *
2308
2309C<lib/File/DosGlob.t> has been modernized and now uses C<Test::More>.
2310
2311=item *
2312
2313A new test script, C<t/porting/filenames.t>, makes sure that filenames and
2314paths are reasonably portable.
2315
2316=item *
2317
2318C<t/porting/diag.t> is now several orders of magnitude faster.
2319
2320=item *
2321
2322C<t/porting/buildtoc.t> now tests that the documentation TOC file is current and well-formed.
2323
2324=item *
2325
2326C<t/base/while.t> now tests the basics of a while loop with minimal dependencies.
2327
2328=item *
2329
2330C<t/cmd/while.t> now uses F<test.pl> for better maintainability.
2331
2332=item *
2333
2334C<t/op/split.t> now tests calls to C<split> without any pattern specified.
2335
2336=item *
2337
2338F<porting/FindExt.t> now skips all tests on a static (-Uusedl) build
2339of perl.
2340
2341=item *
2342
2343F<porting/FindExt.t> now passes on non-Win32 platforms when some
2344extensions are built statically.
2345
2346=item *
2347
2348The tests for C<split /\s/> and Unicode have been moved from
2349F<t/op/split.t> to the new F<t/op/split_unicode.t>.
2350
2351=item *
2352
2353F<t/re/re.t> has been moved to F<ext/re/t/re_funcs_u.t>.
2354
2355=item *
2356
2357The tests for [perl #72922] have been moved from F<t/re/qr.t> to the new
2358F<t/re/qr-72922.t>.
2359
2360=item *
2361
2362F<t/re/reg_unsafe.t> has been deleted and its only test moved to
2363F<t/re/pat_advanced.t>.
2364
2365=back
2366
2367=head1 Platform Support
2368
5076a392
FC
2369=head2 New Platforms
2370
5076a392
FC
2371=over 4
2372
2373=item AIX
2374
2375Perl now builds on AIX 4.2.
2376
2377=back
2378
2379=head2 Discontinued Platforms
2380
2381=over 4
2382
5076a392
FC
2383=item Apollo DomainOS
2384
2385The last vestiges of support for this platform have been excised from the
2386Perl distribution. It was officially discontinued in version 5.12.0. It had
2387not worked for years before that.
2388
2389=item MacOS Classic
2390
2391The last vestiges of support for this platform have been excised from the
2392Perl distribution. It was officially discontinued in an earlier version.
2393
2394=back
2395
2396=head2 Platform-Specific Notes
2397
554003a2 2398=head3 Cygwin
5076a392
FC
2399
2400=over 4
2401
2402=item *
2403
554003a2 2404MakeMaker has been updated to build man pages on cygwin.
5076a392
FC
2405
2406=item *
2407
554003a2
FC
2408Improved rebase behaviour
2409
2410If a dll is updated on cygwin the old imagebase address is reused.
2411This solves most rebase errors, especially when updating on core dll's.
2412See L<http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README> for more information.
5076a392
FC
2413
2414=item *
2415
554003a2 2416Support for the standard cygwin dll prefix, which is e.g. needed for FFI's
5076a392
FC
2417
2418=item *
2419
554003a2 2420Updated build hints file
5076a392
FC
2421
2422=back
2423
554003a2 2424=head3 IRIX
5076a392
FC
2425
2426Conversion of strings to floating-point numbers is now more accurate on
2427IRIX systems [perl #32380].
2428
554003a2 2429=head3 Mac OS X
5076a392
FC
2430
2431Early versions of Mac OS X (Darwin) had buggy implementations of the
2432C<setregid>, C<setreuid>, C<setrgid> and C<setruid> functions, so perl
2433would pretend they did not exist.
2434
2435These functions are now recognised on Mac OS 10.5 (Leopard; Darwin 9) and
2436higher, as they have been fixed [perl #72990].
2437
554003a2 2438=head3 MirBSD
5076a392 2439
554003a2
FC
2440Previously if you built perl with a shared libperl.so on MirBSD (the
2441default config), it would work up to the installation; however, once
2442installed, it would be unable to find libperl. So path handling is now
2443treated as in the other BSD dialects.
5076a392 2444
554003a2 2445=head3 NetBSD
5076a392 2446
554003a2
FC
2447The NetBSD hints file has been changed to make the system's malloc the
2448default.
5076a392 2449
554003a2 2450=head3 Recent OpenBSDs now use perl's malloc
5076a392 2451
554003a2
FC
2452OpenBSD E<gt> 3.7 has a new malloc implementation which is mmap-based
2453and as such can release memory back to the OS; however, perl's use of
2454this malloc causes a substantial slowdown so we now default to using
2455perl's malloc instead [perl #75742].
5076a392 2456
554003a2 2457=head3 OpenVOS
5076a392 2458
554003a2
FC
2459perl now builds again with OpenVOS (formerly known as Stratus VOS)
2460[perl #78132].
5076a392 2461
554003a2 2462=head3 Solaris
5076a392 2463
554003a2
FC
2464DTrace is now supported on Solaris. There used to be build failures, but
2465these have been fixed [perl #73630].
5076a392 2466
554003a2 2467=head3 VMS
5076a392
FC
2468
2469=over
2470
2471=item *
2472
554003a2 2473C<PerlIOUnix_open> now honours the default permissions on VMS.
5076a392 2474
554003a2
FC
2475When C<perlio> became the default and C<unixio> became the default bottom layer,
2476the most common path for creating files from Perl became C<PerlIOUnix_open>,
2477which has always explicitly used C<0666> as the permission mask.
5076a392 2478
554003a2
FC
2479To avoid this, C<0777> is now passed as the permissions to C<open()>. In the
2480VMS CRTL, C<0777> has a special meaning over and above intersecting with the
2481current umask; specifically, it allows Unix syscalls to preserve native default
2482permissions.
5076a392
FC
2483
2484=item *
2485
554003a2
FC
2486The shortening of symbols longer than 31 characters in the C sources is
2487now done by the compiler rather than by xsubpp (which could only do so
2488for generated symbols in XS code).
5076a392
FC
2489
2490=item *
2491
554003a2
FC
2492Record-oriented files (record format variable or variable with fixed control)
2493opened for write by the perlio layer will now be line-buffered to prevent the
2494introduction of spurious line breaks whenever the perlio buffer fills up.
5076a392
FC
2495
2496=back
2497
554003a2 2498=head3 Windows
5076a392 2499
5a1f7719
FC
2500See also L</"fork() emulation will not wait for signalled children"> and
2501L</"Perl source code is read in text mode on Windows">, above.
2502
5076a392
FC
2503=over 4
2504
2505=item *
2506
554003a2 2507Fixed build process for SDK2003SP1 compilers.
5076a392 2508
554003a2 2509=item *
5076a392 2510
554003a2
FC
2511When using old 32-bit compilers, the define C<_USE_32BIT_TIME_T> will now
2512be set in C<$Config{ccflags}>. This improves portability when compiling
2513XS extensions using new compilers, but for a perl compiled with old 32-bit
2514compilers.
5076a392
FC
2515
2516=item *
2517
554003a2
FC
2518C<$Config{gccversion}> is now set correctly when perl is built using the
2519mingw64 compiler from L<http://mingw64.org> [perl #73754].
5076a392 2520
554003a2
FC
2521=item *
2522
2523The build process proceeds more smoothly with mingw and dmake when
2524F<C:\MSYS\bin> is in the PATH, due to a C<Cwd> fix.
5076a392
FC
2525
2526=item *
2527
554003a2
FC
2528Support for building with Visual C++ 2010 is now underway, but is not yet
2529complete. See F<README.win32> or L<perlwin32> for more details.
5076a392 2530
554003a2
FC
2531=item *
2532
2533The option to use an externally-supplied C<crypt()>, or to build with no
2534C<crypt()> at all, has been removed. Perl supplies its own C<crypt()>
2535implementation for Windows, and the political situation that required
2536this part of the distribution to sometimes be omitted is long gone.
5076a392
FC
2537
2538=back
2539
2540=head1 Internal Changes
2541
1e463951 2542=head2 New APIs
5076a392 2543
1e463951 2544=head3 CLONE_PARAMS structure added to ease correct thread creation
5076a392 2545
1e463951
FC
2546Modules that create threads should now create C<CLONE_PARAMS> structures
2547by calling the new function C<Perl_clone_params_new()>, and free them with
2548C<Perl_clone_params_del()>. This will ensure compatibility with any future
2549changes to the internals of the C<CLONE_PARAMS> structure layout, and that
2550it is correctly allocated and initialised.
5076a392 2551
1e463951 2552=head3 New parsing functions
5076a392 2553
1e463951
FC
2554Several functions have been added for parsing statements or multiple
2555statements:
5076a392 2556
1e463951 2557=over
5076a392
FC
2558
2559=item *
2560
1e463951 2561C<parse_fullstmt> parses a complete Perl statement.
5076a392
FC
2562
2563=item *
2564
1e463951
FC
2565C<parse_stmtseq> parses a sequence of statements, up
2566to closing brace or EOF.
5076a392
FC
2567
2568=item *
2569
1e463951 2570C<parse_block> parses a block [perl #78222].
5076a392
FC
2571
2572=item *
2573
1e463951
FC
2574C<parse_barestmt> parses a statement
2575without a label.
5076a392
FC
2576
2577=item *
2578
1e463951 2579C<parse_label> parses a statement label, separate from statements.
5076a392 2580
1e463951 2581=back
5076a392 2582
1e463951
FC
2583The
2584L<C<parse_fullexpr()>|perlapi/parse_fullexpr>,
2585L<C<parse_listexpr()>|perlapi/parse_listexpr>,
2586L<C<parse_termexpr()>|perlapi/parse_termexpr>, and
2587L<C<parse_arithexpr()>|perlapi/parse_arithexpr>
2588functions have been added to the API. They perform
2589recursive-descent parsing of expressions at various precedence levels.
2590They are expected to be used by syntax plugins.
5076a392 2591
1e463951 2592See L<perlapi> for details.
5076a392 2593
1e463951 2594=head3 Hints hash API
5076a392 2595
1e463951
FC
2596A new C API for introspecting the hinthash C<%^H> at runtime has been
2597added. See C<cop_hints_2hv>, C<cop_hints_fetchpvn>, C<cop_hints_fetchpvs>,
2598C<cop_hints_fetchsv>, and C<hv_copy_hints_hv> in L<perlapi> for details.
5076a392 2599
1e463951
FC
2600A new, experimental API has been added for accessing the internal
2601structure that Perl uses for C<%^H>. See the functions beginning with
2602C<cophh_> in L<perlapi>.
5076a392 2603
1e463951 2604=head3 C interface to C<caller()>
5076a392 2605
1e463951
FC
2606The C<caller_cx> function has been added as an XSUB-writer's equivalent of
2607C<caller()>. See L<perlapi> for details.
5076a392 2608
1e463951 2609=head3 Custom per-subroutine check hooks
5076a392 2610
1e463951
FC
2611XS code in an extension module can now annotate a subroutine (whether
2612implemented in XS or in Perl) so that nominated XS code will be called
2613at compile time (specifically as part of op checking) to change the op
2614tree of that subroutine. The compile-time check function (supplied by
2615the extension module) can implement argument processing that can't be
2616expressed as a prototype, generate customised compile-time warnings,
2617perform constant folding for a pure function, inline a subroutine
2618consisting of sufficiently simple ops, replace the whole call with a
2619custom op, and so on. This was previously all possible by hooking the
2620C<entersub> op checker, but the new mechanism makes it easy to tie the
2621hook to a specific subroutine. See L<perlapi/cv_set_call_checker>.
5076a392 2622
1e463951
FC
2623To help in writing custom check hooks, several subtasks within standard
2624C<entersub> op checking have been separated out and exposed in the API.
5076a392 2625
1e463951 2626=head3 Improved support for custom OPs
5076a392 2627
1e463951
FC
2628Custom ops can now be registered with the new C<custom_op_register> C
2629function and the C<XOP> structure. This will make it easier to add new
2630properties of custom ops in the future. Two new properties have been added
2631already, C<xop_class> and C<xop_peep>.
5076a392 2632
1e463951
FC
2633C<xop_class> is one of the OA_*OP constants, and allows L<B> and other
2634introspection mechanisms to work with custom ops
2635that aren't BASEOPs. C<xop_peep> is a pointer to
2636a function that will be called for ops of this
2637type from C<Perl_rpeep>.
5076a392 2638
1e463951
FC
2639See L<perlguts/Custom Operators> and L<perlapi/Custom Operators> for more
2640detail.
5076a392 2641
1e463951
FC
2642The old C<PL_custom_op_names>/C<PL_custom_op_descs> interface is still
2643supported but discouraged.
5076a392 2644
1e463951 2645=head3 Scope hooks
5076a392 2646
1e463951
FC
2647It is now possible for XS code to hook into Perl's lexical scope
2648mechanism at compile time, using the new C<Perl_blockhook_register>
2649function. See L<perlguts/"Compile-time scope hooks">.
5076a392 2650
1e463951 2651=head3 The recursive part of the peephole optimizer is now hookable
5076a392
FC
2652
2653In addition to C<PL_peepp>, for hooking into the toplevel peephole optimizer, a
2654C<PL_rpeepp> is now available to hook into the optimizer recursing into
2655side-chains of the optree.
2656
1e463951 2657=head3 New non-magical variants of existing functions
5076a392 2658
1e463951
FC
2659The following functions/macros have been added to the API. The C<*_nomg>
2660macros are equivalent to their non-_nomg variants, except that they ignore
2661get-magic. Those ending in C<_flags> allow one to specify whether
2662get-magic is processed.
5076a392 2663
1e463951
FC
2664 sv_2bool_flags
2665 SvTRUE_nomg
2666 sv_2nv_flags
2667 SvNV_nomg
2668 sv_cmp_flags
2669 sv_cmp_locale_flags
2670 sv_eq_flags
2671 sv_collxfrm_flags
5076a392 2672
1e463951 2673In some of these cases, the non-_flags functions have
5076a392
FC
2674been replaced with wrappers around the new functions.
2675
1e463951 2676=head3 pv/pvs/sv versions of existing functions
5076a392 2677
1e463951 2678Many functions ending with pvn now have equivalent pv/pvs/sv versions.
5076a392 2679
1e463951 2680=head3 List op-building functions
5076a392 2681
1e463951
FC
2682List op-building functions have been added to the
2683API. See L<op_append_elem|perlapi/op_append_elem>,
2684L<op_append_list|perlapi/op_append_list>, and
2685L<op_prepend_elem|perlapi/op_prepend_elem> in L<perlapi>.
5076a392 2686
1e463951 2687=head3 C<LINKLIST>
5076a392 2688
1e463951
FC
2689The L<LINKLIST|perlapi/LINKLIST> macro, part of op building that
2690constructs the execution-order op chain, has been added to the API.
5076a392 2691
1e463951 2692=head3 Localisation functions
5076a392 2693
1e463951
FC
2694The C<save_freeop>, C<save_op>, C<save_pushi32ptr> and C<save_pushptrptr>
2695functions have been added to the API.
5076a392 2696
1e463951 2697=head3 Stash names
5076a392 2698
1e463951
FC
2699A stash can now have a list of effective names in addition to its usual
2700name. The first effective name can be accessed via the C<HvENAME> macro,
2701which is now the recommended name to use in MRO linearisations (C<HvNAME>
2702being a fallback if there is no C<HvENAME>).
5076a392 2703
1e463951
FC
2704These names are added and deleted via C<hv_ename_add> and
2705C<hv_ename_delete>. These two functions are I<not> part of the API.
5076a392 2706
1e463951 2707=head3 New functions for finding and removing magic
5076a392 2708
1e463951
FC
2709The L<C<mg_findext()>|perlapi/mg_findext> and
2710L<C<sv_unmagicext()>|perlapi/sv_unmagicext>
2711functions have been added to the API.
2712They allow extension authors to find and remove magic attached to
2713scalars based on both the magic type and the magic virtual table, similar to how
2714C<sv_magicext()> attaches magic of a certain type and with a given virtual table
2715to a scalar. This eliminates the need for extensions to walk the list of
2716C<MAGIC> pointers of an C<SV> to find the magic that belongs to them.
5076a392 2717
1e463951 2718=head3 C<find_rundefsv>
5076a392 2719
1e463951
FC
2720This function returns the SV representing C<$_>, whether it's lexical
2721or dynamic.
5076a392 2722
1e463951 2723=head3 C<Perl_croak_no_modify>
5076a392 2724
1e463951
FC
2725C<Perl_croak_no_modify()> is short-hand for
2726C<Perl_croak("%s", PL_no_modify)>.
5076a392 2727
1e463951 2728=head3 C<PERL_STATIC_INLINE> define
5076a392 2729
1e463951
FC
2730The C<PERL_STATIC_INLINE> define has been added to provide the best-guess
2731incantation to use for static inline functions, if the C compiler supports
2732C99-style static inline. If it doesn't, it'll give a plain C<static>.
5076a392 2733
1e463951
FC
2734C<HAS_STATIC_INLINE> can be used to check if the compiler actually supports
2735inline functions.
5076a392 2736
1e463951 2737=head3 New C<pv_escape> option for hexadecimal escapes
5076a392 2738
1e463951
FC
2739A new option, C<PERL_PV_ESCAPE_NONASCII>, has been added to C<pv_escape> to
2740dump all characters above ASCII in hexadecimal. Before, one could get all
2741characters as hexadecimal or the Latin1 non-ASCII as octal.
5076a392 2742
1e463951 2743=head3 C<lex_start>
5076a392 2744
1e463951 2745C<lex_start> has been added to the API, but is considered experimental.
5076a392 2746
1e463951 2747=head3 C<op_scope()> and C<op_lvalue()>
5076a392 2748
1e463951
FC
2749The C<op_scope()> and C<op_lvalue()> functions have been added to the API,
2750but are considered experimental.
5076a392 2751
1e463951 2752=head2 C API Changes
5076a392 2753
1e463951 2754=head3 C<PERL_POLLUTE> has been removed
5076a392 2755
1e463951
FC
2756The option to define C<PERL_POLLUTE> to expose older 5.005 symbols for
2757backwards compatibility has been removed. It's use was always discouraged,
2758and MakeMaker contains a more specific escape hatch:
5076a392 2759
1e463951 2760 perl Makefile.PL POLLUTE=1
5076a392 2761
1e463951
FC
2762This can be used for modules that have not been upgraded to 5.6 naming
2763conventions (and really should be completely obsolete by now).
5076a392 2764
1e463951 2765=head3 Check API compatibility when loading XS modules
5076a392 2766
1e463951
FC
2767When perl's API changes in incompatible ways (which usually happens between
2768major releases), XS modules compiled for previous versions of perl will not
2769work anymore. They will need to be recompiled against the new perl.
5076a392 2770
1e463951
FC
2771In order to ensure that modules are recompiled, and to prevent users from
2772accidentally loading modules compiled for old perls into newer ones, the
2773C<XS_APIVERSION_BOOTCHECK> macro has been added. That macro, which is
2774called when loading every newly compiled extension, compares the API
2775version of the running perl with the version a module has been compiled for
2776and raises an exception if they don't match.
5076a392 2777
1e463951 2778=head3 Perl_fetch_cop_label
5076a392 2779
1e463951
FC
2780The first argument of the C API function C<Perl_fetch_cop_label> has changed
2781from C<struct refcounted he *> to C<COP *>, to insulate the user from
2782implementation details.
5076a392 2783
1e463951
FC
2784This API function was marked as "may change", and likely isn't in use outside
2785the core. (Neither an unpacked CPAN, nor Google's codesearch, finds any other
2786references to it.)
5076a392 2787
1e463951 2788=head3 GvCV() and GvGP() are no longer lvalues
5076a392 2789
1e463951
FC
2790The new GvCV_set() and GvGP_set() macros are now provided to replace
2791assignment to those two macros.
5076a392 2792
1e463951
FC
2793This allows a future commit to eliminate some backref magic between GV
2794and CVs, which will require complete control over assignment to the
2795gp_cv slot.
5076a392 2796
1e463951 2797=head3 CvGV() is no longer an lvalue
5076a392 2798
1e463951
FC
2799Under some circumstances, the C<CvGV()> field of a CV is now
2800reference-counted. To ensure consistent behaviour, direct assignment to
2801it, for example C<CvGV(cv) = gv> is now a compile-time error. A new macro,
2802C<CvGV_set(cv,gv)> has been introduced to perform this operation
2803safely. Note that modification of this field is not part of the public
2804API, regardless of this new macro (and despite its being listed in this section).
5076a392 2805
1e463951 2806=head3 CvSTASH() is no longer an lvalue
5076a392 2807
1e463951
FC
2808The C<CvSTASH()> macro can now only be used as an rvalue. C<CvSTASH_set()>
2809has been added to replace assignment to C<CvSTASH()>. This is to ensure
2810that backreferences are handled properly. These macros are not part of the
2811API.
5076a392 2812
1e463951 2813=head3 Calling conventions for C<newFOROP> and C<newWHILEOP>
5076a392 2814
1e463951
FC
2815The way the parser handles labels has been cleaned up and refactored. As a
2816result, the C<newFOROP()> constructor function no longer takes a parameter
2817stating what label is to go in the state op.
5076a392 2818
1e463951
FC
2819The C<newWHILEOP()> and C<newFOROP()> functions no longer accept a line
2820number as a parameter.
5076a392 2821
1e463951 2822=head3 Flags passed to C<uvuni_to_utf8_flags> and C<utf8n_to_uvuni>
5076a392 2823
1e463951
FC
2824Some of the flags parameters to uvuni_to_utf8_flags() and
2825utf8n_to_uvuni() have changed. This is a result of Perl's now allowing
5076a392
FC
2826internal storage and manipulation of code points that are problematic
2827in some situations. Hence, the default actions for these functions has
2828been complemented to allow these code points. The new flags are
2829documented in L<perlapi>. Code that requires the problematic code
2830points to be rejected needs to change to use these flags. Some flag
2831names are retained for backward source compatibility, though they do
2832nothing, as they are now the default. However the flags
2833C<UNICODE_ALLOW_FDD0>, C<UNICODE_ALLOW_FFFF>, C<UNICODE_ILLEGAL>, and
2834C<UNICODE_IS_ILLEGAL> have been removed, as they stem from a
2835fundamentally broken model of how the Unicode non-character code points
2836should be handled, which is now described in
2837L<perlunicode/Non-character code points>. See also L</Selected Bug Fixes>.
2838
1e463951
FC
2839XXX Which bugs in particular? Selected Bug Fixes is too long for this link
2840to be meaningful right now.
5076a392 2841
1e463951 2842=head2 Deprecated C APIs
5076a392 2843
1e463951 2844=over
5076a392 2845
1e463951 2846=item C<Perl_ptr_table_clear>
5076a392 2847
1e463951
FC
2848C<Perl_ptr_table_clear> is no longer part of Perl's public API. Calling it
2849now generates a deprecation warning, and it will be removed in a future
2850release.
5076a392 2851
1e463951 2852=item C<sv_compile_2op>
5076a392 2853
1e463951
FC
2854The C<sv_compile_2op()> API function is now deprecated. Searches suggest
2855that nothing on CPAN is using it, so this should have zero impact.
5076a392 2856
1e463951
FC
2857It attempted to provide an API to compile code down to an optree, but failed
2858to bind correctly to lexicals in the enclosing scope. It's not possible to
2859fix this problem within the constraints of its parameters and return value.
5076a392 2860
1e463951 2861=item C<find_rundefsvoffset>
5076a392 2862
1e463951
FC
2863The C<find_rundefsvoffset> function has been deprecated. It appeared that
2864its design was insufficient for reliably getting the lexical C<$_> at
2865run-time.
5076a392 2866
1e463951
FC
2867Use the new C<find_rundefsv> function or the C<UNDERBAR> macro
2868instead. They directly return the right SV representing C<$_>, whether it's
2869lexical or dynamic.
5076a392 2870
1e463951 2871=item C<CALL_FPTR> and C<CPERLscope>
5076a392 2872
1e463951
FC
2873Those are left from an old implementation of C<MULTIPLICITY> using C++ objects,
2874which was removed in Perl 5.8. Nowadays these macros do exactly nothing, so
2875they shouldn't be used anymore.
5076a392 2876
1e463951
FC
2877For compatibility, they are still defined for external C<XS> code. Only
2878extensions defining C<PERL_CORE> must be updated now.
5076a392 2879
1e463951 2880=back
5076a392 2881
1e463951 2882=head2 Other Internal Changes
5076a392 2883
1e463951 2884=head3 Stack unwinding
5076a392 2885
1e463951
FC
2886The protocol for unwinding the C stack at the last stage of a C<die>
2887has changed how it identifies the target stack frame. This now uses
2888a separate variable C<PL_restartjmpenv>, where previously it relied on
2889the C<blk_eval.cur_top_env> pointer in the C<eval> context frame that
2890has nominally just been discarded. This change means that code running
2891during various stages of Perl-level unwinding no longer needs to take
2892care to avoid destroying the ghost frame.
5076a392 2893
1e463951 2894=head3 Scope stack entries
5076a392 2895
1e463951
FC
2896The format of entries on the scope stack has been changed, resulting in a
2897reduction of memory usage of about 10%. In particular, the memory used by
2898the scope stack to record each active lexical variable has been halved.
5076a392 2899
1e463951 2900=head3 Memory allocation for pointer tables
5076a392 2901
1e463951
FC
2902Memory allocation for pointer tables has been changed. Previously
2903C<Perl_ptr_table_store> allocated memory from the same arena system as
2904C<SV> bodies and C<HE>s, with freed memory remaining bound to those arenas
2905until interpreter exit. Now it allocates memory from arenas private to the
2906specific pointer table, and that memory is returned to the system when
2907C<Perl_ptr_table_free> is called. Additionally, allocation and release are
2908both less CPU intensive.
5076a392 2909
1e463951 2910=head3 C<UNDERBAR>
5076a392 2911
1e463951
FC
2912The C<UNDERBAR> macro now calls C<find_rundefsv>. C<dUNDERBAR> is now a
2913noop but should still be used to ensure past and future compatibility.
5076a392 2914
1e463951 2915=head3 String comparison routines renamed
5076a392 2916
1e463951
FC
2917The ibcmp_* functions have been renamed and are now called foldEQ,
2918foldEQ_locale and foldEQ_utf8. The old names are still available as
2919macros.
2920
2921=head3 C<chop> and C<chomp> implementations merged
2922
2923The opcode bodies for C<chop> and C<chomp> and for C<schop> and C<schomp>
2924have been merged. The implementation functions C<Perl_do_chop()> and
2925C<Perl_do_chomp()>, never part of the public API, have been merged and
2926moved to a static function in F<pp.c>. This shrinks the perl binary
2927slightly, and should not affect any code outside the core (unless it is
2928relying on the order of side effects when C<chomp> is passed a I<list> of
2929values).
5076a392
FC
2930
2931=head1 Selected Bug Fixes
2932
2933=over 4
2934
2935=item *
2936
a593b319
FC
2937C<binmode $fh, ':scalar'> no longer warns (8250589)
2938
2939Perl will now no longer produce this warning:
2940
2941 $ perl -we 'open my $f, ">", \my $x; binmode $f, "scalar"'
2942 Use of uninitialized value in binmode at -e line 1.
2943
2944=item *
2945
4ed2cea4
FC
2946C<when(scalar){...}> no longer crashes, but produces a syntax error
2947[perl #74114].
2948
2949=item *
2950
2951The C-level C<lex_stuff_pvn> function would sometimes cause a spurious
2952syntax error on the last line of the file if it lacked a final semicolon
2953[perl #74006].
2954
2955=item *
2956
2957The regular expression engine no longer loops when matching
2958C<"\N{LATIN SMALL LIGATURE FF}" =~ /f+/i> and similar expressions
2959[perl #72998].
2960
2961=item *
2962
2963A label right before a string eval (C<foo: eval $string>) no longer causes
2964the label to be associated also with the first statement inside the eval
2965[perl #74290] (5.12.1).
2966
2967=item *
2968
5076a392
FC
2969Naming a deprecated character in \N{...} will not leak memory.
2970
2971=item *
2972
2973FETCH is no longer called needlessly on some tied variables.
2974
2975=item *
2976
2977The trie runtime code should no longer allocate massive amounts of memory,
2978fixing #74484.
2979
2980=item *
2981
2982Timely cleanup of SVs that are cloned into a new thread but then
2983discovered to be orphaned (i.e. their owners are -not- cloned) (e42956)
2984
2985=item *
2986
2987Don't accidentally clone lexicals in scope within active stack frames in
2988the parent when creating a child thread (RT #73086) (05d04d).
2989
2990=item *
2991
2992Avoid loading feature.pm when 'no 5.13.2;' or similar is
2993encountered (faee19).
2994
2995=item *
2996
2997Trap invalid use of SvIVX on SVt_REGEXP when assertions are on
2998(e77da3)
2999
3000=item *
3001
3002Don't stamp on $DB::single, $DB::trace and $DB::signal if they
3003already have values when $^P is assigned to (RT #72422) (4c0f30).
3004
3005=item *
3006
3007chop now correctly handles perl's extended UTF-8 (RT #73246) (65ab92)
3008
3009=item *
3010
3011Defer signal handling when shared SV locks are held to avoid
3012deadlocks (RT #74868) (65c742).
3013
3014=item *
3015
3016glob() no longer crashes when %File::Glob:: is empty and
3017CORE::GLOBAL::glob isn't present (4984aa).
3018
3019=item *
3020
3021perlbug now always permits the sender address to be changed
3022before sending - if you were having trouble sending bug reports before
3023now, this should fix it, we hope (e6eb90).
3024
3025=item *
3026
3027Overloading now works properly in conjunction with tied
3028variables. What formerly happened was that most ops checked their
3029arguments for overloading I<before> checking for magic, so for example
3030an overloaded object returned by a tied array access would usually be
3031treated as not overloaded (RT #57012) (6f1401, ed3b9b, 6a5f8c .. 24328f).
3032
3033=item *
3034
3035Independently, a bug was fixed that prevented $tied-E<gt>() from
3036always calling FETCH correctly (RT #8438) (7c7501)
3037
3038=item *
3039
3040Some work has been done on the internal pointers that link between symbol
3041tables (stashes), typeglobs and subroutines. This has the effect that
3042various edge cases related to deleting stashes or stash entries (e.g.
3043<%FOO:: = ()>), and complex typeglob or code reference aliasing, will no
3044longer crash the interpreter.
3045
3046=item *
3047
3048Fixed readline() when interrupted by signals so it no longer returns
3049the "same thing" as before or random memory
3050
3051=item *
3052
3053Fixed a regression of kill() when a match variable is used for the
3054process ID to kill (RT#75812) (8af710e)
3055
3056=item *
3057
3058Fixed several subtle bugs in sort() when @_ is accessed within a subroutine
3059used for sorting (RT#72334) (8f443ca)
3060
3061=item *
3062
3063Catch yyparse() exceptions in C<< (?{...}) >> (RT#2353) (634d691)
3064
3065=item *
3066
3067Avoid UTF-8 cache panics with offsets beyond a string (RT #75898) (3e2d381)
3068
3069=item *
3070
3071Fixed POSIX::strftime memory leak (RT#73520) (c4bc4aa)
3072
3073=item *
3074
3075Doesn't set strict with C<no VERSION> if C<VERSION> is greater than 5.12
3076(da8fb5d)
3077
3078=item *
3079
3080Avoids multiple FETCH/stringify on filetest ops (40c852d)
3081
3082=item *
3083
3084Fixed issue with string C<eval> not detecting taint of overloaded/tied
3085arguments (RT #75716) (895b760)
3086
3087=item *
3088
3089Fix potential crashes of string C<eval> when evaluating a object with
3090overloaded stringification by creating a stringified copy when necessary
3091(3e5c018)
3092
3093=item *
3094
3095Fixed bug where overloaded stringification could remove tainting
3096(RT #75716) (a02ec77)
3097
3098=item *
3099
3100Plugs more memory leaks in vms.c. (9e2bec0)
3101
3102=item *
3103
3104Fix pthread include error for Time::Piece (e9f284c)
3105
3106=item *
3107
3108A possible memory leak when using L<caller()|perlfunc/"caller EXPR"> to set
3109C<@DB::args> has been fixed.
3110
3111=item *
3112
3113Several memory leaks when loading XS modules were fixed.
3114
3115=item *
3116
3117A panic in the regular expression optimizer has been fixed (RT#75762).
3118
3119=item *
3120
3121Assignments to lvalue subroutines now honor copy-on-write behavior again, which
3122has been broken since version 5.10.0 (RT#75656).
3123
3124=item *
3125
3126Assignments to glob copies now behave just like assignments to regular globs
3127(RT#1804).
3128
3129=item *
3130
3131Within signal handlers, C<$!> is now implicitly localized.
3132
3133=item *
3134
3135L<readline|perlfunc/"readline EXPR"> now honors C<< <> >> overloading on tied
3136arguments.
3137
3138=item *
3139
3140L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT">,
3141L<pos()|perlfunc/"index STR,SUBSTR,POSITION">, L<keys()|perlfunc/"keys HASH">,
3142and L<vec()|perlfunc/"vec EXPR,OFFSET,BITS"> could, when used in combination
3143with lvalues, result in leaking the scalar value they operate on, and cause its
3144destruction to happen too late. This has now been fixed.
3145
3146=item *
3147
5076a392
FC
3148A regression introduced in Perl 5.12.0, making
3149C<< my $x = 3; $x = length(undef) >> result in C<$x> set to C<3> has been
3150fixed. C<$x> will now be C<undef>.
3151
3152=item *
3153
3154A fatal error in regular expressions when processing UTF-8 data has been fixed [perl #75680].
3155
3156=item *
3157
54c7bb16 3158An erroneous regular expression engine optimisation that caused regex verbs like
5076a392
FC
3159C<*COMMIT> to sometimes be ignored has been removed.
3160
3161=item *
3162
3163The Perl debugger now also works in taint mode [perl #76872].
3164
3165=item *
3166
3167Several memory leaks in cloning and freeing threaded Perl interpreters have been
3168fixed [perl #77352].
3169
3170=item *
3171
3172A possible string corruption when doing regular expression matches on overloaded
3173objects has been fixed [perl #77084].
3174
3175=item *
3176
3177Magic applied to variables in the main package no longer affects other packages.
3178See L</Magic variables outside the main package> above [perl #76138].
3179
3180=item *
3181
3182Opening a glob reference via C<< open $fh, "E<gt>", \*glob >> will no longer
3183cause the glob to be corrupted when the filehandle is printed to. This would
3184cause perl to crash whenever the glob's contents were accessed
3185[perl #77492].
3186
3187=item *
3188
3189The postincrement and postdecrement operators, C<++> and C<-->, used to cause
3190leaks when being used on references. This has now been fixed.
3191
3192=item *
3193
3194A bug when replacing the glob of a loop variable within the loop has been fixed
3195[perl #21469]. This
3196means the following code will no longer crash:
3197
3198 for $x (...) {
3199 *x = *y;
3200 }
3201
3202=item *
3203
3204Perl would segfault if the undocumented C<Internals> functions that used
3205reference prototypes were called with the C<&foo()> syntax, e.g.
3206C<&Internals::SvREADONLY(undef)> [perl #77776].
3207
3208These functions now call C<SvROK> on their arguments before dereferencing them
3209with C<SvRV>, and we test for this case in F<t/lib/universal.t>.
3210
3211=item *
3212
3213When assigning a list with duplicated keys to a hash, the assignment used to
3214return garbage and/or freed values:
3215
3216 @a = %h = (list with some duplicate keys);
3217
3218This has now been fixed [perl #31865].
3219
3220=item *
3221
5076a392
FC
3222The regular expression bracketed character class C<[\8\9]> was effectively the
3223same as C<[89\000]>, incorrectly matching a NULL character. It also gave
3224incorrect warnings that the C<8> and C<9> were ignored. Now C<[\8\9]> is the
3225same as C<[89]> and gives legitimate warnings that C<\8> and C<\9> are
3226unrecognized escape sequences, passed-through.
3227
3228=item *
3229
3230C<warn()> and C<die()> now respect utf8-encoded scalars [perl #45549].
3231
3232=item *
3233
3234A regular expression match in the right-hand side of a global substitution
3235(C<s///g>) that is in the same scope will no longer cause match variables
3236to have the wrong values on subsequent iterations. This can happen when an
3237array or hash subscript is interpolated in the right-hand side, as in
3238C<s|(.)|@a{ print($1), /./ }|g> [perl #19078].
3239
3240=item *
3241
3242Constant-folding used to cause
3243
3244 $text =~ ( 1 ? /phoo/ : /bear/)
3245
3246to turn into
3247
3248 $text =~ /phoo/
3249
3250at compile time. Now it correctly matches against C<$_> [perl #20444].
3251
3252=item *
3253
3254Parsing Perl code (either with string C<eval> or by loading modules) from
3255within a C<UNITCHECK> block no longer causes the interpreter to crash
3256[perl #70614].
3257
3258=item *
3259
3260When C<-d> is used on the shebang (C<#!>) line, the debugger now has access
3261to the lines of the main program. In the past, this sometimes worked and
3262sometimes did not, depending on what order things happened to be arranged
3263in memory [perl #71806].
3264
3265=item *
3266
3267The C<y///> or C<tr///> operator now calls get-magic (e.g., the C<FETCH>
3268method of a tie) on its left-hand side just once, not twice [perl #76814].
3269
3270=item *
3271
5076a392
FC
3272The C<-C> command line option can now be followed by other options
3273[perl #72434].
3274
3275=item *
3276
3277Assigning a glob to a PVLV used to convert it to a plain string. Now it
3278works correctly, and a PVLV can hold a glob. This would happen when a
3279nonexistent hash or array element was passed to a subroutine:
3280
3281 sub { $_[0] = *foo }->($hash{key});
3282 # $_[0] would have been the string "*main::foo"
3283
3284It also happened when a glob was assigned to, or returned from, an element
3285of a tied array or hash [perl #36051].
3286
3287=item *
44691e6f 3288
5076a392
FC
3289Creating a new thread when directory handles were open used to cause a
3290crash, because the handles were not cloned, but simply passed to the new
3291thread, resulting in a double free.
44691e6f 3292
5076a392
FC
3293Now directory handles are cloned properly, on systems that have a C<fchdir>
3294function. On other systems, new threads simply do not inherit directory
3295handles from their parent threads [perl #75154].
44691e6f 3296
5076a392 3297=item *
44691e6f 3298
5076a392 3299Subroutine redefinition works once more in the debugger [perl #48332].
44691e6f 3300
5076a392 3301=item *
658a9f31 3302
5076a392
FC
3303The C<&> C<|> C<^> bitwise operators no longer coerce read-only arguments
3304[perl #20661].
658a9f31 3305
5076a392 3306=item *
658a9f31 3307
5076a392
FC
3308Stringifying a scalar containing -0.0 no longer has the affect of turning
3309false into true [perl #45133].
b7188eb5 3310
5076a392 3311=item *
b7188eb5 3312
5076a392
FC
3313Aliasing packages by assigning to globs or deleting packages by deleting
3314their containing stash elements used to have erratic effects on method
3315resolution, because the internal 'isa' caches were not reset. This has been
3316fixed.
b7188eb5 3317
5076a392 3318=item *
3aa0ac5a 3319
5076a392
FC
3320The C<eval_sv> and C<eval_pv> C functions now set C<$@> correctly when
3321there is a syntax error and no C<G_KEEPERR> flag, and never set it if the
3322C<G_KEEPERR> flag is present [perl #3719].
270ca148 3323
5076a392 3324=item *
270ca148 3325
5076a392
FC
3326Nested C<map> and C<grep> blocks no longer leak memory when processing
3327large lists [perl #48004].
270ca148 3328
5076a392 3329=item *
44691e6f 3330
5076a392 3331Malformed C<version> objects no longer cause crashes [perl #78286].
44691e6f
AB
3332
3333=item *
3334
5076a392
FC
3335The interpreter no longer crashes when freeing deeply-nested arrays of
3336arrays. Hashes have not been fixed yet [perl #44225].
44691e6f 3337
5076a392 3338=item *
44691e6f 3339
5076a392
FC
3340The mechanism for freeing objects in globs used to leave dangling
3341pointers to freed SVs, meaning Perl users could see corrupted state
3342during destruction.
44691e6f 3343
5076a392
FC
3344Perl now only frees the affected slots of the GV, rather than freeing
3345the GV itself. This makes sure that there are no dangling refs or
3346corrupted state during destruction.
65484cb9 3347
5076a392 3348=item *
b7188eb5 3349
5076a392
FC
3350The typeglob C<*,>, which holds the scalar variable C<$,> (output field
3351separator), had the wrong reference count in child threads.
911a3729 3352
5076a392
FC
3353=item *
3354
3355C<splice> now calls set-magic. This means that, for instance, changes made
3356by C<splice @ISA> are respected by method calls [perl #78400].
452d0b70
DG
3357
3358=item *
3359
5076a392 3360C<use v5.8> no longer leaks memory [perl #78436].
911a3729 3361
5076a392 3362=item *
c8c13991 3363
5076a392
FC
3364The XS multicall API no longer causes subroutines to lose reference counts
3365if called via the multicall interface from within those very subroutines.
3366This affects modules like List::Util. Calling one of its functions with an
3367active subroutine as the first argument could cause a crash [perl #78070].
c8c13991 3368
5076a392
FC
3369=item *
3370
5076a392
FC
3371Characters in the Latin-1 non-ASCII range (0x80 to 0xFF) used not to match
3372themselves if the string happened to be UTF8-encoded internally, the
3373regular expression was not, and the character in the regular expression was
3374inside a repeated group (e.g.,
3375C<Encode::decode_utf8("\303\200") =~ /(\xc0)+/>) [perl #78464].
35cdccfc 3376
5076a392
FC
3377=item *
3378
5076a392
FC
3379Various bugs related to typeglob dereferencing have been fixed. See
3380L</Dereferencing typeglobs>, above.
0bb35765 3381
5076a392 3382=item *
911a3729 3383
5076a392
FC
3384The C<SvPVbyte> function available to XS modules now calls magic before
3385downgrading the SV, to avoid warnings about wide characters [perl #72398].
911a3729 3386
5076a392 3387=item *
58f55cb3 3388
5076a392
FC
3389The C<=> operator used to ignore magic (e.g., tie methods) on its
3390right-hand side if the scalar happened to hold a typeglob. This could
3391happen if a typeglob was the last thing returned from or assigned to a tied
3392scalar [perl #77498].
58f55cb3 3393
5076a392 3394=item *
6b3df227 3395
5076a392
FC
3396C<sprintf> was ignoring locales when called with constant arguments
3397[perl #78632].
6b3df227 3398
5076a392 3399=item *
c9989a74 3400
5076a392
FC
3401A non-ASCII character in the Latin-1 range could match both a Posix
3402class, such as C<[[:alnum:]]>, and its inverse C<[[:^alnum:]]>. This is
3403now fixed for regular expressions compiled under the C<"u"> modifier.
3404See L</C<use feature "unicode_strings"> now applies to more regex matching>. [perl #18281].
c9989a74 3405
5076a392
FC
3406=item *
3407
3408Concatenating long strings under C<use encoding> no longer causes perl to
3409crash [perl #78674].
b7188eb5
FC
3410
3411=item *
3412
5076a392
FC
3413Typeglob assignments would crash if the glob's stash no longer existed, so
3414long as the glob assigned to was named 'ISA' or the glob on either side of
3415the assignment contained a subroutine.
911a3729 3416
5076a392 3417=item *
c8c13991 3418
5076a392
FC
3419Calling C<< ->import >> on a class lacking an import method could corrupt
3420the stack, resulting in strange behaviour. For instance,
c8c13991 3421
5076a392 3422 push @a, "foo", $b = bar->import;
f00d3350 3423
5076a392 3424would assign 'foo' to C<$b> [perl #63790].
c34a735e 3425
5076a392 3426=item *
b7188eb5 3427
5076a392
FC
3428Creating an alias to a package when that package had been detached from the
3429symbol table would result in corrupted isa caches [perl #77358].
b7188eb5 3430
5076a392 3431=item *
b7188eb5 3432
5076a392
FC
3433C<.=> followed by C<< <> >> or C<readline> would leak memory if C<$/>
3434contained characters beyond the octet range and the scalar assigned to
3435happened to be encoded as UTF8 internally [perl #72246].
c34a735e 3436
05dbc6f8
KW
3437=item *
3438
5076a392
FC
3439The C<recv> function could crash when called with the MSG_TRUNC flag
3440[perl #75082].
7b98b857 3441
5076a392 3442=item *
05dbc6f8 3443
5076a392
FC
3444Matching a Unicode character against an alternation containing characters
3445that happened to match continuation bytes in the former's UTF8
3446representation (C<qq{\x{30ab}} =~ /\xab|\xa9/>) would cause erroneous
3447warnings [perl #70998].
05dbc6f8
KW
3448
3449=item *
3450
5076a392
FC
3451The trie optimisation was not taking empty groups into account, preventing
3452'foo' from matching C</\A(?:(?:)foo|bar|zot)\z/> [perl #78356].
05dbc6f8 3453
5076a392 3454=item *
05dbc6f8 3455
5076a392
FC
3456A pattern containing a C<+> inside a lookahead would sometimes cause an
3457incorrect match failure in a global match (e.g., C</(?=(\S+))/g>)
3458[perl #68564].
05dbc6f8 3459
5076a392 3460=item *
05dbc6f8 3461
5076a392
FC
3462Iterating with C<foreach> over an array returned by an lvalue sub now works
3463[perl #23790].
05dbc6f8
KW
3464
3465=item *
3466
5076a392
FC
3467C<$@> is now localised during calls to C<binmode> to prevent action at a
3468distance [perl #78844].
05dbc6f8 3469
5076a392 3470=item *
05dbc6f8 3471
5076a392
FC
3472C<PL_isarev>, which is accessible to Perl via C<mro::get_isarev> is now
3473updated properly when packages are deleted or removed from the C<@ISA> of
3474other classes. This allows many packages to be created and deleted without
3475causing a memory leak [perl #75176].
8079ad82 3476
5076a392 3477=item *
4d56cd4f 3478
5076a392
FC
3479C<undef *Foo::> and C<undef *Foo::ISA> and C<delete $package::{ISA}>
3480used not to update the internal isa caches if the
3481stash or C<@ISA> array had a reference elsewhere. In
3482fact, C<undef *Foo::ISA> would stop a new C<@Foo::ISA> array from updating
3483caches.
4d56cd4f 3484
5076a392
FC
3485=item *
3486
3487C<@ISA> arrays can now be shared between classes via
3488C<*Foo::ISA = \@Bar::ISA> or C<*Foo::ISA = *Bar::ISA> [perl #77238].
05dbc6f8 3489
911a3729
FC
3490=item *
3491
5076a392
FC
3492The parser no longer hangs when encountering certain Unicode characters,
3493such as U+387 [perl #74022].
911a3729 3494
5076a392 3495=item *
44691e6f 3496
5076a392
FC
3497C<formline> no longer crashes when passed a tainted format picture. It also
3498taints C<$^A> now if its arguments are tainted [perl #79138].
44691e6f 3499
5076a392 3500=item *
44691e6f 3501
5076a392
FC
3502A signal handler called within a signal handler could cause leaks or
3503double-frees. Now fixed. [perl #76248].
9dc513c5 3504
5076a392
FC
3505=item *
3506
3507When trying to report C<Use of uninitialized value $Foo::BAR>, crashes could
3508occur if the GLOB of the global variable causing the warning has been detached
3509from its original stash by, for example C<delete $::{'Foo::'}>. This has been
3510fixed by disabling the reporting of variable names in the warning in those
3511cases.
9dc513c5
DG
3512
3513=item *
3514
5076a392
FC
3515C<BEGIN {require 5.12.0}> now behaves as documented, rather than behaving
3516identically to C<use 5.12.0;>. Previously, C<require> in a C<BEGIN> block
3517was erroneously executing the C<use feature ':5.12.0'> and
3518C<use strict; use warnings;> behaviour, which only C<use> was documented to
3519provide [perl #69050].
9dc513c5 3520
5076a392 3521=item *
9dc513c5 3522
5076a392
FC
3523C<use 5.42> [perl #69050],
3524C<use 6> and C<no 5> no longer leak memory.
44691e6f 3525
5076a392 3526=item *
6d96b0fe 3527
5076a392 3528C<eval "BEGIN{die}"> no longer leaks memory on non-threaded builds.
6d96b0fe 3529
5076a392 3530=item *
6d96b0fe 3531
5076a392
FC
3532PerlIO no longer crashes when called recursively, e.g., from a signal
3533handler. Now it just leaks memory [perl #75556].
6d96b0fe 3534
5076a392 3535=item *
b7188eb5 3536
5076a392
FC
3537Defining a constant with the same name as one of perl's special blocks
3538(e.g., INIT) stopped working in 5.12.0, but has now been fixed
3539[perl #78634].
b7188eb5 3540
5076a392 3541=item *
b7188eb5 3542
5076a392
FC
3543A reference to a literal value used as a hash key (C<$hash{\"foo"}>) used
3544to be stringified, even if the hash was tied [perl #79178].
44691e6f 3545
5076a392 3546=item *
44691e6f 3547
5076a392
FC
3548A closure containing an C<if> statement followed by a constant or variable
3549is no longer treated as a constant [perl #63540].
44691e6f 3550
5076a392 3551=item *
44691e6f 3552
5076a392
FC
3553Calling a closure prototype (what is passed to an attribute handler for a
3554closure) now results in a "Closure prototype called" error message instead
3555of a crash [perl #68560].
44691e6f 3556
5076a392 3557=item *
b7188eb5 3558
5076a392
FC
3559A regular expression optimisation would sometimes cause a match with a
3560C<{n,m}> quantifier to fail when it should match [perl #79152].
b7188eb5 3561
5076a392 3562=item *
b7188eb5 3563
5076a392
FC
3564What has become known as the "Unicode Bug" is mostly resolved in this release.
3565Under C<use feature 'unicode_strings'>, the internal storage format of a
3566string no longer affects the external semantics. There are two known
3567exceptions. User-defined case changing functions, which are planned to
3568be deprecated in 5.14, require utf8-encoded strings to function; and the
3569character C<LATIN SMALL LETTER SHARP S> in regular expression
3570case-insensitive matching has a somewhat different set of bugs depending
3571on the internal storage format. Case-insensitive matching of all
3572characters that have multi-character matches, as this one does, is
3573problematical in Perl [perl #58182].
b7188eb5 3574
5076a392 3575=item *
44691e6f 3576
5076a392
FC
3577Mentioning a read-only lexical variable from the enclosing scope in a
3578string C<eval> no longer causes the variable to become writable
3579[perl #19135].
6c9cd4a1 3580
5076a392 3581=item *
6c9cd4a1 3582
5076a392
FC
3583C<state> can now be used with attributes. It used to mean the same thing as
3584C<my> if attributes were present [perl #68658].
44691e6f 3585
5076a392 3586=item *
44691e6f 3587
5076a392
FC
3588Expressions like C<< @$a > 3 >> no longer cause C<$a> to be mentioned in
3589the "Use of uninitialized value in numeric gt" warning when C<$a> is
3590undefined (since it is not part of the C<E<gt>> expression, but the operand
3591of the C<@>) [perl #72090].
44691e6f 3592
5076a392 3593=item *
44691e6f 3594
5076a392
FC
3595C<require> no longer causes C<caller> to return the wrong file name for
3596the scope that called C<require> and other scopes higher up that had the
3597same file name [perl #68712].
b7188eb5
FC
3598
3599=item *
3600
5076a392
FC
3601The ref types in the typemap for XS bindings now support magical variables
3602[perl #72684].
b7188eb5 3603
5076a392 3604=item *
b7188eb5 3605
5076a392
FC
3606Match variables (e.g., C<$1>) no longer persist between calls to a sort
3607subroutine [perl #76026].
b7188eb5 3608
5076a392 3609=item *
b7188eb5 3610
5076a392
FC
3611The C<B> module was returning C<B::OP>s instead of C<B::LOGOP>s for C<entertry> [perl #80622].
3612This was due to a bug in the perl core, not in C<B> itself.
b7188eb5 3613
5076a392
FC
3614=item *
3615
3616Some numeric operators were converting integers to floating point,
3617resulting in loss of precision on 64-bit platforms [perl #77456].
b7188eb5
FC
3618
3619=item *