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