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