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