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