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