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