This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perldelta: Sort out the platform 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
87595b22
FC
2275CCINCDIR and CCLIBDIR for the mingw64
2276cross-compiler are now correctly under
5076a392
FC
2277$(CCHOME)\mingw\include and \lib rather than immediately below $(CCHOME).
2278
5076a392
FC
2279This means the 'incpath', 'libpth', 'ldflags', 'lddlflags' and
2280'ldflags_nolargefiles' values in Config.pm and Config_heavy.pl are now
87595b22 2281set correctly.
5076a392
FC
2282
2283=item *
2284
87595b22
FC
2285'make test.valgrind' has been adjusted to account for cpan/dist/ext
2286separation.
5076a392
FC
2287
2288=item *
2289
2290On compilers that support it, C<-Wwrite-strings> is now added to cflags by
2291default.
2292
2293=item *
2294
2295The C<Encode> module can now (once again) be included in a static Perl
2296build. The special-case handling for this situation got broken in Perl
22975.11.0, and has now been repaired.
2298
2299=back
2300
2301=head1 Testing
2302
6eff4dda
FC
2303XXX This section has not been cleaned up yet. Do we really need this
2304section? How many people are going to find a list of new test files useful?
2305Anyone hacking on the core can use
2306‘git diff v5.12.0..v5.14.0 MANIFEST|grep '^[+-]t/'’.
2307
5076a392
FC
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
5076a392
FC
2449=head2 New Platforms
2450
5076a392
FC
2451=over 4
2452
2453=item AIX
2454
2455Perl now builds on AIX 4.2.
2456
2457=back
2458
2459=head2 Discontinued Platforms
2460
2461=over 4
2462
5076a392
FC
2463=item Apollo DomainOS
2464
2465The last vestiges of support for this platform have been excised from the
2466Perl distribution. It was officially discontinued in version 5.12.0. It had
2467not worked for years before that.
2468
2469=item MacOS Classic
2470
2471The last vestiges of support for this platform have been excised from the
2472Perl distribution. It was officially discontinued in an earlier version.
2473
2474=back
2475
2476=head2 Platform-Specific Notes
2477
554003a2 2478=head3 Cygwin
5076a392
FC
2479
2480=over 4
2481
2482=item *
2483
554003a2 2484MakeMaker has been updated to build man pages on cygwin.
5076a392
FC
2485
2486=item *
2487
554003a2
FC
2488Improved rebase behaviour
2489
2490If a dll is updated on cygwin the old imagebase address is reused.
2491This solves most rebase errors, especially when updating on core dll's.
2492See L<http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README> for more information.
5076a392
FC
2493
2494=item *
2495
554003a2 2496Support for the standard cygwin dll prefix, which is e.g. needed for FFI's
5076a392
FC
2497
2498=item *
2499
554003a2 2500Updated build hints file
5076a392
FC
2501
2502=back
2503
554003a2 2504=head3 IRIX
5076a392
FC
2505
2506Conversion of strings to floating-point numbers is now more accurate on
2507IRIX systems [perl #32380].
2508
554003a2 2509=head3 Mac OS X
5076a392
FC
2510
2511Early versions of Mac OS X (Darwin) had buggy implementations of the
2512C<setregid>, C<setreuid>, C<setrgid> and C<setruid> functions, so perl
2513would pretend they did not exist.
2514
2515These functions are now recognised on Mac OS 10.5 (Leopard; Darwin 9) and
2516higher, as they have been fixed [perl #72990].
2517
554003a2 2518=head3 MirBSD
5076a392 2519
554003a2
FC
2520Previously if you built perl with a shared libperl.so on MirBSD (the
2521default config), it would work up to the installation; however, once
2522installed, it would be unable to find libperl. So path handling is now
2523treated as in the other BSD dialects.
5076a392 2524
554003a2 2525=head3 NetBSD
5076a392 2526
554003a2
FC
2527The NetBSD hints file has been changed to make the system's malloc the
2528default.
5076a392 2529
554003a2 2530=head3 Recent OpenBSDs now use perl's malloc
5076a392 2531
554003a2
FC
2532OpenBSD E<gt> 3.7 has a new malloc implementation which is mmap-based
2533and as such can release memory back to the OS; however, perl's use of
2534this malloc causes a substantial slowdown so we now default to using
2535perl's malloc instead [perl #75742].
5076a392 2536
554003a2 2537=head3 OpenVOS
5076a392 2538
554003a2
FC
2539perl now builds again with OpenVOS (formerly known as Stratus VOS)
2540[perl #78132].
5076a392 2541
554003a2 2542=head3 Solaris
5076a392 2543
554003a2
FC
2544DTrace is now supported on Solaris. There used to be build failures, but
2545these have been fixed [perl #73630].
5076a392 2546
554003a2 2547=head3 VMS
5076a392
FC
2548
2549=over
2550
2551=item *
2552
554003a2 2553C<PerlIOUnix_open> now honours the default permissions on VMS.
5076a392 2554
554003a2
FC
2555When C<perlio> became the default and C<unixio> became the default bottom layer,
2556the most common path for creating files from Perl became C<PerlIOUnix_open>,
2557which has always explicitly used C<0666> as the permission mask.
5076a392 2558
554003a2
FC
2559To avoid this, C<0777> is now passed as the permissions to C<open()>. In the
2560VMS CRTL, C<0777> has a special meaning over and above intersecting with the
2561current umask; specifically, it allows Unix syscalls to preserve native default
2562permissions.
5076a392
FC
2563
2564=item *
2565
554003a2
FC
2566The shortening of symbols longer than 31 characters in the C sources is
2567now done by the compiler rather than by xsubpp (which could only do so
2568for generated symbols in XS code).
5076a392
FC
2569
2570=item *
2571
554003a2
FC
2572Record-oriented files (record format variable or variable with fixed control)
2573opened for write by the perlio layer will now be line-buffered to prevent the
2574introduction of spurious line breaks whenever the perlio buffer fills up.
5076a392
FC
2575
2576=back
2577
554003a2 2578=head3 Windows
5076a392
FC
2579
2580=over 4
2581
2582=item *
2583
554003a2 2584Fixed build process for SDK2003SP1 compilers.
5076a392 2585
554003a2 2586=item *
5076a392 2587
554003a2
FC
2588When using old 32-bit compilers, the define C<_USE_32BIT_TIME_T> will now
2589be set in C<$Config{ccflags}>. This improves portability when compiling
2590XS extensions using new compilers, but for a perl compiled with old 32-bit
2591compilers.
5076a392
FC
2592
2593=item *
2594
554003a2
FC
2595C<$Config{gccversion}> is now set correctly when perl is built using the
2596mingw64 compiler from L<http://mingw64.org> [perl #73754].
5076a392 2597
554003a2
FC
2598=item *
2599
2600The build process proceeds more smoothly with mingw and dmake when
2601F<C:\MSYS\bin> is in the PATH, due to a C<Cwd> fix.
5076a392
FC
2602
2603=item *
2604
554003a2
FC
2605Support for building with Visual C++ 2010 is now underway, but is not yet
2606complete. See F<README.win32> or L<perlwin32> for more details.
5076a392 2607
554003a2
FC
2608=item *
2609
2610The option to use an externally-supplied C<crypt()>, or to build with no
2611C<crypt()> at all, has been removed. Perl supplies its own C<crypt()>
2612implementation for Windows, and the political situation that required
2613this part of the distribution to sometimes be omitted is long gone.
5076a392
FC
2614
2615=back
2616
2617=head1 Internal Changes
2618
aa81da68 2619See also L</New C APIs>, L</C API Changes> and L</Deprecated C APIs>, above.
f8e88449 2620
5076a392
FC
2621=over 4
2622
2623=item *
2624
2625The protocol for unwinding the C stack at the last stage of a C<die>
2626has changed how it identifies the target stack frame. This now uses
2627a separate variable C<PL_restartjmpenv>, where previously it relied on
2628the C<blk_eval.cur_top_env> pointer in the C<eval> context frame that
2629has nominally just been discarded. This change means that code running
2630during various stages of Perl-level unwinding no longer needs to take
2631care to avoid destroying the ghost frame.
2632
2633=item *
2634
2635The format of entries on the scope stack has been changed, resulting in a
2636reduction of memory usage of about 10%. In particular, the memory used by
2637the scope stack to record each active lexical variable has been halved.
2638
2639=item *
2640
2641Memory allocation for pointer tables has been changed. Previously
2642C<Perl_ptr_table_store> allocated memory from the same arena system as C<SV>
2643bodies and C<HE>s, with freed memory remaining bound to those arenas until
2644interpreter exit. Now it allocates memory from arenas private to the specific
2645pointer table, and that memory is returned to the system when
2646C<Perl_ptr_table_free> is called. Additionally, allocation and release are both
2647less CPU intensive.
2648
2649=item *
2650
2651A new function, Perl_magic_methcall has been added that wraps the setup needed
2652to call a magic method like FETCH (the existing S_magic_methcall function has
2653been renamed S_magic_methcall1).
2654
2655=item *
2656
2657The implementation of sv_dup_inc() has changed from a macro to a function.
2658
2659=item *
2660
2661The C<find_rundefsvoffset> function has been deprecated. It appeared that
2662its design was insufficient to reliably get the lexical C<$_> at run-time.
2663
2664Use the new C<find_rundefsv> function or the C<UNDERBAR> macro instead.
2665They directly return the right SV representing C<$_>, whether it's lexical
2666or dynamic (789bd8 .. 03d5bc).
2667
2668=item *
2669
2670The following new functions or macros have been added to the public API:
2671C<SvNV_nomg>, C<sv_2nv_flags>, C<find_rundefsv>.
2672
2673=item *
2674
2675The C<UNDERBAR> macro now calls C<find_rundefsv>. C<dUNDERBAR> is now a
2676noop but should still be used to ensure past and future compatibility.
2677
2678=item *
2679
2680The ibcmp_* functions have been renamed and are now called foldEQ,
2681foldEQ_locale and foldEQ_utf8 (e6226b).
2682
2683=item *
2684
2685Under some circumstances, the C<CvGV()> field of a CV is now reference
2686counted. To ensure consistent behaviour, direct assignment to it, for
2687example C<CvGV(cv) = gv> is now a compile-time error. A new macro,
2688C<CvGV_set(cv,gv)> has been introduced to perform this operation safely.
2689Note that modification of this field is not part of of the public API,
2690regardless of this new macro. This change caused some
2691L<issues|/"Known Problems"> in modules that used the private C<GvGV()>
2692field.
2693
2694=item *
2695
2696It is now possible for XS code to hook into Perl's lexical scope
2697mechanism at compile time, using the new C<Perl_blockhook_register>
2698function. See L<perlguts/"Compile-time scope hooks">.
2699
2700=item *
2701
2702Added C<Perl_croak_no_modify()> to implement
2703C<Perl_croak("%s", PL_no_modify)> (6ad8f25)
2704
2705=item *
2706
2707Added prototypes for C<tie()> and C<untie()> to allow overloading (RT#75902)
2708(1db4d19)
2709
2710=item *
2711
2712Adds C<my_[l]stat_flags()> to replace C<my_[l]stat()>. C<my_stat()> and
2713C<my_lstat()> call get magic on the stack arg, so create C<_flags()>
2714variants that allow us to control this. (0d7d409)
2715
2716=item *
2717
2718Removed C<PERL_POLLUTE>
2719
2720The option to define C<PERL_POLLUTE> to expose older 5.005 symbols for backwards
2721compatibility has been removed. It's use was always discouraged, and MakeMaker
2722contains a more specific escape hatch:
2723
2724 perl Makefile.PL POLLUTE=1
2725
2726This can be used for modules that have not been upgraded to 5.6 naming
2727conventions (and really should be completely obsolete by now).
2728
2729=item *
2730
2731Added C<PERL_STATIC_INLINE>
2732
2733The C<PERL_STATIC_INLINE> define has been added to provide the best-guess
2734incantation to use for static inline functions, if the C compiler supports
2735C99-style static inline. If it doesn't, it'll give a plain C<static>.
2736
2737C<HAS_STATIC_INLINE> can be used to check if the compiler actually supports
2738inline functions.
2739
2740=item *
2741
2742C<CALL_FPTR> and C<CPERLscope> have been deprecated.
2743
2744Those are left from an old implementation of C<MULTIPLICITY> using C++ objects,
2745which was removed in Perl 5.8. Nowadays these macros do exactly nothing, so
2746they shouldn't be used anymore.
2747
2748For compatibility, they are still defined for external C<XS> code. Only
2749extensions defining C<PERL_CORE> must be updated now.
2750
2751=item *
2752
2753C<lex_stuff_pvs()> has been added as a convenience macro wrapping
2754C<lex_stuff_pvn()> for literal strings.
2755
2756=item *
2757
2758The recursive part of the peephole optimizer is now hookable.
2759
2760In addition to C<PL_peepp>, for hooking into the toplevel peephole optimizer, a
2761C<PL_rpeepp> is now available to hook into the optimizer recursing into
2762side-chains of the optree.
2763
2764=item *
2765
2766See L</Regular expressions retain their localeness when interpolated>,
2767above.
2768
2769=item *
2770
2771The C<sv_cmp_flags>, C<sv_cmp_locale_flags>, C<sv_eq_flags> and
2772C<sv_collxfrm_flags> functions have been added. These are like their
2773non-_flags counterparts, but allow one to specify whether get-magic is
2774processed.
2775
2776The C<sv_cmp>, C<sv_cmp_locale>, C<sv_eq> and C<sv_collxfrm> functions have
2777been replaced with wrappers around the new functions.
2778
2779=item *
2780
2781A new C<sv_2bool_flags> function has been added.
2782
2783This is like C<sv_2bool>, but it lets the calling code decide whether
2784get-magic is handled. C<sv_2bool> is now a macro that calls the new
2785function.
2786
2787=item *
2788
2789A new macro, C<SvTRUE_nomg>, has been added.
2790
2791This is like C<SvTRUE>, except that it does not process magic. It uses the
2792new C<sv_2bool_flags> function.
2793
2794=item *
2795
2796C<sv_catsv_flags> no longer calls C<mg_get> on its second argument (the
2797source string) if the flags passed to it do not include SV_GMAGIC. So it
2798now matches the documentation.
2799
2800=item *
2801
2802A new interface has been added for custom check hooks on subroutines. See
2803L</Custom per-subroutine check hooks>, above.
2804
2805=item *
2806
2807List op building functions have been added to the
2808API. See L<op_append_elem|perlapi/op_append_elem>,
2809L<op_append_list|perlapi/op_append_list>, and
2810L<op_prepend_elem|perlapi/op_prepend_elem>.
2811
2812=item *
2813
2814The L<LINKLIST|perlapi/LINKLIST> macro, part of op building that
2815constructs the execution-order op chain, has been added to the API.
2816
2817=item *
2818
2819Many functions ending with pvn now have equivalent pv/pvs/sv versions.
2820
2821=item *
2822
2823The C<save_freeop>, C<save_op>, C<save_pushi32ptr> and C<save_pushptrptr>
2824functions have been added to the API.
2825
2826=item *
2827
2828The new API function C<parse_stmtseq()> parses a sequence of statements, up
2829to closing brace or EOF.
2830
2831=item *
2832
2833C<lex_start> has been added to the API, but is considered experimental.
2834
2835=item *
2836
2837A new C<parse_block> function has been added to the API [perl #78222].
2838
2839=item *
2840
2841A new, experimental API has been added for accessing the internal
2842structure that Perl uses for C<%^H>. See the functions beginning with
2843C<cophh_> in L<perlapi>.
2844
2845=item *
2846
2847A stash can now have a list of effective names in addition to its usual
2848name. The first effective name can be accessed via the C<HvENAME> macro,
2849which is now the recommended name to use in MRO linearisations (C<HvNAME>
2850being a fallback if there is no C<HvENAME>).
2851
2852These names are added and deleted via C<hv_ename_add> and
2853C<hv_ename_delete>. These two functions are I<not> part of the API.
2854
2855=item *
2856
2857The way the parser handles labels has been cleaned up and refactored. As a
2858result, the C<newFOROP()> constructor function no longer takes a parameter
2859stating what label is to go in the state op.
2860
2861=item *
2862
2863The C<newWHILEOP()> and C<newFOROP()> functions no longer accept a line
2864number as a parameter.
2865
2866=item *
2867
2868A new C<parse_barestmt()> function has been added, for parsing a statement
2869without a label.
2870
2871=item *
2872
2873A new C<parse_label()> function has been added, that parses a statement
2874label, separate from statements.
2875
2876=item *
2877
2878The C<CvSTASH()> macro can now only be used as an rvalue. C<CvSTASH_set()>
2879has been added to replace assignment to C<CvSTASH()>. This is to ensure
2880that backreferences are handled properly. These macros are not part of the
2881API.
2882
2883=item *
2884
2885The C<op_scope()> and C<op_lvalue()> functions have been added to the API,
2886but are considered experimental.
2887
2888=item *
2889
2890The L<C<mg_findext()>|perlapi/mg_findext> and
2891L<C<sv_unmagicext()>|perlapi/sv_unmagicext>
2892functions have been added to the API.
2893They allow extension authors to find and remove magic attached to
2894scalars based on both the magic type and the magic virtual table, similar to how
2895C<sv_magicext()> attaches magic of a certain type and with a given virtual table
2896to a scalar. This eliminates the need for extensions to walk the list of
2897C<MAGIC> pointers of an C<SV> to find the magic that belongs to them.
2898
2899=item *
2900
2901The
2902L<C<parse_fullexpr()>|perlapi/parse_fullexpr>,
2903L<C<parse_listexpr()>|perlapi/parse_listexpr>,
2904L<C<parse_termexpr()>|perlapi/parse_termexpr>, and
2905L<C<parse_arithexpr()>|perlapi/parse_arithexpr>
2906functions have been added to the API. They perform
2907recursive-descent parsing of expressions at various precedence levels.
2908They are expected to be used by syntax plugins.
2909
2910=item *
2911
2912The opcode bodies for C<chop> and C<chomp> and for C<schop> and C<schomp> have
2913been merged. The implementation functions C<Perl_do_chop()> and
2914C<Perl_do_chomp()>, never part of the public API, have been merged and moved to
2915a static function in F<pp.c>. This shrinks the perl binary slightly, and should
2916not affect any code outside the core (unless it is relying on the order of side
2917effects when C<chomp> is passed a I<list> of values).
2918
2919=item *
2920
2921Some of the flags parameters to the uvuni_to_utf8_flags() and
2922utf8n_to_uvuni() have changed. This is a result of Perl now allowing
2923internal storage and manipulation of code points that are problematic
2924in some situations. Hence, the default actions for these functions has
2925been complemented to allow these code points. The new flags are
2926documented in L<perlapi>. Code that requires the problematic code
2927points to be rejected needs to change to use these flags. Some flag
2928names are retained for backward source compatibility, though they do
2929nothing, as they are now the default. However the flags
2930C<UNICODE_ALLOW_FDD0>, C<UNICODE_ALLOW_FFFF>, C<UNICODE_ILLEGAL>, and
2931C<UNICODE_IS_ILLEGAL> have been removed, as they stem from a
2932fundamentally broken model of how the Unicode non-character code points
2933should be handled, which is now described in
2934L<perlunicode/Non-character code points>. See also L</Selected Bug Fixes>.
2935
2936=item *
2937
2938Certain shared flags in the C<pmop.op_pmflags> and C<regexp.extflags>
2939structures have been removed. These are: C<Rxf_Pmf_LOCALE>,
2940C<Rxf_Pmf_UNICODE>, and C<PMf_LOCALE>. Instead there are encodes and
2941three static in-line functions for accessing the information:
2942C<get_regex_charset()>, C<set_regex_charset()>, and C<get_regex_charset_name()>,
2943which are defined in the places where the original flags were.
2944
2945=item *
2946
2947A new option has been added to C<pv_escape> to dump all characters above
2948ASCII in hexadecimal. Before, one could get all characters as hexadecimal
2949or the Latin1 non-ASCII as octal
2950
2951
2952=item *
2953
2954Generate pp_* prototypes in pp_proto.h, and remove pp.sym
2955
2956Eliminate the #define pp_foo Perl_pp_foo(pTHX) macros, and update the 13
2957locations that relied on them.
2958
2959regen/opcode.pl now generates prototypes for the PP functions directly, into
2960pp_proto.h. It no longer writes pp.sym, and regen/embed.pl no longer reads
2961this, removing the only ordering dependency in the regen scripts. opcode.pl
2962is now responsible for prototypes for pp_* functions. (embed.pl remains
2963responsible for ck_* functions, reading from regen/opcodes)
2964
2965=item *
2966
2967Fix harmless invalid read in Perl_re_compile() (f6d9469)
2968
2969[perl #2460] described a case where electric fence reported an invalid
2970read. This could be reproduced under valgrind with blead and -e'/x/',
2971but only on a non-debugging build.
2972
2973This was because it was checking for certain pairs of nodes (e.g. BOL + END)
2974and wasn't allowing for EXACT nodes, which have the string at the next
2975node position when using a naive NEXTOPER(first). In the non-debugging
2976build, the nodes aren't initialised to zero, and a 1-char EXACT node isn't
2977long enough to spill into the type field of the "next node".
2978
2979Fix this by only using NEXTOPER(first) when we know the first node is
2980kosher.
2981
2982=item *
2983
2984Break out the generated function Perl_keywords() into F<keywords.c>, a new file. (26ea9e1)
2985
2986As it and Perl_yylex() both need FEATURE_IS_ENABLED, feature_is_enabled() is
2987no longer static, and the two macro definitions move from toke.c to perl.h
2988
2989Previously, one had to cut and paste the output of perl_keywords.pl into the
2990middle of toke.c, and it was not clear that it was generated code.
2991
2992=item *
2993
2994A lot of tests have been ported from Test to Test::More, e.g. in
29953842ad6.
2996
2997=item *
2998
2999Increase default PerlIO buffer size. (b83080d)
3000
3001The previous default size of a PerlIO buffer (4096 bytes) has been increased
3002to the larger of 8192 bytes and your local BUFSIZ. Benchmarks show that doubling
3003this decade-old default increases read and write performance in the neighborhood
3004of 25% to 50% when using the default layers of perlio on top of unix. To choose
3005a non-default size, such as to get back the old value or to obtain and even
3006larger value, configure with:
3007
3008 ./Configure -Accflags=-DPERLIOBUF_DEFAULT_BUFSIZ=N
3009
3010where N is the desired size in bytes; it should probably be a multiple of
3011your page size.
3012
3013=back
3014
3015=head1 Selected Bug Fixes
3016
3017=over 4
3018
3019=item *
3020
a593b319
FC
3021C<binmode $fh, ':scalar'> no longer warns (8250589)
3022
3023Perl will now no longer produce this warning:
3024
3025 $ perl -we 'open my $f, ">", \my $x; binmode $f, "scalar"'
3026 Use of uninitialized value in binmode at -e line 1.
3027
3028=item *
3029
4ed2cea4
FC
3030C<when(scalar){...}> no longer crashes, but produces a syntax error
3031[perl #74114].
3032
3033=item *
3034
3035The C-level C<lex_stuff_pvn> function would sometimes cause a spurious
3036syntax error on the last line of the file if it lacked a final semicolon
3037[perl #74006].
3038
3039=item *
3040
3041The regular expression engine no longer loops when matching
3042C<"\N{LATIN SMALL LIGATURE FF}" =~ /f+/i> and similar expressions
3043[perl #72998].
3044
3045=item *
3046
3047A label right before a string eval (C<foo: eval $string>) no longer causes
3048the label to be associated also with the first statement inside the eval
3049[perl #74290] (5.12.1).
3050
3051=item *
3052
5076a392
FC
3053Naming a deprecated character in \N{...} will not leak memory.
3054
3055=item *
3056
3057FETCH is no longer called needlessly on some tied variables.
3058
3059=item *
3060
3061The trie runtime code should no longer allocate massive amounts of memory,
3062fixing #74484.
3063
3064=item *
3065
3066Timely cleanup of SVs that are cloned into a new thread but then
3067discovered to be orphaned (i.e. their owners are -not- cloned) (e42956)
3068
3069=item *
3070
3071Don't accidentally clone lexicals in scope within active stack frames in
3072the parent when creating a child thread (RT #73086) (05d04d).
3073
3074=item *
3075
3076Avoid loading feature.pm when 'no 5.13.2;' or similar is
3077encountered (faee19).
3078
3079=item *
3080
3081Trap invalid use of SvIVX on SVt_REGEXP when assertions are on
3082(e77da3)
3083
3084=item *
3085
3086Don't stamp on $DB::single, $DB::trace and $DB::signal if they
3087already have values when $^P is assigned to (RT #72422) (4c0f30).
3088
3089=item *
3090
3091chop now correctly handles perl's extended UTF-8 (RT #73246) (65ab92)
3092
3093=item *
3094
3095Defer signal handling when shared SV locks are held to avoid
3096deadlocks (RT #74868) (65c742).
3097
3098=item *
3099
3100glob() no longer crashes when %File::Glob:: is empty and
3101CORE::GLOBAL::glob isn't present (4984aa).
3102
3103=item *
3104
3105perlbug now always permits the sender address to be changed
3106before sending - if you were having trouble sending bug reports before
3107now, this should fix it, we hope (e6eb90).
3108
3109=item *
3110
3111Overloading now works properly in conjunction with tied
3112variables. What formerly happened was that most ops checked their
3113arguments for overloading I<before> checking for magic, so for example
3114an overloaded object returned by a tied array access would usually be
3115treated as not overloaded (RT #57012) (6f1401, ed3b9b, 6a5f8c .. 24328f).
3116
3117=item *
3118
3119Independently, a bug was fixed that prevented $tied-E<gt>() from
3120always calling FETCH correctly (RT #8438) (7c7501)
3121
3122=item *
3123
3124Some work has been done on the internal pointers that link between symbol
3125tables (stashes), typeglobs and subroutines. This has the effect that
3126various edge cases related to deleting stashes or stash entries (e.g.
3127<%FOO:: = ()>), and complex typeglob or code reference aliasing, will no
3128longer crash the interpreter.
3129
3130=item *
3131
3132Fixed readline() when interrupted by signals so it no longer returns
3133the "same thing" as before or random memory
3134
3135=item *
3136
3137Fixed a regression of kill() when a match variable is used for the
3138process ID to kill (RT#75812) (8af710e)
3139
3140=item *
3141
3142Fixed several subtle bugs in sort() when @_ is accessed within a subroutine
3143used for sorting (RT#72334) (8f443ca)
3144
3145=item *
3146
3147Catch yyparse() exceptions in C<< (?{...}) >> (RT#2353) (634d691)
3148
3149=item *
3150
3151Avoid UTF-8 cache panics with offsets beyond a string (RT #75898) (3e2d381)
3152
3153=item *
3154
3155Fixed POSIX::strftime memory leak (RT#73520) (c4bc4aa)
3156
3157=item *
3158
3159Doesn't set strict with C<no VERSION> if C<VERSION> is greater than 5.12
3160(da8fb5d)
3161
3162=item *
3163
3164Avoids multiple FETCH/stringify on filetest ops (40c852d)
3165
3166=item *
3167
3168Fixed issue with string C<eval> not detecting taint of overloaded/tied
3169arguments (RT #75716) (895b760)
3170
3171=item *
3172
3173Fix potential crashes of string C<eval> when evaluating a object with
3174overloaded stringification by creating a stringified copy when necessary
3175(3e5c018)
3176
3177=item *
3178
3179Fixed bug where overloaded stringification could remove tainting
3180(RT #75716) (a02ec77)
3181
3182=item *
3183
3184Plugs more memory leaks in vms.c. (9e2bec0)
3185
3186=item *
3187
3188Fix pthread include error for Time::Piece (e9f284c)
3189
3190=item *
3191
3192A possible memory leak when using L<caller()|perlfunc/"caller EXPR"> to set
3193C<@DB::args> has been fixed.
3194
3195=item *
3196
3197Several memory leaks when loading XS modules were fixed.
3198
3199=item *
3200
3201A panic in the regular expression optimizer has been fixed (RT#75762).
3202
3203=item *
3204
3205Assignments to lvalue subroutines now honor copy-on-write behavior again, which
3206has been broken since version 5.10.0 (RT#75656).
3207
3208=item *
3209
3210Assignments to glob copies now behave just like assignments to regular globs
3211(RT#1804).
3212
3213=item *
3214
3215Within signal handlers, C<$!> is now implicitly localized.
3216
3217=item *
3218
3219L<readline|perlfunc/"readline EXPR"> now honors C<< <> >> overloading on tied
3220arguments.
3221
3222=item *
3223
3224L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT">,
3225L<pos()|perlfunc/"index STR,SUBSTR,POSITION">, L<keys()|perlfunc/"keys HASH">,
3226and L<vec()|perlfunc/"vec EXPR,OFFSET,BITS"> could, when used in combination
3227with lvalues, result in leaking the scalar value they operate on, and cause its
3228destruction to happen too late. This has now been fixed.
3229
3230=item *
3231
3232Building with C<PERL_GLOBAL_STRUCT>, which has been broken accidentally in
32335.13.3, now works again.
3234
3235=item *
3236
3237A regression introduced in Perl 5.12.0, making
3238C<< my $x = 3; $x = length(undef) >> result in C<$x> set to C<3> has been
3239fixed. C<$x> will now be C<undef>.
3240
3241=item *
3242
3243A fatal error in regular expressions when processing UTF-8 data has been fixed [perl #75680].
3244
3245=item *
3246
54c7bb16 3247An erroneous regular expression engine optimisation that caused regex verbs like
5076a392
FC
3248C<*COMMIT> to sometimes be ignored has been removed.
3249
3250=item *
3251
3252The Perl debugger now also works in taint mode [perl #76872].
3253
3254=item *
3255
3256Several memory leaks in cloning and freeing threaded Perl interpreters have been
3257fixed [perl #77352].
3258
3259=item *
3260
3261A possible string corruption when doing regular expression matches on overloaded
3262objects has been fixed [perl #77084].
3263
3264=item *
3265
3266Magic applied to variables in the main package no longer affects other packages.
3267See L</Magic variables outside the main package> above [perl #76138].
3268
3269=item *
3270
3271Opening a glob reference via C<< open $fh, "E<gt>", \*glob >> will no longer
3272cause the glob to be corrupted when the filehandle is printed to. This would
3273cause perl to crash whenever the glob's contents were accessed
3274[perl #77492].
3275
3276=item *
3277
3278The postincrement and postdecrement operators, C<++> and C<-->, used to cause
3279leaks when being used on references. This has now been fixed.
3280
3281=item *
3282
3283A bug when replacing the glob of a loop variable within the loop has been fixed
3284[perl #21469]. This
3285means the following code will no longer crash:
3286
3287 for $x (...) {
3288 *x = *y;
3289 }
3290
3291=item *
3292
3293Perl would segfault if the undocumented C<Internals> functions that used
3294reference prototypes were called with the C<&foo()> syntax, e.g.
3295C<&Internals::SvREADONLY(undef)> [perl #77776].
3296
3297These functions now call C<SvROK> on their arguments before dereferencing them
3298with C<SvRV>, and we test for this case in F<t/lib/universal.t>.
3299
3300=item *
3301
3302When assigning a list with duplicated keys to a hash, the assignment used to
3303return garbage and/or freed values:
3304
3305 @a = %h = (list with some duplicate keys);
3306
3307This has now been fixed [perl #31865].
3308
3309=item *
3310
3311An earlier release of the 5.13 series of Perl changed the semantics of opening a
3312reference to a copy of a glob:
3313
3314 my $var = *STDOUT;
3315 open my $fh, '>', \$var;
3316
3317This was a mistake, and the previous behaviour from Perl 5.10 and 5.12, which is
3318to treat \$var as a scalar reference, has now been restored.
3319
3320=item *
3321
3322The regular expression bracketed character class C<[\8\9]> was effectively the
3323same as C<[89\000]>, incorrectly matching a NULL character. It also gave
3324incorrect warnings that the C<8> and C<9> were ignored. Now C<[\8\9]> is the
3325same as C<[89]> and gives legitimate warnings that C<\8> and C<\9> are
3326unrecognized escape sequences, passed-through.
3327
3328=item *
3329
3330C<warn()> and C<die()> now respect utf8-encoded scalars [perl #45549].
3331
3332=item *
3333
3334A regular expression match in the right-hand side of a global substitution
3335(C<s///g>) that is in the same scope will no longer cause match variables
3336to have the wrong values on subsequent iterations. This can happen when an
3337array or hash subscript is interpolated in the right-hand side, as in
3338C<s|(.)|@a{ print($1), /./ }|g> [perl #19078].
3339
3340=item *
3341
3342Constant-folding used to cause
3343
3344 $text =~ ( 1 ? /phoo/ : /bear/)
3345
3346to turn into
3347
3348 $text =~ /phoo/
3349
3350at compile time. Now it correctly matches against C<$_> [perl #20444].
3351
3352=item *
3353
3354Parsing Perl code (either with string C<eval> or by loading modules) from
3355within a C<UNITCHECK> block no longer causes the interpreter to crash
3356[perl #70614].
3357
3358=item *
3359
3360When C<-d> is used on the shebang (C<#!>) line, the debugger now has access
3361to the lines of the main program. In the past, this sometimes worked and
3362sometimes did not, depending on what order things happened to be arranged
3363in memory [perl #71806].
3364
3365=item *
3366
3367The C<y///> or C<tr///> operator now calls get-magic (e.g., the C<FETCH>
3368method of a tie) on its left-hand side just once, not twice [perl #76814].
3369
3370=item *
3371
3372String comparison (C<eq>, C<ne>, C<lt>, C<gt>, C<le>, C<ge> and
3373C<cmp>) and logical not (C<not> and C<!>) operators no longer call magic
3374(e.g., tie methods) twice on their operands [perl #76814].
3375
3376This bug was introduced in an earlier 5.13 release, and does not affect
3377perl 5.12.
3378
3379=item *
3380
3381When a tied (or other magic) variable is used as, or in, a regular
3382expression, it no longer has its C<FETCH> method called twice
3383[perl #76814].
3384
3385This bug was introduced in an earlier 5.13 release, and does not affect
3386perl 5.12.
3387
3388=item *
3389
3390The C<-C> command line option can now be followed by other options
3391[perl #72434].
3392
3393=item *
3394
3395Assigning a glob to a PVLV used to convert it to a plain string. Now it
3396works correctly, and a PVLV can hold a glob. This would happen when a
3397nonexistent hash or array element was passed to a subroutine:
3398
3399 sub { $_[0] = *foo }->($hash{key});
3400 # $_[0] would have been the string "*main::foo"
3401
3402It also happened when a glob was assigned to, or returned from, an element
3403of a tied array or hash [perl #36051].
3404
3405=item *
44691e6f 3406
5076a392
FC
3407Creating a new thread when directory handles were open used to cause a
3408crash, because the handles were not cloned, but simply passed to the new
3409thread, resulting in a double free.
44691e6f 3410
5076a392
FC
3411Now directory handles are cloned properly, on systems that have a C<fchdir>
3412function. On other systems, new threads simply do not inherit directory
3413handles from their parent threads [perl #75154].
44691e6f 3414
5076a392 3415=item *
44691e6f 3416
5076a392
FC
3417The regular expression parser no longer hangs when parsing C<\18> and
3418C<\88>.
44691e6f 3419
5076a392
FC
3420This bug was introduced in version 5.13.5 and did not affect earlier
3421versions [perl #78058].
b7188eb5 3422
5076a392 3423=item *
b7188eb5 3424
5076a392 3425Subroutine redefinition works once more in the debugger [perl #48332].
44691e6f 3426
5076a392 3427=item *
658a9f31 3428
5076a392
FC
3429The C<&> C<|> C<^> bitwise operators no longer coerce read-only arguments
3430[perl #20661].
658a9f31 3431
5076a392 3432=item *
658a9f31 3433
5076a392
FC
3434Stringifying a scalar containing -0.0 no longer has the affect of turning
3435false into true [perl #45133].
b7188eb5 3436
5076a392 3437=item *
b7188eb5 3438
5076a392
FC
3439Aliasing packages by assigning to globs or deleting packages by deleting
3440their containing stash elements used to have erratic effects on method
3441resolution, because the internal 'isa' caches were not reset. This has been
3442fixed.
b7188eb5 3443
5076a392 3444=item *
3aa0ac5a 3445
5076a392
FC
3446C<sort> with a custom sort routine could crash if too many nested
3447subroutine calls occurred from within the sort routine [perl #77930].
3aa0ac5a 3448
5076a392
FC
3449This bug was introduced in an earlier 5.13 release, and did not affect
3450perl 5.12.
3aa0ac5a 3451
5076a392 3452=item *
3aa0ac5a 3453
5076a392
FC
3454The C<eval_sv> and C<eval_pv> C functions now set C<$@> correctly when
3455there is a syntax error and no C<G_KEEPERR> flag, and never set it if the
3456C<G_KEEPERR> flag is present [perl #3719].
270ca148 3457
5076a392 3458=item *
270ca148 3459
5076a392
FC
3460Nested C<map> and C<grep> blocks no longer leak memory when processing
3461large lists [perl #48004].
270ca148 3462
5076a392 3463=item *
44691e6f 3464
5076a392 3465Malformed C<version> objects no longer cause crashes [perl #78286].
44691e6f
AB
3466
3467=item *
3468
5076a392
FC
3469The interpreter no longer crashes when freeing deeply-nested arrays of
3470arrays. Hashes have not been fixed yet [perl #44225].
44691e6f 3471
5076a392 3472=item *
44691e6f 3473
5076a392
FC
3474The mechanism for freeing objects in globs used to leave dangling
3475pointers to freed SVs, meaning Perl users could see corrupted state
3476during destruction.
44691e6f 3477
5076a392
FC
3478Perl now only frees the affected slots of the GV, rather than freeing
3479the GV itself. This makes sure that there are no dangling refs or
3480corrupted state during destruction.
65484cb9 3481
5076a392 3482=item *
b7188eb5 3483
5076a392
FC
3484The typeglob C<*,>, which holds the scalar variable C<$,> (output field
3485separator), had the wrong reference count in child threads.
911a3729 3486
5076a392
FC
3487=item *
3488
3489C<splice> now calls set-magic. This means that, for instance, changes made
3490by C<splice @ISA> are respected by method calls [perl #78400].
452d0b70
DG
3491
3492=item *
3493
5076a392 3494C<use v5.8> no longer leaks memory [perl #78436].
911a3729 3495
5076a392 3496=item *
c8c13991 3497
5076a392
FC
3498The XS multicall API no longer causes subroutines to lose reference counts
3499if called via the multicall interface from within those very subroutines.
3500This affects modules like List::Util. Calling one of its functions with an
3501active subroutine as the first argument could cause a crash [perl #78070].
c8c13991 3502
5076a392
FC
3503=item *
3504
3505The C<parse_stmt> C function added in earlier in the 5.13.x series has been
3506fixed to work with statements ending with C<}> [perl #78222].
44691e6f 3507
f00d3350
BR
3508=item *
3509
5076a392
FC
3510The C<parse_fullstmt> C function added in 5.13.5 has been fixed to work
3511when called while an expression is being parsed.
fe3de278 3512
5076a392 3513=item *
35cdccfc 3514
5076a392
FC
3515Characters in the Latin-1 non-ASCII range (0x80 to 0xFF) used not to match
3516themselves if the string happened to be UTF8-encoded internally, the
3517regular expression was not, and the character in the regular expression was
3518inside a repeated group (e.g.,
3519C<Encode::decode_utf8("\303\200") =~ /(\xc0)+/>) [perl #78464].
35cdccfc 3520
5076a392
FC
3521=item *
3522
3523The C<(?d)> regular expression construct now overrides a previous C<(?u)>
3524or C<use feature "unicode_string"> [perl #78508].
f5c40488
CBW
3525
3526=item *
3527
5076a392
FC
3528A memory leak in C<do "file">, introduced in perl 5.13.6, has been fixed
3529[perl #78488].
b7188eb5 3530
5076a392 3531=item *
b7188eb5 3532
5076a392
FC
3533Various bugs related to typeglob dereferencing have been fixed. See
3534L</Dereferencing typeglobs>, above.
0bb35765 3535
5076a392 3536=item *
911a3729 3537
5076a392
FC
3538The C<SvPVbyte> function available to XS modules now calls magic before
3539downgrading the SV, to avoid warnings about wide characters [perl #72398].
911a3729 3540
5076a392 3541=item *
58f55cb3 3542
5076a392
FC
3543The C<=> operator used to ignore magic (e.g., tie methods) on its
3544right-hand side if the scalar happened to hold a typeglob. This could
3545happen if a typeglob was the last thing returned from or assigned to a tied
3546scalar [perl #77498].
58f55cb3 3547
5076a392 3548=item *
6b3df227 3549
5076a392
FC
3550C<sprintf> was ignoring locales when called with constant arguments
3551[perl #78632].
6b3df227 3552
5076a392 3553=item *
c9989a74 3554
5076a392
FC
3555A non-ASCII character in the Latin-1 range could match both a Posix
3556class, such as C<[[:alnum:]]>, and its inverse C<[[:^alnum:]]>. This is
3557now fixed for regular expressions compiled under the C<"u"> modifier.
3558See L</C<use feature "unicode_strings"> now applies to more regex matching>. [perl #18281].
c9989a74 3559
5076a392
FC
3560=item *
3561
3562Concatenating long strings under C<use encoding> no longer causes perl to
3563crash [perl #78674].
b7188eb5
FC
3564
3565=item *
3566
5076a392
FC
3567Typeglob assignments would crash if the glob's stash no longer existed, so
3568long as the glob assigned to was named 'ISA' or the glob on either side of
3569the assignment contained a subroutine.
911a3729 3570
5076a392 3571=item *
c8c13991 3572
5076a392
FC
3573Calling C<< ->import >> on a class lacking an import method could corrupt
3574the stack, resulting in strange behaviour. For instance,
c8c13991 3575
5076a392 3576 push @a, "foo", $b = bar->import;
f00d3350 3577
5076a392 3578would assign 'foo' to C<$b> [perl #63790].
c34a735e 3579
5076a392 3580=item *
b7188eb5 3581
5076a392
FC
3582Creating an alias to a package when that package had been detached from the
3583symbol table would result in corrupted isa caches [perl #77358].
b7188eb5 3584
5076a392 3585=item *
b7188eb5 3586
5076a392
FC
3587C<.=> followed by C<< <> >> or C<readline> would leak memory if C<$/>
3588contained characters beyond the octet range and the scalar assigned to
3589happened to be encoded as UTF8 internally [perl #72246].
c34a735e 3590
05dbc6f8
KW
3591=item *
3592
5076a392
FC
3593The C<recv> function could crash when called with the MSG_TRUNC flag
3594[perl #75082].
7b98b857 3595
5076a392 3596=item *
05dbc6f8 3597
5076a392
FC
3598Evaluating a simple glob (like C<*a>) was calling get-magic on the glob,
3599even when its contents were not being used [perl #78580].
05dbc6f8 3600
5076a392 3601This bug was introduced in 5.13.2 and did not affect earlier perl versions.
05dbc6f8 3602
5076a392
FC
3603=item *
3604
3605Matching a Unicode character against an alternation containing characters
3606that happened to match continuation bytes in the former's UTF8
3607representation (C<qq{\x{30ab}} =~ /\xab|\xa9/>) would cause erroneous
3608warnings [perl #70998].
05dbc6f8
KW
3609
3610=item *
3611
5076a392 3612C<s///r> (added in 5.13.2) no longer leaks.
05dbc6f8 3613
5076a392 3614=item *
05dbc6f8 3615
5076a392
FC
3616The trie optimisation was not taking empty groups into account, preventing
3617'foo' from matching C</\A(?:(?:)foo|bar|zot)\z/> [perl #78356].
05dbc6f8 3618
5076a392 3619=item *
05dbc6f8 3620
5076a392
FC
3621A pattern containing a C<+> inside a lookahead would sometimes cause an
3622incorrect match failure in a global match (e.g., C</(?=(\S+))/g>)
3623[perl #68564].
05dbc6f8 3624
5076a392 3625=item *
05dbc6f8 3626
5076a392
FC
3627Iterating with C<foreach> over an array returned by an lvalue sub now works
3628[perl #23790].
05dbc6f8
KW
3629
3630=item *
3631
5076a392
FC
3632C<$@> is now localised during calls to C<binmode> to prevent action at a
3633distance [perl #78844].
05dbc6f8 3634
5076a392 3635=item *
05dbc6f8 3636
5076a392
FC
3637C<PL_isarev>, which is accessible to Perl via C<mro::get_isarev> is now
3638updated properly when packages are deleted or removed from the C<@ISA> of
3639other classes. This allows many packages to be created and deleted without
3640causing a memory leak [perl #75176].
8079ad82 3641
5076a392 3642=item *
4d56cd4f 3643
5076a392
FC
3644C<undef *Foo::> and C<undef *Foo::ISA> and C<delete $package::{ISA}>
3645used not to update the internal isa caches if the
3646stash or C<@ISA> array had a reference elsewhere. In
3647fact, C<undef *Foo::ISA> would stop a new C<@Foo::ISA> array from updating
3648caches.
4d56cd4f 3649
5076a392
FC
3650=item *
3651
3652C<@ISA> arrays can now be shared between classes via
3653C<*Foo::ISA = \@Bar::ISA> or C<*Foo::ISA = *Bar::ISA> [perl #77238].
05dbc6f8 3654
911a3729
FC
3655=item *
3656
5076a392
FC
3657The parser no longer hangs when encountering certain Unicode characters,
3658such as U+387 [perl #74022].
911a3729 3659
5076a392 3660=item *
44691e6f 3661
5076a392
FC
3662C<formline> no longer crashes when passed a tainted format picture. It also
3663taints C<$^A> now if its arguments are tainted [perl #79138].
44691e6f 3664
5076a392 3665=item *
44691e6f 3666
5076a392
FC
3667A signal handler called within a signal handler could cause leaks or
3668double-frees. Now fixed. [perl #76248].
9dc513c5 3669
5076a392
FC
3670=item *
3671
3672When trying to report C<Use of uninitialized value $Foo::BAR>, crashes could
3673occur if the GLOB of the global variable causing the warning has been detached
3674from its original stash by, for example C<delete $::{'Foo::'}>. This has been
3675fixed by disabling the reporting of variable names in the warning in those
3676cases.
9dc513c5
DG
3677
3678=item *
3679
5076a392
FC
3680C<BEGIN {require 5.12.0}> now behaves as documented, rather than behaving
3681identically to C<use 5.12.0;>. Previously, C<require> in a C<BEGIN> block
3682was erroneously executing the C<use feature ':5.12.0'> and
3683C<use strict; use warnings;> behaviour, which only C<use> was documented to
3684provide [perl #69050].
9dc513c5 3685
5076a392 3686=item *
9dc513c5 3687
5076a392
FC
3688C<use 5.42> [perl #69050],
3689C<use 6> and C<no 5> no longer leak memory.
44691e6f 3690
5076a392 3691=item *
6d96b0fe 3692
5076a392 3693C<eval "BEGIN{die}"> no longer leaks memory on non-threaded builds.
6d96b0fe 3694
5076a392 3695=item *
6d96b0fe 3696
5076a392
FC
3697PerlIO no longer crashes when called recursively, e.g., from a signal
3698handler. Now it just leaks memory [perl #75556].
6d96b0fe 3699
5076a392 3700=item *
b7188eb5 3701
5076a392
FC
3702Defining a constant with the same name as one of perl's special blocks
3703(e.g., INIT) stopped working in 5.12.0, but has now been fixed
3704[perl #78634].
b7188eb5 3705
5076a392 3706=item *
b7188eb5 3707
5076a392
FC
3708A reference to a literal value used as a hash key (C<$hash{\"foo"}>) used
3709to be stringified, even if the hash was tied [perl #79178].
44691e6f 3710
5076a392 3711=item *
44691e6f 3712
5076a392
FC
3713A closure containing an C<if> statement followed by a constant or variable
3714is no longer treated as a constant [perl #63540].
44691e6f 3715
5076a392 3716=item *
44691e6f 3717
5076a392
FC
3718Calling a closure prototype (what is passed to an attribute handler for a
3719closure) now results in a "Closure prototype called" error message instead
3720of a crash [perl #68560].
44691e6f 3721
5076a392 3722=item *
b7188eb5 3723
5076a392
FC
3724A regular expression optimisation would sometimes cause a match with a
3725C<{n,m}> quantifier to fail when it should match [perl #79152].
b7188eb5 3726
5076a392 3727=item *
b7188eb5 3728
5076a392
FC
3729What has become known as the "Unicode Bug" is mostly resolved in this release.
3730Under C<use feature 'unicode_strings'>, the internal storage format of a
3731string no longer affects the external semantics. There are two known
3732exceptions. User-defined case changing functions, which are planned to
3733be deprecated in 5.14, require utf8-encoded strings to function; and the
3734character C<LATIN SMALL LETTER SHARP S> in regular expression
3735case-insensitive matching has a somewhat different set of bugs depending
3736on the internal storage format. Case-insensitive matching of all
3737characters that have multi-character matches, as this one does, is
3738problematical in Perl [perl #58182].
b7188eb5 3739
5076a392 3740=item *
44691e6f 3741
5076a392
FC
3742Mentioning a read-only lexical variable from the enclosing scope in a
3743string C<eval> no longer causes the variable to become writable
3744[perl #19135].
6c9cd4a1 3745
5076a392 3746=item *
6c9cd4a1 3747
5076a392
FC
3748C<state> can now be used with attributes. It used to mean the same thing as
3749C<my> if attributes were present [perl #68658].
44691e6f 3750
5076a392 3751=item *
44691e6f 3752
5076a392
FC
3753Expressions like C<< @$a > 3 >> no longer cause C<$a> to be mentioned in
3754the "Use of uninitialized value in numeric gt" warning when C<$a> is
3755undefined (since it is not part of the C<E<gt>> expression, but the operand
3756of the C<@>) [perl #72090].
44691e6f 3757
5076a392 3758=item *
44691e6f 3759
5076a392
FC
3760C<require> no longer causes C<caller> to return the wrong file name for
3761the scope that called C<require> and other scopes higher up that had the
3762same file name [perl #68712].
b7188eb5
FC
3763
3764=item *
3765
5076a392
FC
3766The ref types in the typemap for XS bindings now support magical variables
3767[perl #72684].
b7188eb5 3768
5076a392 3769=item *
b7188eb5 3770
5076a392
FC
3771Match variables (e.g., C<$1>) no longer persist between calls to a sort
3772subroutine [perl #76026].
b7188eb5 3773
5076a392 3774=item *
b7188eb5 3775
5076a392
FC
3776The C<B> module was returning C<B::OP>s instead of C<B::LOGOP>s for C<entertry> [perl #80622].
3777This was due to a bug in the perl core, not in C<B> itself.