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