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