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