1PERL5140DELTA(1)       Perl Programmers Reference Guide       PERL5140DELTA(1)
2
3
4

NAME

6       perl5140delta - what is new for perl v5.14.0
7

DESCRIPTION

9       This document describes differences between the 5.12.0 release and the
10       5.14.0 release.
11
12       If you are upgrading from an earlier release such as 5.10.0, first read
13       perl5120delta, which describes differences between 5.10.0 and 5.12.0.
14
15       Some of the bug fixes in this release have been backported to
16       subsequent releases of 5.12.x.  Those are indicated with the 5.12.x
17       version in parentheses.
18

Notice

20       As described in perlpolicy, the release of Perl 5.14.0 marks the
21       official end of support for Perl 5.10.  Users of Perl 5.10 or earlier
22       should consider upgrading to a more recent release of Perl.
23

Core Enhancements

25   Unicode
26       Unicode Version 6.0 is now supported (mostly)
27
28       Perl comes with the Unicode 6.0 data base updated with Corrigendum #8
29       <http://www.unicode.org/versions/corrigendum8.html>, with one exception
30       noted below.  See <http://unicode.org/versions/Unicode6.0.0/> for
31       details on the new release.  Perl does not support any Unicode
32       provisional properties, including the new ones for this release.
33
34       Unicode 6.0 has chosen to use the name "BELL" for the character at
35       U+1F514, which is a symbol that looks like a bell, and is used in
36       Japanese cell phones.  This conflicts with the long-standing Perl usage
37       of having "BELL" mean the ASCII "BEL" character, U+0007.  In Perl 5.14,
38       "\N{BELL}" continues to mean U+0007, but its use generates a
39       deprecation warning message unless such warnings are turned off.  The
40       new name for U+0007 in Perl is "ALERT", which corresponds nicely with
41       the existing shorthand sequence for it, "\a".  "\N{BEL}" means U+0007,
42       with no warning given.  The character at U+1F514 has no name in 5.14,
43       but can be referred to by "\N{U+1F514}".  In Perl 5.16, "\N{BELL}" will
44       refer to U+1F514; all code that uses "\N{BELL}" should be converted to
45       use "\N{ALERT}", "\N{BEL}", or "\a" before upgrading.
46
47       Full functionality for "use feature 'unicode_strings'"
48
49       This release provides full functionality for "use feature
50       'unicode_strings'".  Under its scope, all string operations executed
51       and regular expressions compiled (even if executed outside its scope)
52       have Unicode semantics.  See "the 'unicode_strings' feature" in
53       feature.  However, see "Inverted bracketed character classes and multi-
54       character folds", below.
55
56       This feature avoids most forms of the "Unicode Bug" (see "The "Unicode
57       Bug"" in perlunicode for details).  If there is any possibility that
58       your code will process Unicode strings, you are strongly encouraged to
59       use this subpragma to avoid nasty surprises.
60
61       "\N{NAME}" and "charnames" enhancements
62
63       ·   "\N{NAME}" and "charnames::vianame" now know about the abbreviated
64           character names listed by Unicode, such as NBSP, SHY, LRO, ZWJ,
65           etc.; all customary abbreviations for the C0 and C1 control
66           characters (such as ACK, BEL, CAN, etc.); and a few new variants of
67           some C1 full names that are in common usage.
68
69       ·   Unicode has several named character sequences, in which particular
70           sequences of code points are given names.  "\N{NAME}" now
71           recognizes these.
72
73       ·   "\N{NAME}", "charnames::vianame", and "charnames::viacode" now know
74           about every character in Unicode.  In earlier releases of Perl,
75           they didn't know about the Hangul syllables nor several CJK
76           (Chinese/Japanese/Korean) characters.
77
78       ·   It is now possible to override Perl's abbreviations with your own
79           custom aliases.
80
81       ·   You can now create a custom alias of the ordinal of a character,
82           known by "\N{NAME}", "charnames::vianame()", and
83           "charnames::viacode()".  Previously, aliases had to be to official
84           Unicode character names.  This made it impossible to create an
85           alias for unnamed code points, such as those reserved for private
86           use.
87
88       ·   The new function charnames::string_vianame() is a run-time version
89           of "\N{NAME}}", returning the string of characters whose Unicode
90           name is its parameter.  It can handle Unicode named character
91           sequences, whereas the pre-existing charnames::vianame() cannot, as
92           the latter returns a single code point.
93
94       See charnames for details on all these changes.
95
96       New warnings categories for problematic (non-)Unicode code points.
97
98       Three new warnings subcategories of "utf8" have been added.  These
99       allow you to turn off some "utf8" warnings, while allowing other
100       warnings to remain on.  The three categories are: "surrogate" when
101       UTF-16 surrogates are encountered; "nonchar" when Unicode non-character
102       code points are encountered; and "non_unicode" when code points above
103       the legal Unicode maximum of 0x10FFFF are encountered.
104
105       Any unsigned value can be encoded as a character
106
107       With this release, Perl is adopting a model that any unsigned value can
108       be treated as a code point and encoded internally (as utf8) without
109       warnings, not just the code points that are legal in Unicode.  However,
110       unless utf8 or the corresponding sub-category (see previous item) of
111       lexical warnings have been explicitly turned off, outputting or
112       executing a Unicode-defined operation such as upper-casing on such a
113       code point generates a warning.  Attempting to input these using strict
114       rules (such as with the ":encoding(UTF-8)" layer) will continue to
115       fail.  Prior to this release, handling was inconsistent and in places,
116       incorrect.
117
118       Unicode non-characters, some of which previously were erroneously
119       considered illegal in places by Perl, contrary to the Unicode Standard,
120       are now always legal internally.  Inputting or outputting them works
121       the same as with the non-legal Unicode code points, because the Unicode
122       Standard says they are (only) illegal for "open interchange".
123
124       Unicode database files not installed
125
126       The Unicode database files are no longer installed with Perl.  This
127       doesn't affect any functionality in Perl and saves significant disk
128       space.  If you need these files, you can download them from
129       <http://www.unicode.org/Public/zipped/6.0.0/>.
130
131   Regular Expressions
132       "(?^...)" construct signifies default modifiers
133
134       An ASCII caret "^" immediately following a "(?" in a regular expression
135       now means that the subexpression does not inherit surrounding modifiers
136       such as "/i", but reverts to the Perl defaults.  Any modifiers
137       following the caret override the defaults.
138
139       Stringification of regular expressions now uses this notation.  For
140       example, "qr/hlagh/i" would previously be stringified as
141       "(?i-xsm:hlagh)", but now it's stringified as "(?^i:hlagh)".
142
143       The main purpose of this change is to allow tests that rely on the
144       stringification not to have to change whenever new modifiers are added.
145       See "Extended Patterns" in perlre.
146
147       This change is likely to break code that compares stringified regular
148       expressions with fixed strings containing "?-xism".
149
150       "/d", "/l", "/u", and "/a" modifiers
151
152       Four new regular expression modifiers have been added.  These are
153       mutually exclusive: one only can be turned on at a time.
154
155       ·   The "/l" modifier says to compile the regular expression as if it
156           were in the scope of "use locale", even if it is not.
157
158       ·   The "/u" modifier says to compile the regular expression as if it
159           were in the scope of a "use feature 'unicode_strings'" pragma.
160
161       ·   The "/d" (default) modifier is used to override any "use locale"
162           and "use feature 'unicode_strings'" pragmas in effect at the time
163           of compiling the regular expression.
164
165       ·   The "/a" regular expression modifier restricts "\s", "\d" and "\w"
166           and the POSIX ("[[:posix:]]") character classes to the ASCII range.
167           Their complements and "\b" and "\B" are correspondingly affected.
168           Otherwise, "/a" behaves like the "/u" modifier, in that case-
169           insensitive matching uses Unicode semantics.
170
171           If the "/a" modifier is repeated, then additionally in case-
172           insensitive matching, no ASCII character can match a non-ASCII
173           character.  For example,
174
175               "k"     =~ /\N{KELVIN SIGN}/ai
176               "\xDF" =~ /ss/ai
177
178           match but
179
180               "k"    =~ /\N{KELVIN SIGN}/aai
181               "\xDF" =~ /ss/aai
182
183           do not match.
184
185       See "Modifiers" in perlre for more detail.
186
187       Non-destructive substitution
188
189       The substitution ("s///") and transliteration ("y///") operators now
190       support an "/r" option that copies the input variable, carries out the
191       substitution on the copy, and returns the result.  The original remains
192       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 "map".  See perlop for more examples.
199
200       Re-entrant regular expression engine
201
202       It is now safe to use regular expressions within "(?{...})" and
203       "(??{...})" code blocks inside regular expressions.
204
205       These blocks are still experimental, however, and still have problems
206       with lexical ("my") variables and abnormal exiting.
207
208       "use re '/flags'"
209
210       The "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 "'/flags' mode" in re for details.
217
218       \o{...} for octals
219
220       There is a new octal escape sequence, "\o", in doublequote-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 a
225       regex capture group.  See "Capture groups" in perlre.
226
227       Add "\p{Titlecase}" as a synonym for "\p{Title}"
228
229       This synonym is added for symmetry with the Unicode property names
230       "\p{Uppercase}" and "\p{Lowercase}".
231
232       Regular expression debugging output improvement
233
234       Regular expression debugging output (turned on by "use re 'debug'") now
235       uses hexadecimal when escaping non-ASCII characters, instead of octal.
236
237       Return value of "delete $+{...}"
238
239       Custom regular expression engines can now determine the return value of
240       "delete" on an entry of "%+" or "%-".
241
242   Syntactical Enhancements
243       Array and hash container functions accept references
244
245       Warning: This feature is considered experimental, as the exact
246       behaviour may change in a future version of Perl.
247
248       All builtin functions that operate directly on array or hash containers
249       now also accept unblessed hard references to arrays or hashes:
250
251         |----------------------------+---------------------------|
252         | Traditional syntax         | Terse syntax              |
253         |----------------------------+---------------------------|
254         | push @$arrayref, @stuff    | push $arrayref, @stuff    |
255         | unshift @$arrayref, @stuff | unshift $arrayref, @stuff |
256         | pop @$arrayref             | pop $arrayref             |
257         | shift @$arrayref           | shift $arrayref           |
258         | splice @$arrayref, 0, 2    | splice $arrayref, 0, 2    |
259         | keys %$hashref             | keys $hashref             |
260         | keys @$arrayref            | keys $arrayref            |
261         | values %$hashref           | values $hashref           |
262         | values @$arrayref          | values $arrayref          |
263         | ($k,$v) = each %$hashref   | ($k,$v) = each $hashref   |
264         | ($k,$v) = each @$arrayref  | ($k,$v) = each $arrayref  |
265         |----------------------------+---------------------------|
266
267       This allows these builtin functions to act on long dereferencing chains
268       or on the return value of subroutines without needing to wrap them in
269       "@{}" or "%{}":
270
271         push @{$obj->tags}, $new_tag;  # old way
272         push $obj->tags,    $new_tag;  # new way
273
274         for ( keys %{$hoh->{genres}{artists}} ) {...} # old way
275         for ( keys $hoh->{genres}{artists}    ) {...} # new way
276
277       Single term prototype
278
279       The "+" prototype is a special alternative to "$" that acts like
280       "\[@%]" when given a literal array or hash variable, but will otherwise
281       force scalar context on the argument.  See "Prototypes" in perlsub.
282
283       "package" block syntax
284
285       A package declaration can now contain a code block, in which case the
286       declaration is in scope inside that block only.  So "package Foo { ...
287       }" is precisely equivalent to "{ package Foo; ... }".  It also works
288       with a version number in the declaration, as in "package Foo 1.2 { ...
289       }", which is its most attractive feature.  See perlfunc.
290
291       Statement labels can appear in more places
292
293       Statement labels can now occur before any type of statement or
294       declaration, such as "package".
295
296       Stacked labels
297
298       Multiple statement labels can now appear before a single statement.
299
300       Uppercase X/B allowed in hexadecimal/binary literals
301
302       Literals may now use either upper case "0X..." or "0B..." prefixes, in
303       addition to the already supported "0x..." and "0b..."  syntax [perl
304       #76296].
305
306       C, Ruby, Python, and PHP already support this syntax, and it makes Perl
307       more internally consistent: a round-trip with "eval sprintf "%#X",
308       0x10" now returns 16, just like "eval sprintf "%#x", 0x10".
309
310       Overridable tie functions
311
312       "tie", "tied" and "untie" can now be overridden [perl #75902].
313
314   Exception Handling
315       To make them more reliable and consistent, several changes have been
316       made to how "die", "warn", and $@ behave.
317
318       ·   When an exception is thrown inside an "eval", the exception is no
319           longer at risk of being clobbered by destructor code running during
320           unwinding.  Previously, the exception was written into $@ early in
321           the throwing process, and would be overwritten if "eval" was used
322           internally in the destructor for an object that had to be freed
323           while exiting from the outer "eval".  Now the exception is written
324           into $@ last thing before exiting the outer "eval", so the code
325           running immediately thereafter can rely on the value in $@
326           correctly corresponding to that "eval".  ($@ is still also set
327           before exiting the "eval", for the sake of destructors that rely on
328           this.)
329
330           Likewise, a "local $@" inside an "eval" no longer clobbers any
331           exception thrown in its scope.  Previously, the restoration of $@
332           upon unwinding would overwrite any exception being thrown.  Now the
333           exception gets to the "eval" anyway.  So "local $@" is safe before
334           a "die".
335
336           Exceptions thrown from object destructors no longer modify the $@
337           of the surrounding context.  (If the surrounding context was
338           exception unwinding, this used to be another way to clobber the
339           exception being thrown.)  Previously such an exception was
340           sometimes emitted as a warning, and then either was string-appended
341           to the surrounding $@ or completely replaced the surrounding $@,
342           depending on whether that exception and the surrounding $@ were
343           strings or objects.  Now, an exception in this situation is always
344           emitted as a warning, leaving the surrounding $@ untouched.  In
345           addition to object destructors, this also affects any function call
346           run by XS code using the "G_KEEPERR" flag.
347
348       ·   Warnings for "warn" can now be objects in the same way as
349           exceptions for "die".  If an object-based warning gets the default
350           handling of writing to standard error, it is stringified as before
351           with the filename and line number appended.  But a $SIG{__WARN__}
352           handler now receives an object-based warning as an object, where
353           previously it was passed the result of stringifying the object.
354
355   Other Enhancements
356       Assignment to $0 sets the legacy process name with prctl() on Linux
357
358       On Linux the legacy process name is now set with prctl(2), in addition
359       to altering the POSIX name via "argv[0]", as Perl has done since
360       version 4.000.  Now system utilities that read the legacy process name
361       such as ps, top, and killall recognize the name you set when assigning
362       to $0.  The string you supply is truncated at 16 bytes; this limitation
363       is imposed by Linux.
364
365       srand() now returns the seed
366
367       This allows programs that need to have repeatable results not to have
368       to come up with their own seed-generating mechanism.  Instead, they can
369       use srand() and stash the return value for future use.  One example is
370       a test program with too many combinations to test comprehensively in
371       the time available for each run.  It can test a random subset each time
372       and, should there be a failure, log the seed used for that run so this
373       can later be used to produce the same results.
374
375       printf-like functions understand post-1980 size modifiers
376
377       Perl's printf and sprintf operators, and Perl's internal printf
378       replacement function, now understand the C90 size modifiers "hh"
379       ("char"), "z" ("size_t"), and "t" ("ptrdiff_t").  Also, when compiled
380       with a C99 compiler, Perl now understands the size modifier "j"
381       ("intmax_t") (but this is not portable).
382
383       So, for example, on any modern machine, "sprintf("%hhd", 257)" returns
384       "1".
385
386       New global variable "${^GLOBAL_PHASE}"
387
388       A new global variable, "${^GLOBAL_PHASE}", has been added to allow
389       introspection of the current phase of the Perl interpreter.  It's
390       explained in detail in "${^GLOBAL_PHASE}" in perlvar and in "BEGIN,
391       UNITCHECK, CHECK, INIT and END" in perlmod.
392
393       "-d:-foo" calls "Devel::foo::unimport"
394
395       The syntax -d:foo was extended in 5.6.1 to make -d:foo=bar equivalent
396       to -MDevel::foo=bar, which expands internally to "use Devel::foo
397       'bar'".  Perl now allows prefixing the module name with -, with the
398       same semantics as -M; that is:
399
400       "-d:-foo"
401           Equivalent to -M-Devel::foo: expands to "no Devel::foo" and calls
402           "Devel::foo->unimport()" if that method exists.
403
404       "-d:-foo=bar"
405           Equivalent to -M-Devel::foo=bar: expands to "no Devel::foo 'bar'",
406           and calls "Devel::foo->unimport("bar")" if that method exists.
407
408       This is particularly useful for suppressing the default actions of a
409       "Devel::*" module's "import" method whilst still loading it for
410       debugging.
411
412       Filehandle method calls load IO::File on demand
413
414       When a method call on a filehandle would die because the method cannot
415       be resolved and IO::File has not been loaded, Perl now loads IO::File
416       via "require" and attempts method resolution again:
417
418         open my $fh, ">", $file;
419         $fh->binmode(":raw");     # loads IO::File and succeeds
420
421       This also works for globs like "STDOUT", "STDERR", and "STDIN":
422
423         STDOUT->autoflush(1);
424
425       Because this on-demand load happens only if method resolution fails,
426       the legacy approach of manually loading an IO::File parent class for
427       partial method support still works as expected:
428
429         use IO::Handle;
430         open my $fh, ">", $file;
431         $fh->autoflush(1);        # IO::File not loaded
432
433       Improved IPv6 support
434
435       The "Socket" module provides new affordances for IPv6, including
436       implementations of the "Socket::getaddrinfo()" and
437       "Socket::getnameinfo()" functions, along with related constants and a
438       handful of new functions.  See Socket.
439
440       DTrace probes now include package name
441
442       The "DTrace" probes now include an additional argument, "arg3", which
443       contains the package the subroutine being entered or left was compiled
444       in.
445
446       For example, using the following DTrace script:
447
448         perl$target:::sub-entry
449         {
450             printf("%s::%s\n", copyinstr(arg0), copyinstr(arg3));
451         }
452
453       and then running:
454
455         $ perl -e 'sub test { }; test'
456
457       "DTrace" will print:
458
459         main::test
460
461   New C APIs
462       See "Internal Changes".
463

Security

465   User-defined regular expression properties
466       "User-Defined Character Properties" in perlunicode documented that you
467       can create custom properties by defining subroutines whose names begin
468       with "In" or "Is".  However, Perl did not actually enforce that naming
469       restriction, so "\p{foo::bar}" could call foo::bar() if it existed.
470       The documented convention is now enforced.
471
472       Also, Perl no longer allows tainted regular expressions to invoke a
473       user-defined property.  It simply dies instead [perl #82616].
474

Incompatible Changes

476       Perl 5.14.0 is not binary-compatible with any previous stable release.
477
478       In addition to the sections that follow, see "C API Changes".
479
480   Regular Expressions and String Escapes
481       Inverted bracketed character classes and multi-character folds
482
483       Some characters match a sequence of two or three characters in "/i"
484       regular expression matching under Unicode rules.  One example is "LATIN
485       SMALL LETTER SHARP S" which matches the sequence "ss".
486
487        'ss' =~ /\A[\N{LATIN SMALL LETTER SHARP S}]\z/i  # Matches
488
489       This, however, can lead to very counter-intuitive results, especially
490       when inverted.  Because of this, Perl 5.14 does not use multi-character
491       "/i" matching in inverted character classes.
492
493        'ss' =~ /\A[^\N{LATIN SMALL LETTER SHARP S}]+\z/i  # ???
494
495       This should match any sequences of characters that aren't the "SHARP S"
496       nor what "SHARP S" matches under "/i".  "s" isn't "SHARP S", but
497       Unicode says that "ss" is what "SHARP S" matches under "/i".  So which
498       one "wins"? Do you fail the match because the string has "ss" or accept
499       it because it has an "s" followed by another "s"?
500
501       Earlier releases of Perl did allow this multi-character matching, but
502       due to bugs, it mostly did not work.
503
504       \400-\777
505
506       In certain circumstances, "\400"-"\777" in regexes have behaved
507       differently than they behave in all other doublequote-like contexts.
508       Since 5.10.1, Perl has issued a deprecation warning when this happens.
509       Now, these literals behave the same in all doublequote-like contexts,
510       namely to be equivalent to "\x{100}"-"\x{1FF}", with no deprecation
511       warning.
512
513       Use of "\400"-"\777" in the command-line option -0 retain their
514       conventional meaning.  They slurp whole input files; previously, this
515       was documented only for -0777.
516
517       Because of various ambiguities, you should use the new "\o{...}"
518       construct to represent characters in octal instead.
519
520       Most "\p{}" properties are now immune to case-insensitive matching
521
522       For most Unicode properties, it doesn't make sense to have them match
523       differently under "/i" case-insensitive matching.  Doing so can lead to
524       unexpected results and potential security holes.  For example
525
526        m/\p{ASCII_Hex_Digit}+/i
527
528       could previously match non-ASCII characters because of the Unicode
529       matching rules (although there were several bugs with this).  Now
530       matching under "/i" gives the same results as non-"/i" matching except
531       for those few properties where people have come to expect differences,
532       namely the ones where casing is an integral part of their meaning, such
533       as "m/\p{Uppercase}/i" and "m/\p{Lowercase}/i", both of which match the
534       same code points as matched by "m/\p{Cased}/i".  Details are in
535       "Unicode Properties" in perlrecharclass.
536
537       User-defined property handlers that need to match differently under
538       "/i" must be changed to read the new boolean parameter passed to them,
539       which is non-zero if case-insensitive matching is in effect and 0
540       otherwise.  See "User-Defined Character Properties" in perlunicode.
541
542       \p{} implies Unicode semantics
543
544       Specifying a Unicode property in the pattern indicates that the pattern
545       is meant for matching according to Unicode rules, the way "\N{NAME}"
546       does.
547
548       Regular expressions retain their localeness when interpolated
549
550       Regular expressions compiled under "use locale" now retain this when
551       interpolated into a new regular expression compiled outside a "use
552       locale", and vice-versa.
553
554       Previously, one regular expression interpolated into another inherited
555       the localeness of the surrounding regex, losing whatever state it
556       originally had.  This is considered a bug fix, but may trip up code
557       that has come to rely on the incorrect behaviour.
558
559       Stringification of regexes has changed
560
561       Default regular expression modifiers are now notated using "(?^...)".
562       Code relying on the old stringification will fail.  This is so that
563       when new modifiers are added, such code won't have to keep changing
564       each time this happens, because the stringification will automatically
565       incorporate the new modifiers.
566
567       Code that needs to work properly with both old- and new-style regexes
568       can avoid the whole issue by using (for perls since 5.9.5; see re):
569
570        use re qw(regexp_pattern);
571        my ($pat, $mods) = regexp_pattern($re_ref);
572
573       If the actual stringification is important or older Perls need to be
574       supported, you can use something like the following:
575
576           # Accept both old and new-style stringification
577           my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? "^" : "-xism";
578
579       And then use $modifiers instead of "-xism".
580
581       Run-time code blocks in regular expressions inherit pragmata
582
583       Code blocks in regular expressions ("(?{...})" and "(??{...})")
584       previously did not inherit pragmata (strict, warnings, etc.) if the
585       regular expression was compiled at run time as happens in cases like
586       these two:
587
588         use re "eval";
589         $foo =~ $bar; # when $bar contains (?{...})
590         $foo =~ /$bar(?{ $finished = 1 })/;
591
592       This bug has now been fixed, but code that relied on the buggy
593       behaviour may need to be fixed to account for the correct behaviour.
594
595   Stashes and Package Variables
596       Localised tied hashes and arrays are no longed tied
597
598       In the following:
599
600           tie @a, ...;
601           {
602                   local @a;
603                   # here, @a is a now a new, untied array
604           }
605           # here, @a refers again to the old, tied array
606
607       Earlier versions of Perl incorrectly tied the new local array.  This
608       has now been fixed.  This fix could however potentially cause a change
609       in behaviour of some code.
610
611       Stashes are now always defined
612
613       "defined %Foo::" now always returns true, even when no symbols have yet
614       been defined in that package.
615
616       This is a side-effect of removing a special-case kludge in the
617       tokeniser, added for 5.10.0, to hide side-effects of changes to the
618       internal storage of hashes.  The fix drastically reduces hashes' memory
619       overhead.
620
621       Calling defined on a stash has been deprecated since 5.6.0, warned on
622       lexicals since 5.6.0, and warned for stashes and other package
623       variables since 5.12.0.  "defined %hash" has always exposed an
624       implementation detail: emptying a hash by deleting all entries from it
625       does not make "defined %hash" false.  Hence "defined %hash" is not
626       valid code to determine whether an arbitrary hash is empty.  Instead,
627       use the behaviour of an empty %hash always returning false in scalar
628       context.
629
630       Clearing stashes
631
632       Stash list assignment "%foo:: = ()" used to make the stash temporarily
633       anonymous while it was being emptied.  Consequently, any of its
634       subroutines referenced elsewhere would become anonymous,  showing up as
635       "(unknown)" in "caller".  They now retain their package names such that
636       "caller" returns the original sub name if there is still a reference to
637       its typeglob and "foo::__ANON__" otherwise [perl #79208].
638
639       Dereferencing typeglobs
640
641       If you assign a typeglob to a scalar variable:
642
643           $glob = *foo;
644
645       the glob that is copied to $glob is marked with a special flag
646       indicating that the glob is just a copy.  This allows subsequent
647       assignments to $glob to overwrite the glob.  The original glob,
648       however, is immutable.
649
650       Some Perl operators did not distinguish between these two types of
651       globs.  This would result in strange behaviour in edge cases: "untie
652       $scalar" would not untie the scalar if the last thing assigned to it
653       was a glob (because it treated it as "untie *$scalar", which unties a
654       handle).  Assignment to a glob slot (such as "*$glob = \@some_array")
655       would simply assign "\@some_array" to $glob.
656
657       To fix this, the "*{}" operator (including its *foo and *$foo forms)
658       has been modified to make a new immutable glob if its operand is a glob
659       copy.  This allows operators that make a distinction between globs and
660       scalars to be modified to treat only immutable globs as globs.  ("tie",
661       "tied" and "untie" have been left as they are for compatibility's sake,
662       but will warn.  See "Deprecations".)
663
664       This causes an incompatible change in code that assigns a glob to the
665       return value of "*{}" when that operator was passed a glob copy.  Take
666       the following code, for instance:
667
668           $glob = *foo;
669           *$glob = *bar;
670
671       The *$glob on the second line returns a new immutable glob.  That new
672       glob is made an alias to *bar.  Then it is discarded.  So the second
673       assignment has no effect.
674
675       See <http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for more
676       detail.
677
678       Magic variables outside the main package
679
680       In previous versions of Perl, magic variables like $!, %SIG, etc. would
681       "leak" into other packages.  So %foo::SIG could be used to access
682       signals, "${"foo::!"}" (with strict mode off) to access C's "errno",
683       etc.
684
685       This was a bug, or an "unintentional" feature, which caused various ill
686       effects, such as signal handlers being wiped when modules were loaded,
687       etc.
688
689       This has been fixed (or the feature has been removed, depending on how
690       you see it).
691
692       local($_) strips all magic from $_
693
694       local() on scalar variables gives them a new value but keeps all their
695       magic intact.  This has proven problematic for the default scalar
696       variable $_, where perlsub recommends that any subroutine that assigns
697       to $_ should first localize it.  This would throw an exception if $_ is
698       aliased to a read-only variable, and could in general have various
699       unintentional side-effects.
700
701       Therefore, as an exception to the general rule, local($_) will not only
702       assign a new value to $_, but also remove all existing magic from it as
703       well.
704
705       Parsing of package and variable names
706
707       Parsing the names of packages and package variables has changed:
708       multiple adjacent pairs of colons, as in "foo::::bar", are now all
709       treated as package separators.
710
711       Regardless of this change, the exact parsing of package separators has
712       never been guaranteed and is subject to change in future Perl versions.
713
714   Changes to Syntax or to Perl Operators
715       "given" return values
716
717       "given" blocks now return the last evaluated expression, or an empty
718       list if the block was exited by "break".  Thus you can now write:
719
720           my $type = do {
721            given ($num) {
722             break     when undef;
723             "integer" when /^[+-]?[0-9]+$/;
724             "float"   when /^[+-]?[0-9]+(?:\.[0-9]+)?$/;
725             "unknown";
726            }
727           };
728
729       See "Return value" in perlsyn for details.
730
731       Change in parsing of certain prototypes
732
733       Functions declared with the following prototypes now behave correctly
734       as unary functions:
735
736         *
737         \$ \% \@ \* \&
738         \[...]
739         ;$ ;*
740         ;\$ ;\% etc.
741         ;\[...]
742
743       Due to this bug fix [perl #75904], functions using the "(*)", "(;$)"
744       and "(;*)" prototypes are parsed with higher precedence than before.
745       So in the following example:
746
747         sub foo(;$);
748         foo $a < $b;
749
750       the second line is now parsed correctly as "foo($a) < $b", rather than
751       "foo($a < $b)".  This happens when one of these operators is used in an
752       unparenthesised argument:
753
754         < > <= >= lt gt le ge
755         == != <=> eq ne cmp ~~
756         &
757         | ^
758         &&
759         || //
760         .. ...
761         ?:
762         = += -= *= etc.
763         , =>
764
765       Smart-matching against array slices
766
767       Previously, the following code resulted in a successful match:
768
769           my @a = qw(a y0 z);
770           my @b = qw(a x0 z);
771           @a[0 .. $#b] ~~ @b;
772
773       This odd behaviour has now been fixed [perl #77468].
774
775       Negation treats strings differently from before
776
777       The unary negation operator, "-", now treats strings that look like
778       numbers as numbers [perl #57706].
779
780       Negative zero
781
782       Negative zero (-0.0), when converted to a string, now becomes "0" on
783       all platforms.  It used to become "-0" on some, but "0" on others.
784
785       If you still need to determine whether a zero is negative, use
786       "sprintf("%g", $zero) =~ /^-/" or the Data::Float module on CPAN.
787
788       ":=" is now a syntax error
789
790       Previously "my $pi := 4" was exactly equivalent to "my $pi : = 4", with
791       the ":" being treated as the start of an attribute list, ending before
792       the "=".  The use of ":=" to mean ": =" was deprecated in 5.12.0, and
793       is now a syntax error.  This allows future use of ":=" as a new token.
794
795       Outside the core's tests for it, we find no Perl 5 code on CPAN using
796       this construction, so we believe that this change will have little
797       impact on real-world codebases.
798
799       If it is absolutely necessary to have empty attribute lists (for
800       example, because of a code generator), simply avoid the error by adding
801       a space before the "=".
802
803       Change in the parsing of identifiers
804
805       Characters outside the Unicode "XIDStart" set are no longer allowed at
806       the beginning of an identifier.  This means that certain accents and
807       marks that normally follow an alphabetic character may no longer be the
808       first character of an identifier.
809
810   Threads and Processes
811       Directory handles not copied to threads
812
813       On systems other than Windows that do not have a "fchdir" function,
814       newly-created threads no longer inherit directory handles from their
815       parent threads.  Such programs would usually have crashed anyway [perl
816       #75154].
817
818       "close" on shared pipes
819
820       To avoid deadlocks, the "close" function no longer waits for the child
821       process to exit if the underlying file descriptor is still in use by
822       another thread.  It returns true in such cases.
823
824       fork() emulation will not wait for signalled children
825
826       On Windows parent processes would not terminate until all forked
827       children had terminated first.  However, "kill("KILL", ...)" is
828       inherently unstable on pseudo-processes, and "kill("TERM", ...)"  might
829       not get delivered if the child is blocked in a system call.
830
831       To avoid the deadlock and still provide a safe mechanism to terminate
832       the hosting process, Perl now no longer waits for children that have
833       been sent a SIGTERM signal.  It is up to the parent process to
834       waitpid() for these children if child-cleanup processing must be
835       allowed to finish.  However, it is also then the responsibility of the
836       parent to avoid the deadlock by making sure the child process can't be
837       blocked on I/O.
838
839       See perlfork for more information about the fork() emulation on
840       Windows.
841
842   Configuration
843       Naming fixes in Policy_sh.SH may invalidate Policy.sh
844
845       Several long-standing typos and naming confusions in Policy_sh.SH have
846       been fixed, standardizing on the variable names used in config.sh.
847
848       This will change the behaviour of Policy.sh if you happen to have been
849       accidentally relying on its incorrect behaviour.
850
851       Perl source code is read in text mode on Windows
852
853       Perl scripts used to be read in binary mode on Windows for the benefit
854       of the ByteLoader module (which is no longer part of core Perl).  This
855       had the side-effect of breaking various operations on the "DATA"
856       filehandle, including seek()/tell(), and even simply reading from
857       "DATA" after filehandles have been flushed by a call to system(),
858       backticks, fork() etc.
859
860       The default build options for Windows have been changed to read Perl
861       source code on Windows in text mode now.  ByteLoader will (hopefully)
862       be updated on CPAN to automatically handle this situation [perl
863       #28106].
864

Deprecations

866       See also "Deprecated C APIs".
867
868   Omitting a space between a regular expression and subsequent word
869       Omitting the space between a regular expression operator or its
870       modifiers and the following word is deprecated.  For example,
871       "m/foo/sand $bar" is for now still parsed as "m/foo/s and $bar", but
872       will now issue a warning.
873
874   "\cX"
875       The backslash-c construct was designed as a way of specifying non-
876       printable characters, but there were no restrictions (on ASCII
877       platforms) on what the character following the "c" could be.  Now, a
878       deprecation warning is raised if that character isn't an ASCII
879       character.  Also, a deprecation warning is raised for "\c{" (which is
880       the same as simply saying ";").
881
882   "\b{" and "\B{"
883       In regular expressions, a literal "{" immediately following a "\b" (not
884       in a bracketed character class) or a "\B{" is now deprecated to allow
885       for its future use by Perl itself.
886
887   Perl 4-era .pl libraries
888       Perl bundles a handful of library files that predate Perl 5.  This
889       bundling is now deprecated for most of these files, which are now
890       available from CPAN.  The affected files now warn when run, if they
891       were installed as part of the core.
892
893       This is a mandatory warning, not obeying -X or lexical warning bits.
894       The warning is modelled on that supplied by deprecate.pm for
895       deprecated-in-core .pm libraries.  It points to the specific CPAN
896       distribution that contains the .pl libraries.  The CPAN versions, of
897       course, do not generate the warning.
898
899   List assignment to $[
900       Assignment to $[ was deprecated and started to give warnings in Perl
901       version 5.12.0.  This version of Perl (5.14) now also emits a warning
902       when assigning to $[ in list context.  This fixes an oversight in
903       5.12.0.
904
905   Use of qw(...) as parentheses
906       Historically the parser fooled itself into thinking that "qw(...)"
907       literals were always enclosed in parentheses, and as a result you could
908       sometimes omit parentheses around them:
909
910           for $x qw(a b c) { ... }
911
912       The parser no longer lies to itself in this way.  Wrap the list literal
913       in parentheses like this:
914
915           for $x (qw(a b c)) { ... }
916
917       This is being deprecated because the parentheses in "for $i (1,2,3) {
918       ... }" are not part of expression syntax.  They are part of the
919       statement syntax, with the "for" statement wanting literal parentheses.
920       The synthetic parentheses that a "qw" expression acquired were only
921       intended to be treated as part of expression syntax.
922
923       Note that this does not change the behaviour of cases like:
924
925           use POSIX qw(setlocale localeconv);
926           our @EXPORT = qw(foo bar baz);
927
928       where parentheses were never required around the expression.
929
930   "\N{BELL}"
931       This is because Unicode is using that name for a different character.
932       See "Unicode Version 6.0 is now supported (mostly)" for more
933       explanation.
934
935   "?PATTERN?"
936       "?PATTERN?" (without the initial "m") has been deprecated and now
937       produces a warning.  This is to allow future use of "?" in new
938       operators.  The match-once functionality is still available as
939       "m?PATTERN?".
940
941   Tie functions on scalars holding typeglobs
942       Calling a tie function ("tie", "tied", "untie") with a scalar argument
943       acts on a filehandle if the scalar happens to hold a typeglob.
944
945       This is a long-standing bug that will be removed in Perl 5.16, as there
946       is currently no way to tie the scalar itself when it holds a typeglob,
947       and no way to untie a scalar that has had a typeglob assigned to it.
948
949       Now there is a deprecation warning whenever a tie function is used on a
950       handle without an explicit "*".
951
952   User-defined case-mapping
953       This feature is being deprecated due to its many issues, as documented
954       in "User-Defined Case Mappings (for serious hackers only)" in
955       perlunicode.  This feature will be removed in Perl 5.16.  Instead use
956       the CPAN module Unicode::Casing, which provides improved functionality.
957
958   Deprecated modules
959       The following module will be removed from the core distribution in a
960       future release, and should be installed from CPAN instead.
961       Distributions on CPAN that require this should add it to their
962       prerequisites.  The core version of these module now issues a
963       deprecation warning.
964
965       If you ship a packaged version of Perl, either alone or as part of a
966       larger system, then you should carefully consider the repercussions of
967       core module deprecations.  You may want to consider shipping your
968       default build of Perl with a package for the deprecated module that
969       installs into "vendor" or "site" Perl library directories.  This will
970       inhibit the deprecation warnings.
971
972       Alternatively, you may want to consider patching lib/deprecate.pm to
973       provide deprecation warnings specific to your packaging system or
974       distribution of Perl, consistent with how your packaging system or
975       distribution manages a staged transition from a release where the
976       installation of a single package provides the given functionality, to a
977       later release where the system administrator needs to know to install
978       multiple packages to get that same functionality.
979
980       You can silence these deprecation warnings by installing the module in
981       question from CPAN.  To install the latest version of it by role rather
982       than by name, just install "Task::Deprecations::5_14".
983
984       Devel::DProf
985           We strongly recommend that you install and use Devel::NYTProf
986           instead of Devel::DProf, as Devel::NYTProf offers significantly
987           improved profiling and reporting.
988

Performance Enhancements

990   "Safe signals" optimisation
991       Signal dispatch has been moved from the runloop into control ops.  This
992       should give a few percent speed increase, and eliminates nearly all the
993       speed penalty caused by the introduction of "safe signals" in 5.8.0.
994       Signals should still be dispatched within the same statement as they
995       were previously.  If this does not happen, or if you find it possible
996       to create uninterruptible loops, this is a bug, and reports are
997       encouraged of how to recreate such issues.
998
999   Optimisation of shift() and pop() calls without arguments
1000       Two fewer OPs are used for shift() and pop() calls with no argument
1001       (with implicit @_).  This change makes shift() 5% faster than "shift
1002       @_" on non-threaded perls, and 25% faster on threaded ones.
1003
1004   Optimisation of regexp engine string comparison work
1005       The "foldEQ_utf8" API function for case-insensitive comparison of
1006       strings (which is used heavily by the regexp engine) was substantially
1007       refactored and optimised -- and its documentation much improved as a
1008       free bonus.
1009
1010   Regular expression compilation speed-up
1011       Compiling regular expressions has been made faster when upgrading the
1012       regex to utf8 is necessary but this isn't known when the compilation
1013       begins.
1014
1015   String appending is 100 times faster
1016       When doing a lot of string appending, perls built to use the system's
1017       "malloc" could end up allocating a lot more memory than needed in a
1018       inefficient way.
1019
1020       "sv_grow", the function used to allocate more memory if necessary when
1021       appending to a string, has been taught to round up the memory it
1022       requests to a certain geometric progression, making it much faster on
1023       certain platforms and configurations.  On Win32, it's now about 100
1024       times faster.
1025
1026   Eliminate "PL_*" accessor functions under ithreads
1027       When "MULTIPLICITY" was first developed, and interpreter state moved
1028       into an interpreter struct, thread- and interpreter-local "PL_*"
1029       variables were defined as macros that called accessor functions
1030       (returning the address of the value) outside the Perl core.  The intent
1031       was to allow members within the interpreter struct to change size
1032       without breaking binary compatibility, so that bug fixes could be
1033       merged to a maintenance branch that necessitated such a size change.
1034       This mechanism was redundant and penalised well-behaved code.  It has
1035       been removed.
1036
1037   Freeing weak references
1038       When there are many weak references to an object, freeing that object
1039       can under some circumstances take O(N*N) time to free, where N is the
1040       number of references.  The circumstances in which this can happen have
1041       been reduced [perl #75254]
1042
1043   Lexical array and hash assignments
1044       An earlier optimisation to speed up "my @array = ..." and "my %hash =
1045       ..." assignments caused a bug and was disabled in Perl 5.12.0.
1046
1047       Now we have found another way to speed up these assignments [perl
1048       #82110].
1049
1050   @_ uses less memory
1051       Previously, @_ was allocated for every subroutine at compile time with
1052       enough space for four entries.  Now this allocation is done on demand
1053       when the subroutine is called [perl #72416].
1054
1055   Size optimisations to SV and HV structures
1056       "xhv_fill" has been eliminated from "struct xpvhv", saving 1 IV per
1057       hash and on some systems will cause "struct xpvhv" to become cache-
1058       aligned.  To avoid this memory saving causing a slowdown elsewhere,
1059       boolean use of "HvFILL" now calls "HvTOTALKEYS" instead (which is
1060       equivalent), so while the fill data when actually required are now
1061       calculated on demand, cases when this needs to be done should be rare.
1062
1063       The order of structure elements in SV bodies has changed.  Effectively,
1064       the NV slot has swapped location with STASH and MAGIC.  As all access
1065       to SV members is via macros, this should be completely transparent.
1066       This change allows the space saving for PVHVs documented above, and may
1067       reduce the memory allocation needed for PVIVs on some architectures.
1068
1069       "XPV", "XPVIV", and "XPVNV" now allocate only the parts of the "SV"
1070       body they actually use, saving some space.
1071
1072       Scalars containing regular expressions now allocate only the part of
1073       the "SV" body they actually use, saving some space.
1074
1075   Memory consumption improvements to Exporter
1076       The @EXPORT_FAIL AV is no longer created unless needed, hence neither
1077       is the typeglob backing it.  This saves about 200 bytes for every
1078       package that uses Exporter but doesn't use this functionality.
1079
1080   Memory savings for weak references
1081       For weak references, the common case of just a single weak reference
1082       per referent has been optimised to reduce the storage required.  In
1083       this case it saves the equivalent of one small Perl array per referent.
1084
1085   "%+" and "%-" use less memory
1086       The bulk of the "Tie::Hash::NamedCapture" module used to be in the Perl
1087       core.  It has now been moved to an XS module to reduce overhead for
1088       programs that do not use "%+" or "%-".
1089
1090   Multiple small improvements to threads
1091       The internal structures of threading now make fewer API calls and fewer
1092       allocations, resulting in noticeably smaller object code.
1093       Additionally, many thread context checks have been deferred so they're
1094       done only as needed (although this is only possible for non-debugging
1095       builds).
1096
1097   Adjacent pairs of nextstate opcodes are now optimized away
1098       Previously, in code such as
1099
1100           use constant DEBUG => 0;
1101
1102           sub GAK {
1103               warn if DEBUG;
1104               print "stuff\n";
1105           }
1106
1107       the ops for "warn if DEBUG" would be folded to a "null" op
1108       ("ex-const"), but the "nextstate" op would remain, resulting in a
1109       runtime op dispatch of "nextstate", "nextstate", etc.
1110
1111       The execution of a sequence of "nextstate" ops is indistinguishable
1112       from just the last "nextstate" op so the peephole optimizer now
1113       eliminates the first of a pair of "nextstate" ops except when the first
1114       carries a label, since labels must not be eliminated by the optimizer,
1115       and label usage isn't conclusively known at compile time.
1116

Modules and Pragmata

1118   New Modules and Pragmata
1119       ·   CPAN::Meta::YAML 0.003 has been added as a dual-life module.  It
1120           supports a subset of YAML sufficient for reading and writing
1121           META.yml and MYMETA.yml files included with CPAN distributions or
1122           generated by the module installation toolchain.  It should not be
1123           used for any other general YAML parsing or generation task.
1124
1125       ·   CPAN::Meta version 2.110440 has been added as a dual-life module.
1126           It provides a standard library to read, interpret and write CPAN
1127           distribution metadata files (like META.json and META.yml) that
1128           describe a distribution, its contents, and the requirements for
1129           building it and installing it.  The latest CPAN distribution
1130           metadata specification is included as CPAN::Meta::Spec and notes on
1131           changes in the specification over time are given in
1132           CPAN::Meta::History.
1133
1134       ·   HTTP::Tiny 0.012 has been added as a dual-life module.  It is a
1135           very small, simple HTTP/1.1 client designed for simple GET requests
1136           and file mirroring.  It has been added so that CPAN.pm and CPANPLUS
1137           can "bootstrap" HTTP access to CPAN using pure Perl without relying
1138           on external binaries like curl(1) or wget(1).
1139
1140       ·   JSON::PP 2.27105 has been added as a dual-life module to allow CPAN
1141           clients to read META.json files in CPAN distributions.
1142
1143       ·   Module::Metadata 1.000004 has been added as a dual-life module.  It
1144           gathers package and POD information from Perl module files.  It is
1145           a standalone module based on Module::Build::ModuleInfo for use by
1146           other module installation toolchain components.
1147           Module::Build::ModuleInfo has been deprecated in favor of this
1148           module instead.
1149
1150       ·   Perl::OSType 1.002 has been added as a dual-life module.  It maps
1151           Perl operating system names (like "dragonfly" or "MSWin32") to more
1152           generic types with standardized names (like "Unix" or "Windows").
1153           It has been refactored out of Module::Build and ExtUtils::CBuilder
1154           and consolidates such mappings into a single location for easier
1155           maintenance.
1156
1157       ·   The following modules were added by the Unicode::Collate upgrade.
1158           See below for details.
1159
1160           Unicode::Collate::CJK::Big5
1161
1162           Unicode::Collate::CJK::GB2312
1163
1164           Unicode::Collate::CJK::JISX0208
1165
1166           Unicode::Collate::CJK::Korean
1167
1168           Unicode::Collate::CJK::Pinyin
1169
1170           Unicode::Collate::CJK::Stroke
1171
1172       ·   Version::Requirements version 0.101020 has been added as a dual-
1173           life module.  It provides a standard library to model and
1174           manipulates module prerequisites and version constraints defined in
1175           CPAN::Meta::Spec.
1176
1177   Updated Modules and Pragma
1178       ·   attributes has been upgraded from version 0.12 to 0.14.
1179
1180       ·   Archive::Extract has been upgraded from version 0.38 to 0.48.
1181
1182           Updates since 0.38 include: a safe print method that guards
1183           Archive::Extract from changes to "$\"; a fix to the tests when run
1184           in core Perl; support for TZ files; a modification for the lzma
1185           logic to favour IO::Uncompress::Unlzma; and a fix for an issue with
1186           NetBSD-current and its new unzip(1) executable.
1187
1188       ·   Archive::Tar has been upgraded from version 1.54 to 1.76.
1189
1190           Important changes since 1.54 include the following:
1191
1192           ·   Compatibility with busybox implementations of tar(1).
1193
1194           ·   A fix so that write() and create_archive() close only
1195               filehandles they themselves opened.
1196
1197           ·   A bug was fixed regarding the exit code of extract_archive.
1198
1199           ·   The ptar(1) utility has a new option to allow safe creation of
1200               tarballs without world-writable files on Windows, allowing
1201               those archives to be uploaded to CPAN.
1202
1203           ·   A new ptargrep(1) utility for using regular expressions against
1204               the contents of files in a tar archive.
1205
1206           ·   pax extended headers are now skipped.
1207
1208       ·   Attribute::Handlers has been upgraded from version 0.87 to 0.89.
1209
1210       ·   autodie has been upgraded from version 2.06_01 to 2.1001.
1211
1212       ·   AutoLoader has been upgraded from version 5.70 to 5.71.
1213
1214       ·   The B module has been upgraded from version 1.23 to 1.29.
1215
1216           It no longer crashes when taking apart a "y///" containing
1217           characters outside the octet range or compiled in a "use utf8"
1218           scope.
1219
1220           The size of the shared object has been reduced by about 40%, with
1221           no reduction in functionality.
1222
1223       ·   B::Concise has been upgraded from version 0.78 to 0.83.
1224
1225           B::Concise marks rv2sv(), rv2av(), and rv2hv() ops with the new
1226           "OPpDEREF" flag as "DREFed".
1227
1228           It no longer produces mangled output with the -tree option [perl
1229           #80632].
1230
1231       ·   B::Debug has been upgraded from version 1.12 to 1.16.
1232
1233       ·   B::Deparse has been upgraded from version 0.96 to 1.03.
1234
1235           The deparsing of a "nextstate" op has changed when it has both a
1236           change of package relative to the previous nextstate, or a change
1237           of "%^H" or other state and a label.  The label was previously
1238           emitted first, but is now emitted last (5.12.1).
1239
1240           The "no 5.13.2" or similar form is now correctly handled by
1241           B::Deparse (5.12.3).
1242
1243           B::Deparse now properly handles the code that applies a conditional
1244           pattern match against implicit $_ as it was fixed in [perl #20444].
1245
1246           Deparsing of "our" followed by a variable with funny characters (as
1247           permitted under the "use utf8" pragma) has also been fixed [perl
1248           #33752].
1249
1250       ·   B::Lint has been upgraded from version 1.11_01 to 1.13.
1251
1252       ·   base has been upgraded from version 2.15 to 2.16.
1253
1254       ·   Benchmark has been upgraded from version 1.11 to 1.12.
1255
1256       ·   bignum has been upgraded from version 0.23 to 0.27.
1257
1258       ·   Carp has been upgraded from version 1.15 to 1.20.
1259
1260           Carp now detects incomplete caller() overrides and avoids using
1261           bogus @DB::args.  To provide backtraces, Carp relies on particular
1262           behaviour of the caller() builtin.  Carp now detects if other code
1263           has overridden this with an incomplete implementation, and modifies
1264           its backtrace accordingly.  Previously incomplete overrides would
1265           cause incorrect values in backtraces (best case), or obscure fatal
1266           errors (worst case).
1267
1268           This fixes certain cases of "Bizarre copy of ARRAY" caused by
1269           modules overriding caller() incorrectly (5.12.2).
1270
1271           It now also avoids using regular expressions that cause Perl to
1272           load its Unicode tables, so as to avoid the "BEGIN not safe after
1273           errors" error that ensue if there has been a syntax error [perl
1274           #82854].
1275
1276       ·   CGI has been upgraded from version 3.48 to 3.52.
1277
1278           This provides the following security fixes: the MIME boundary in
1279           multipart_init() is now random and the handling of newlines
1280           embedded in header values has been improved.
1281
1282       ·   Compress::Raw::Bzip2 has been upgraded from version 2.024 to 2.033.
1283
1284           It has been updated to use bzip2(1) 1.0.6.
1285
1286       ·   Compress::Raw::Zlib has been upgraded from version 2.024 to 2.033.
1287
1288       ·   constant has been upgraded from version 1.20 to 1.21.
1289
1290           Unicode constants work once more.  They have been broken since Perl
1291           5.10.0 [CPAN RT #67525].
1292
1293       ·   CPAN has been upgraded from version 1.94_56 to 1.9600.
1294
1295           Major highlights:
1296
1297           ·   much less configuration dialog hassle
1298
1299           ·   support for META/MYMETA.json
1300
1301           ·   support for local::lib
1302
1303           ·   support for HTTP::Tiny to reduce the dependency on FTP sites
1304
1305           ·   automatic mirror selection
1306
1307           ·   iron out all known bugs in configure_requires
1308
1309           ·   support for distributions compressed with bzip2(1)
1310
1311           ·   allow Foo/Bar.pm on the command line to mean "Foo::Bar"
1312
1313       ·   CPANPLUS has been upgraded from version 0.90 to 0.9103.
1314
1315           A change to cpanp-run-perl resolves RT #55964
1316           <http://rt.cpan.org/Public/Bug/Display.html?id=55964> and RT #57106
1317           <http://rt.cpan.org/Public/Bug/Display.html?id=57106>, both of
1318           which related to failures to install distributions that use
1319           "Module::Install::DSL" (5.12.2).
1320
1321           A dependency on Config was not recognised as a core module
1322           dependency.  This has been fixed.
1323
1324           CPANPLUS now includes support for META.json and MYMETA.json.
1325
1326       ·   CPANPLUS::Dist::Build has been upgraded from version 0.46 to 0.54.
1327
1328       ·   Data::Dumper has been upgraded from version 2.125 to 2.130_02.
1329
1330           The indentation used to be off when $Data::Dumper::Terse was set.
1331           This has been fixed [perl #73604].
1332
1333           This upgrade also fixes a crash when using custom sort functions
1334           that might cause the stack to change [perl #74170].
1335
1336           Dumpxs no longer crashes with globs returned by *$io_ref [perl
1337           #72332].
1338
1339       ·   DB_File has been upgraded from version 1.820 to 1.821.
1340
1341       ·   DBM_Filter has been upgraded from version 0.03 to 0.04.
1342
1343       ·   Devel::DProf has been upgraded from version 20080331.00 to
1344           20110228.00.
1345
1346           Merely loading Devel::DProf now no longer triggers profiling to
1347           start.  Both "use Devel::DProf" and "perl -d:DProf ..." behave as
1348           before and start the profiler.
1349
1350           NOTE: Devel::DProf is deprecated and will be removed from a future
1351           version of Perl.  We strongly recommend that you install and use
1352           Devel::NYTProf instead, as it offers significantly improved
1353           profiling and reporting.
1354
1355       ·   Devel::Peek has been upgraded from version 1.04 to 1.07.
1356
1357       ·   Devel::SelfStubber has been upgraded from version 1.03 to 1.05.
1358
1359       ·   diagnostics has been upgraded from version 1.19 to 1.22.
1360
1361           It now renders pod links slightly better, and has been taught to
1362           find descriptions for messages that share their descriptions with
1363           other messages.
1364
1365       ·   Digest::MD5 has been upgraded from version 2.39 to 2.51.
1366
1367           It is now safe to use this module in combination with threads.
1368
1369       ·   Digest::SHA has been upgraded from version 5.47 to 5.61.
1370
1371           "shasum" now more closely mimics sha1sum(1)/md5sum(1).
1372
1373           "addfile" accepts all POSIX filenames.
1374
1375           New SHA-512/224 and SHA-512/256 transforms (ref. NIST Draft FIPS
1376           180-4 [February 2011])
1377
1378       ·   DirHandle has been upgraded from version 1.03 to 1.04.
1379
1380       ·   Dumpvalue has been upgraded from version 1.13 to 1.16.
1381
1382       ·   DynaLoader has been upgraded from version 1.10 to 1.13.
1383
1384           It fixes a buffer overflow when passed a very long file name.
1385
1386           It no longer inherits from AutoLoader; hence it no longer produces
1387           weird error messages for unsuccessful method calls on classes that
1388           inherit from DynaLoader [perl #84358].
1389
1390       ·   Encode has been upgraded from version 2.39 to 2.42.
1391
1392           Now, all 66 Unicode non-characters are treated the same way U+FFFF
1393           has always been treated: in cases when it was disallowed, all 66
1394           are disallowed, and in cases where it warned, all 66 warn.
1395
1396       ·   Env has been upgraded from version 1.01 to 1.02.
1397
1398       ·   Errno has been upgraded from version 1.11 to 1.13.
1399
1400           The implementation of Errno has been refactored to use about 55%
1401           less memory.
1402
1403           On some platforms with unusual header files, like Win32 gcc(1)
1404           using "mingw64" headers, some constants that weren't actually error
1405           numbers have been exposed by Errno.  This has been fixed [perl
1406           #77416].
1407
1408       ·   Exporter has been upgraded from version 5.64_01 to 5.64_03.
1409
1410           Exporter no longer overrides $SIG{__WARN__} [perl #74472]
1411
1412       ·   ExtUtils::CBuilder has been upgraded from version 0.27 to 0.280203.
1413
1414       ·   ExtUtils::Command has been upgraded from version 1.16 to 1.17.
1415
1416       ·   ExtUtils::Constant has been upgraded from 0.22 to 0.23.
1417
1418           The AUTOLOAD helper code generated by
1419           "ExtUtils::Constant::ProxySubs" can now croak() for missing
1420           constants, or generate a complete "AUTOLOAD" subroutine in XS,
1421           allowing simplification of many modules that use it (Fcntl,
1422           File::Glob, GDBM_File, I18N::Langinfo, POSIX, Socket).
1423
1424           ExtUtils::Constant::ProxySubs can now optionally push the names of
1425           all constants onto the package's @EXPORT_OK.
1426
1427       ·   ExtUtils::Install has been upgraded from version 1.55 to 1.56.
1428
1429       ·   ExtUtils::MakeMaker has been upgraded from version 6.56 to 6.57_05.
1430
1431       ·   ExtUtils::Manifest has been upgraded from version 1.57 to 1.58.
1432
1433       ·   ExtUtils::ParseXS has been upgraded from version 2.21 to 2.2210.
1434
1435       ·   Fcntl has been upgraded from version 1.06 to 1.11.
1436
1437       ·   File::Basename has been upgraded from version 2.78 to 2.82.
1438
1439       ·   File::CheckTree has been upgraded from version 4.4 to 4.41.
1440
1441       ·   File::Copy has been upgraded from version 2.17 to 2.21.
1442
1443       ·   File::DosGlob has been upgraded from version 1.01 to 1.04.
1444
1445           It allows patterns containing literal parentheses: they no longer
1446           need to be escaped.  On Windows, it no longer adds an extra ./ to
1447           file names returned when the pattern is a relative glob with a
1448           drive specification, like C:*.pl [perl #71712].
1449
1450       ·   File::Fetch has been upgraded from version 0.24 to 0.32.
1451
1452           HTTP::Lite is now supported for the "http" scheme.
1453
1454           The fetch(1) utility is supported on FreeBSD, NetBSD, and Dragonfly
1455           BSD for the "http" and "ftp" schemes.
1456
1457       ·   File::Find has been upgraded from version 1.15 to 1.19.
1458
1459           It improves handling of backslashes on Windows, so that paths like
1460           C:\dir\/file are no longer generated [perl #71710].
1461
1462       ·   File::Glob has been upgraded from version 1.07 to 1.12.
1463
1464       ·   File::Spec has been upgraded from version 3.31 to 3.33.
1465
1466           Several portability fixes were made in File::Spec::VMS: a colon is
1467           now recognized as a delimiter in native filespecs; caret-escaped
1468           delimiters are recognized for better handling of extended
1469           filespecs; catpath() returns an empty directory rather than the
1470           current directory if the input directory name is empty; and
1471           abs2rel() properly handles Unix-style input (5.12.2).
1472
1473       ·   File::stat has been upgraded from 1.02 to 1.05.
1474
1475           The "-x" and "-X" file test operators now work correctly when run
1476           by the superuser.
1477
1478       ·   Filter::Simple has been upgraded from version 0.84 to 0.86.
1479
1480       ·   GDBM_File has been upgraded from 1.10 to 1.14.
1481
1482           This fixes a memory leak when DBM filters are used.
1483
1484       ·   Hash::Util has been upgraded from 0.07 to 0.11.
1485
1486           Hash::Util no longer emits spurious "uninitialized" warnings when
1487           recursively locking hashes that have undefined values [perl
1488           #74280].
1489
1490       ·   Hash::Util::FieldHash has been upgraded from version 1.04 to 1.09.
1491
1492       ·   I18N::Collate has been upgraded from version 1.01 to 1.02.
1493
1494       ·   I18N::Langinfo has been upgraded from version 0.03 to 0.08.
1495
1496           langinfo() now defaults to using $_ if there is no argument given,
1497           just as the documentation has always claimed.
1498
1499       ·   I18N::LangTags has been upgraded from version 0.35 to 0.35_01.
1500
1501       ·   if has been upgraded from version 0.05 to 0.0601.
1502
1503       ·   IO has been upgraded from version 1.25_02 to 1.25_04.
1504
1505           This version of IO includes a new IO::Select, which now allows
1506           IO::Handle objects (and objects in derived classes) to be removed
1507           from an IO::Select set even if the underlying file descriptor is
1508           closed or invalid.
1509
1510       ·   IPC::Cmd has been upgraded from version 0.54 to 0.70.
1511
1512           Resolves an issue with splitting Win32 command lines.  An argument
1513           consisting of the single character "0" used to be omitted (CPAN RT
1514           #62961).
1515
1516       ·   IPC::Open3 has been upgraded from 1.05 to 1.09.
1517
1518           open3() now produces an error if the "exec" call fails, allowing
1519           this condition to be distinguished from a child process that exited
1520           with a non-zero status [perl #72016].
1521
1522           The internal xclose() routine now knows how to handle file
1523           descriptors as documented, so duplicating "STDIN" in a child
1524           process using its file descriptor now works [perl #76474].
1525
1526       ·   IPC::SysV has been upgraded from version 2.01 to 2.03.
1527
1528       ·   lib has been upgraded from version 0.62 to 0.63.
1529
1530       ·   Locale::Maketext has been upgraded from version 1.14 to 1.19.
1531
1532           Locale::Maketext now supports external caches.
1533
1534           This upgrade also fixes an infinite loop in
1535           "Locale::Maketext::Guts::_compile()" when working with tainted
1536           values (CPAN RT #40727).
1537
1538           "->maketext" calls now back up and restore $@ so error messages are
1539           not suppressed (CPAN RT #34182).
1540
1541       ·   Log::Message has been upgraded from version 0.02 to 0.04.
1542
1543       ·   Log::Message::Simple has been upgraded from version 0.06 to 0.08.
1544
1545       ·   Math::BigInt has been upgraded from version 1.89_01 to 1.994.
1546
1547           This fixes, among other things, incorrect results when computing
1548           binomial coefficients [perl #77640].
1549
1550           It also prevents "sqrt($int)" from crashing under "use bigrat".
1551           [perl #73534].
1552
1553       ·   Math::BigInt::FastCalc has been upgraded from version 0.19 to 0.28.
1554
1555       ·   Math::BigRat has been upgraded from version 0.24 to 0.26_02.
1556
1557       ·   Memoize has been upgraded from version 1.01_03 to 1.02.
1558
1559       ·   MIME::Base64 has been upgraded from 3.08 to 3.13.
1560
1561           Includes new functions to calculate the length of encoded and
1562           decoded base64 strings.
1563
1564           Now provides encode_base64url() and decode_base64url() functions to
1565           process the base64 scheme for "URL applications".
1566
1567       ·   Module::Build has been upgraded from version 0.3603 to 0.3800.
1568
1569           A notable change is the deprecation of several modules.
1570           Module::Build::Version has been deprecated and Module::Build now
1571           relies on the version pragma directly.  Module::Build::ModuleInfo
1572           has been deprecated in favor of a standalone copy called
1573           Module::Metadata.  Module::Build::YAML has been deprecated in favor
1574           of CPAN::Meta::YAML.
1575
1576           Module::Build now also generates META.json and MYMETA.json files in
1577           accordance with version 2 of the CPAN distribution metadata
1578           specification, CPAN::Meta::Spec.  The older format META.yml and
1579           MYMETA.yml files are still generated.
1580
1581       ·   Module::CoreList has been upgraded from version 2.29 to 2.47.
1582
1583           Besides listing the updated core modules of this release, it also
1584           stops listing the "Filespec" module.  That module never existed in
1585           core.  The scripts generating Module::CoreList confused it with
1586           VMS::Filespec, which actually is a core module as of Perl 5.8.7.
1587
1588       ·   Module::Load has been upgraded from version 0.16 to 0.18.
1589
1590       ·   Module::Load::Conditional has been upgraded from version 0.34 to
1591           0.44.
1592
1593       ·   The mro pragma has been upgraded from version 1.02 to 1.07.
1594
1595       ·   NDBM_File has been upgraded from version 1.08 to 1.12.
1596
1597           This fixes a memory leak when DBM filters are used.
1598
1599       ·   Net::Ping has been upgraded from version 2.36 to 2.38.
1600
1601       ·   NEXT has been upgraded from version 0.64 to 0.65.
1602
1603       ·   Object::Accessor has been upgraded from version 0.36 to 0.38.
1604
1605       ·   ODBM_File has been upgraded from version 1.07 to 1.10.
1606
1607           This fixes a memory leak when DBM filters are used.
1608
1609       ·   Opcode has been upgraded from version 1.15 to 1.18.
1610
1611       ·   The overload pragma has been upgraded from 1.10 to 1.13.
1612
1613           "overload::Method" can now handle subroutines that are themselves
1614           blessed into overloaded classes [perl #71998].
1615
1616           The documentation has greatly improved.  See "Documentation" below.
1617
1618       ·   Params::Check has been upgraded from version 0.26 to 0.28.
1619
1620       ·   The parent pragma has been upgraded from version 0.223 to 0.225.
1621
1622       ·   Parse::CPAN::Meta has been upgraded from version 1.40 to 1.4401.
1623
1624           The latest Parse::CPAN::Meta can now read YAML and JSON files using
1625           CPAN::Meta::YAML and JSON::PP, which are now part of the Perl core.
1626
1627       ·   PerlIO::encoding has been upgraded from version 0.12 to 0.14.
1628
1629       ·   PerlIO::scalar has been upgraded from 0.07 to 0.11.
1630
1631           A read() after a seek() beyond the end of the string no longer
1632           thinks it has data to read [perl #78716].
1633
1634       ·   PerlIO::via has been upgraded from version 0.09 to 0.11.
1635
1636       ·   Pod::Html has been upgraded from version 1.09 to 1.11.
1637
1638       ·   Pod::LaTeX has been upgraded from version 0.58 to 0.59.
1639
1640       ·   Pod::Perldoc has been upgraded from version 3.15_02 to 3.15_03.
1641
1642       ·   Pod::Simple has been upgraded from version 3.13 to 3.16.
1643
1644       ·   POSIX has been upgraded from 1.19 to 1.24.
1645
1646           It now includes constants for POSIX signal constants.
1647
1648       ·   The re pragma has been upgraded from version 0.11 to 0.18.
1649
1650           The "use re '/flags'" subpragma is new.
1651
1652           The regmust() function used to crash when called on a regular
1653           expression belonging to a pluggable engine.  Now it croaks instead.
1654
1655           regmust() no longer leaks memory.
1656
1657       ·   Safe has been upgraded from version 2.25 to 2.29.
1658
1659           Coderefs returned by reval() and rdo() are now wrapped via
1660           wrap_code_refs() (5.12.1).
1661
1662           This fixes a possible infinite loop when looking for coderefs.
1663
1664           It adds several "version::vxs::*" routines to the default share.
1665
1666       ·   SDBM_File has been upgraded from version 1.06 to 1.09.
1667
1668       ·   SelfLoader has been upgraded from 1.17 to 1.18.
1669
1670           It now works in taint mode [perl #72062].
1671
1672       ·   The sigtrap pragma has been upgraded from version 1.04 to 1.05.
1673
1674           It no longer tries to modify read-only arguments when generating a
1675           backtrace [perl #72340].
1676
1677       ·   Socket has been upgraded from version 1.87 to 1.94.
1678
1679           See "Improved IPv6 support" above.
1680
1681       ·   Storable has been upgraded from version 2.22 to 2.27.
1682
1683           Includes performance improvement for overloaded classes.
1684
1685           This adds support for serialising code references that contain
1686           UTF-8 strings correctly.  The Storable minor version number changed
1687           as a result, meaning that Storable users who set
1688           $Storable::accept_future_minor to a "FALSE" value will see errors
1689           (see "FORWARD COMPATIBILITY" in Storable for more details).
1690
1691           Freezing no longer gets confused if the Perl stack gets reallocated
1692           during freezing [perl #80074].
1693
1694       ·   Sys::Hostname has been upgraded from version 1.11 to 1.16.
1695
1696       ·   Term::ANSIColor has been upgraded from version 2.02 to 3.00.
1697
1698       ·   Term::UI has been upgraded from version 0.20 to 0.26.
1699
1700       ·   Test::Harness has been upgraded from version 3.17 to 3.23.
1701
1702       ·   Test::Simple has been upgraded from version 0.94 to 0.98.
1703
1704           Among many other things, subtests without a "plan" or "no_plan" now
1705           have an implicit done_testing() added to them.
1706
1707       ·   Thread::Semaphore has been upgraded from version 2.09 to 2.12.
1708
1709           It provides two new methods that give more control over the
1710           decrementing of semaphores: "down_nb" and "down_force".
1711
1712       ·   Thread::Queue has been upgraded from version 2.11 to 2.12.
1713
1714       ·   The threads pragma has been upgraded from version 1.75 to 1.83.
1715
1716       ·   The threads::shared pragma has been upgraded from version 1.32 to
1717           1.37.
1718
1719       ·   Tie::Hash has been upgraded from version 1.03 to 1.04.
1720
1721           Calling "Tie::Hash->TIEHASH()" used to loop forever.  Now it
1722           "croak"s.
1723
1724       ·   Tie::Hash::NamedCapture has been upgraded from version 0.06 to
1725           0.08.
1726
1727       ·   Tie::RefHash has been upgraded from version 1.38 to 1.39.
1728
1729       ·   Time::HiRes has been upgraded from version 1.9719 to 1.9721_01.
1730
1731       ·   Time::Local has been upgraded from version 1.1901_01 to 1.2000.
1732
1733       ·   Time::Piece has been upgraded from version 1.15_01 to 1.20_01.
1734
1735       ·   Unicode::Collate has been upgraded from version 0.52_01 to 0.73.
1736
1737           Unicode::Collate has been updated to use Unicode 6.0.0.
1738
1739           Unicode::Collate::Locale now supports a plethora of new locales:
1740           ar, be, bg, de__phonebook, hu, hy, kk, mk, nso, om, tn, vi, hr, ig,
1741           ja, ko, ru, sq, se, sr, to, uk, zh, zh__big5han, zh__gb2312han,
1742           zh__pinyin, and zh__stroke.
1743
1744           The following modules have been added:
1745
1746           Unicode::Collate::CJK::Big5 for "zh__big5han" which makes tailoring
1747           of CJK Unified Ideographs in the order of CLDR's big5han ordering.
1748
1749           Unicode::Collate::CJK::GB2312 for "zh__gb2312han" which makes
1750           tailoring of CJK Unified Ideographs in the order of CLDR's
1751           gb2312han ordering.
1752
1753           Unicode::Collate::CJK::JISX0208 which makes tailoring of 6355 kanji
1754           (CJK Unified Ideographs) in the JIS X 0208 order.
1755
1756           Unicode::Collate::CJK::Korean which makes tailoring of CJK Unified
1757           Ideographs in the order of CLDR's Korean ordering.
1758
1759           Unicode::Collate::CJK::Pinyin for "zh__pinyin" which makes
1760           tailoring of CJK Unified Ideographs in the order of CLDR's pinyin
1761           ordering.
1762
1763           Unicode::Collate::CJK::Stroke for "zh__stroke" which makes
1764           tailoring of CJK Unified Ideographs in the order of CLDR's stroke
1765           ordering.
1766
1767           This also sees the switch from using the pure-Perl version of this
1768           module to the XS version.
1769
1770       ·   Unicode::Normalize has been upgraded from version 1.03 to 1.10.
1771
1772       ·   Unicode::UCD has been upgraded from version 0.27 to 0.32.
1773
1774           A new function, Unicode::UCD::num(), has been added.  This function
1775           returns the numeric value of the string passed it or "undef" if the
1776           string in its entirety has no "safe" numeric value.  (For more
1777           detail, and for the definition of "safe", see "num()" in
1778           Unicode::UCD.)
1779
1780           This upgrade also includes several bug fixes:
1781
1782           charinfo()
1783               ·   It is now updated to Unicode Version 6.0.0 with Corrigendum
1784                   #8, excepting that, just as with Perl 5.14, the code point
1785                   at U+1F514 has no name.
1786
1787               ·   Hangul syllable code points have the correct names, and
1788                   their decompositions are always output without requiring
1789                   Lingua::KO::Hangul::Util to be installed.
1790
1791               ·   CJK (Chinese-Japanese-Korean) code points U+2A700 to
1792                   U+2B734 and U+2B740 to U+2B81D are now properly handled.
1793
1794               ·   Numeric values are now output for those CJK code points
1795                   that have them.
1796
1797               ·   Names output for code points with multiple aliases are now
1798                   the corrected ones.
1799
1800           charscript()
1801               This now correctly returns "Unknown" instead of "undef" for the
1802               script of a code point that hasn't been assigned another one.
1803
1804           charblock()
1805               This now correctly returns "No_Block" instead of "undef" for
1806               the block of a code point that hasn't been assigned to another
1807               one.
1808
1809       ·   The version pragma has been upgraded from 0.82 to 0.88.
1810
1811           Because of a bug, now fixed, the is_strict() and is_lax() functions
1812           did not work when exported (5.12.1).
1813
1814       ·   The warnings pragma has been upgraded from version 1.09 to 1.12.
1815
1816           Calling "use warnings" without arguments is now significantly more
1817           efficient.
1818
1819       ·   The warnings::register pragma has been upgraded from version 1.01
1820           to 1.02.
1821
1822           It is now possible to register warning categories other than the
1823           names of packages using warnings::register.  See perllexwarn(1) for
1824           more information.
1825
1826       ·   XSLoader has been upgraded from version 0.10 to 0.13.
1827
1828       ·   VMS::DCLsym has been upgraded from version 1.03 to 1.05.
1829
1830           Two bugs have been fixed [perl #84086]:
1831
1832           The symbol table name was lost when tying a hash, due to a thinko
1833           in "TIEHASH".  The result was that all tied hashes interacted with
1834           the local symbol table.
1835
1836           Unless a symbol table name had been explicitly specified in the
1837           call to the constructor, querying the special key ":LOCAL" failed
1838           to identify objects connected to the local symbol table.
1839
1840       ·   The Win32 module has been upgraded from version 0.39 to 0.44.
1841
1842           This release has several new functions: Win32::GetSystemMetrics(),
1843           Win32::GetProductInfo(), Win32::GetOSDisplayName().
1844
1845           The names returned by Win32::GetOSName() and
1846           Win32::GetOSDisplayName() have been corrected.
1847
1848       ·   XS::Typemap has been upgraded from version 0.03 to 0.05.
1849
1850   Removed Modules and Pragmata
1851       As promised in Perl 5.12.0's release notes, the following modules have
1852       been removed from the core distribution, and if needed should be
1853       installed from CPAN instead.
1854
1855       ·   Class::ISA has been removed from the Perl core.  Prior version was
1856           0.36.
1857
1858       ·   Pod::Plainer has been removed from the Perl core.  Prior version
1859           was 1.02.
1860
1861       ·   Switch has been removed from the Perl core.  Prior version was
1862           2.16.
1863
1864       The removal of Shell has been deferred until after 5.14, as the
1865       implementation of Shell shipped with 5.12.0 did not correctly issue the
1866       warning that it was to be removed from core.
1867

Documentation

1869   New Documentation
1870       perlgpl
1871
1872       perlgpl has been updated to contain GPL version 1, as is included in
1873       the README distributed with Perl (5.12.1).
1874
1875       Perl 5.12.x delta files
1876
1877       The perldelta files for Perl 5.12.1 to 5.12.3 have been added from the
1878       maintenance branch: perl5121delta, perl5122delta, perl5123delta.
1879
1880       perlpodstyle
1881
1882       New style guide for POD documentation, split mostly from the NOTES
1883       section of the pod2man(1) manpage.
1884
1885       perlsource, perlinterp, perlhacktut, and perlhacktips
1886
1887       See "perlhack and perlrepository revamp", below.
1888
1889   Changes to Existing Documentation
1890       perlmodlib is now complete
1891
1892       The perlmodlib manpage that came with Perl 5.12.0 was missing several
1893       modules due to a bug in the script that generates the list.  This has
1894       been fixed [perl #74332] (5.12.1).
1895
1896       Replace incorrect tr/// table in perlebcdic
1897
1898       perlebcdic contains a helpful table to use in "tr///" to convert
1899       between EBCDIC and Latin1/ASCII.  The table was the inverse of the one
1900       it describes, though the code that used the table worked correctly for
1901       the specific example given.
1902
1903       The table has been corrected and the sample code changed to correspond.
1904
1905       The table has also been changed to hex from octal, and the recipes in
1906       the pod have been altered to print out leading zeros to make all values
1907       the same length.
1908
1909       Tricks for user-defined casing
1910
1911       perlunicode now contains an explanation of how to override, mangle and
1912       otherwise tweak the way Perl handles upper-, lower- and other-case
1913       conversions on Unicode data, and how to provide scoped changes to alter
1914       one's own code's behaviour without stomping on anybody else's.
1915
1916       INSTALL explicitly states that Perl requires a C89 compiler
1917
1918       This was already true, but it's now Officially Stated For The Record
1919       (5.12.2).
1920
1921       Explanation of "\xHH" and "\oOOO" escapes
1922
1923       perlop has been updated with more detailed explanation of these two
1924       character escapes.
1925
1926       -0NNN switch
1927
1928       In perlrun, the behaviour of the -0NNN switch for -0400 or higher has
1929       been clarified (5.12.2).
1930
1931       Maintenance policy
1932
1933       perlpolicy now contains the policy on what patches are acceptable for
1934       maintenance branches (5.12.1).
1935
1936       Deprecation policy
1937
1938       perlpolicy now contains the policy on compatibility and deprecation
1939       along with definitions of terms like "deprecation" (5.12.2).
1940
1941       New descriptions in perldiag
1942
1943       The following existing diagnostics are now documented:
1944
1945       ·   Ambiguous use of %c resolved as operator %c
1946
1947       ·   Ambiguous use of %c{%s} resolved to %c%s
1948
1949       ·   Ambiguous use of %c{%s[...]} resolved to %c%s[...]
1950
1951       ·   Ambiguous use of %c{%s{...}} resolved to %c%s{...}
1952
1953       ·   Ambiguous use of -%s resolved as -&%s()
1954
1955       ·   Invalid strict version format (%s)
1956
1957       ·   Invalid version format (%s)
1958
1959       ·   Invalid version object
1960
1961       perlbook
1962
1963       perlbook has been expanded to cover many more popular books.
1964
1965       "SvTRUE" macro
1966
1967       The documentation for the "SvTRUE" macro in perlapi was simply wrong in
1968       stating that get-magic is not processed.  It has been corrected.
1969
1970       op manipulation functions
1971
1972       Several API functions that process optrees have been newly documented.
1973
1974       perlvar revamp
1975
1976       perlvar reorders the variables and groups them by topic.  Each variable
1977       introduced after Perl 5.000 notes the first version in which it is
1978       available.  perlvar also has a new section for deprecated variables to
1979       note when they were removed.
1980
1981       Array and hash slices in scalar context
1982
1983       These are now documented in perldata.
1984
1985       "use locale" and formats
1986
1987       perlform and perllocale have been corrected to state that "use locale"
1988       affects formats.
1989
1990       overload
1991
1992       overload's documentation has practically undergone a rewrite.  It is
1993       now much more straightforward and clear.
1994
1995       perlhack and perlrepository revamp
1996
1997       The perlhack document is now much shorter, and focuses on the Perl 5
1998       development process and submitting patches to Perl.  The technical
1999       content has been moved to several new documents, perlsource,
2000       perlinterp, perlhacktut, and perlhacktips.  This technical content has
2001       been only lightly edited.
2002
2003       The perlrepository document has been renamed to perlgit.  This new
2004       document is just a how-to on using git with the Perl source code.  Any
2005       other content that used to be in perlrepository has been moved to
2006       perlhack.
2007
2008       Time::Piece examples
2009
2010       Examples in perlfaq4 have been updated to show the use of Time::Piece.
2011

Diagnostics

2013       The following additions or changes have been made to diagnostic output,
2014       including warnings and fatal error messages.  For the complete list of
2015       diagnostic messages, see perldiag.
2016
2017   New Diagnostics
2018       New Errors
2019
2020       Closure prototype called
2021           This error occurs when a subroutine reference passed to an
2022           attribute handler is called, if the subroutine is a closure [perl
2023           #68560].
2024
2025       Insecure user-defined property %s
2026           Perl detected tainted data when trying to compile a regular
2027           expression that contains a call to a user-defined character
2028           property function, meaning "\p{IsFoo}" or "\p{InFoo}".  See "User-
2029           Defined Character Properties" in perlunicode and perlsec.
2030
2031       panic: gp_free failed to free glob pointer - something is repeatedly
2032       re-creating entries
2033           This new error is triggered if a destructor called on an object in
2034           a typeglob that is being freed creates a new typeglob entry
2035           containing an object with a destructor that creates a new entry
2036           containing an object etc.
2037
2038       Parsing code internal error (%s)
2039           This new fatal error is produced when parsing code supplied by an
2040           extension violates the parser's API in a detectable way.
2041
2042       refcnt: fd %d%s
2043           This new error only occurs if a internal consistency check fails
2044           when a pipe is about to be closed.
2045
2046       Regexp modifier "/%c" may not appear twice
2047           The regular expression pattern has one of the mutually exclusive
2048           modifiers repeated.
2049
2050       Regexp modifiers "/%c" and "/%c" are mutually exclusive
2051           The regular expression pattern has more than one of the mutually
2052           exclusive modifiers.
2053
2054       Using !~ with %s doesn't make sense
2055           This error occurs when "!~" is used with "s///r" or "y///r".
2056
2057       New Warnings
2058
2059       "\b{" is deprecated; use "\b\{" instead
2060       "\B{" is deprecated; use "\B\{" instead
2061           Use of an unescaped "{" immediately following a "\b" or "\B" is now
2062           deprecated in order to reserve its use for Perl itself in a future
2063           release.
2064
2065       Operation "%s" returns its argument for ...
2066           Performing an operation requiring Unicode semantics (such as case-
2067           folding) on a Unicode surrogate or a non-Unicode character now
2068           triggers this warning.
2069
2070       Use of qw(...) as parentheses is deprecated
2071           See "Use of qw(...) as parentheses", above, for details.
2072
2073   Changes to Existing Diagnostics
2074       ·   The "Variable $foo is not imported" warning that precedes a "strict
2075           'vars'" error has now been assigned the "misc" category, so that
2076           "no warnings" will suppress it [perl #73712].
2077
2078       ·   warn() and die() now produce "Wide character" warnings when fed a
2079           character outside the byte range if "STDERR" is a byte-sized
2080           handle.
2081
2082       ·   The "Layer does not match this perl" error message has been
2083           replaced with these more helpful messages [perl #73754]:
2084
2085           ·   PerlIO layer function table size (%d) does not match size
2086               expected by this perl (%d)
2087
2088           ·   PerlIO layer instance size (%d) does not match size expected by
2089               this perl (%d)
2090
2091       ·   The "Found = in conditional" warning that is emitted when a
2092           constant is assigned to a variable in a condition is now withheld
2093           if the constant is actually a subroutine or one generated by "use
2094           constant", since the value of the constant may not be known at the
2095           time the program is written [perl #77762].
2096
2097       ·   Previously, if none of the gethostbyaddr(), gethostbyname() and
2098           gethostent() functions were implemented on a given platform, they
2099           would all die with the message "Unsupported socket function
2100           'gethostent' called", with analogous messages for getnet*() and
2101           getserv*().  This has been corrected.
2102
2103       ·   The warning message about unrecognized regular expression escapes
2104           passed through has been changed to include any literal "{"
2105           following the two-character escape.  For example, "\q{" is now
2106           emitted instead of "\q".
2107

Utility Changes

2109       perlbug(1)
2110
2111       ·   perlbug now looks in the EMAIL environment variable for a return
2112           address if the REPLY-TO and REPLYTO variables are empty.
2113
2114       ·   perlbug did not previously generate a "From:" header, potentially
2115           resulting in dropped mail; it now includes that header.
2116
2117       ·   The user's address is now used as the Return-Path.
2118
2119           Many systems these days don't have a valid Internet domain name,
2120           and perlbug@perl.org does not accept email with a return-path that
2121           does not resolve.  So the user's address is now passed to sendmail
2122           so it's less likely to get stuck in a mail queue somewhere [perl
2123           #82996].
2124
2125       ·   perlbug now always gives the reporter a chance to change the email
2126           address it guesses for them (5.12.2).
2127
2128       ·   perlbug should no longer warn about uninitialized values when using
2129           the -d and -v options (5.12.2).
2130
2131       perl5db.pl
2132
2133       ·   The remote terminal works after forking and spawns new sessions,
2134           one per forked process.
2135
2136       ptargrep
2137
2138       ·   ptargrep is a new utility to apply pattern matching to the contents
2139           of files  in a tar archive.  It comes with "Archive::Tar".
2140

Configuration and Compilation

2142       See also "Naming fixes in Policy_sh.SH may invalidate Policy.sh",
2143       above.
2144
2145       ·   CCINCDIR and CCLIBDIR for the mingw64 cross-compiler are now
2146           correctly under $(CCHOME)\mingw\include and \lib rather than
2147           immediately below $(CCHOME).
2148
2149           This means the "incpath", "libpth", "ldflags", "lddlflags" and
2150           "ldflags_nolargefiles" values in Config.pm and Config_heavy.pl are
2151           now set correctly.
2152
2153       ·   "make test.valgrind" has been adjusted to account for cpan/dist/ext
2154           separation.
2155
2156       ·   On compilers that support it, -Wwrite-strings is now added to
2157           cflags by default.
2158
2159       ·   The Encode module can now (once again) be included in a static Perl
2160           build.  The special-case handling for this situation got broken in
2161           Perl 5.11.0, and has now been repaired.
2162
2163       ·   The previous default size of a PerlIO buffer (4096 bytes) has been
2164           increased to the larger of 8192 bytes and your local BUFSIZ.
2165           Benchmarks show that doubling this decade-old default increases
2166           read and write performance by around 25% to 50% when using the
2167           default layers of perlio on top of unix.  To choose a non-default
2168           size, such as to get back the old value or to obtain an even larger
2169           value, configure with:
2170
2171                ./Configure -Accflags=-DPERLIOBUF_DEFAULT_BUFSIZ=N
2172
2173           where N is the desired size in bytes; it should probably be a
2174           multiple of your page size.
2175
2176       ·   An "incompatible operand types" error in ternary expressions when
2177           building with "clang" has been fixed (5.12.2).
2178
2179       ·   Perl now skips setuid File::Copy tests on partitions it detects
2180           mounted as "nosuid" (5.12.2).
2181

Platform Support

2183   New Platforms
2184       AIX Perl now builds on AIX 4.2 (5.12.1).
2185
2186   Discontinued Platforms
2187       Apollo DomainOS
2188           The last vestiges of support for this platform have been excised
2189           from the Perl distribution.  It was officially discontinued in
2190           version 5.12.0.  It had not worked for years before that.
2191
2192       MacOS Classic
2193           The last vestiges of support for this platform have been excised
2194           from the Perl distribution.  It was officially discontinued in an
2195           earlier version.
2196
2197   Platform-Specific Notes
2198       AIX
2199
2200       ·   README.aix has been updated with information about the XL C/C++ V11
2201           compiler suite (5.12.2).
2202
2203       ARM
2204
2205       ·   The "d_u32align" configuration probe on ARM has been fixed
2206           (5.12.2).
2207
2208       Cygwin
2209
2210       ·   MakeMaker has been updated to build manpages on cygwin.
2211
2212       ·   Improved rebase behaviour
2213
2214           If a DLL is updated on cygwin the old imagebase address is reused.
2215           This solves most rebase errors, especially when updating on core
2216           DLL's.  See
2217           http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README
2218           <http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README>
2219           for more information.
2220
2221       ·   Support for the standard cygwin dll prefix (needed for FFIs)
2222
2223       ·   Updated build hints file
2224
2225       FreeBSD 7
2226
2227       ·   FreeBSD 7 no longer contains /usr/bin/objformat.  At build time,
2228           Perl now skips the objformat check for versions 7 and higher and
2229           assumes ELF (5.12.1).
2230
2231       HP-UX
2232
2233       ·   Perl now allows -Duse64bitint without promoting to "use64bitall" on
2234           HP-UX (5.12.1).
2235
2236       IRIX
2237
2238       ·   Conversion of strings to floating-point numbers is now more
2239           accurate on IRIX systems [perl #32380].
2240
2241       Mac OS X
2242
2243       ·   Early versions of Mac OS X (Darwin) had buggy implementations of
2244           the setregid(), setreuid(), setrgid(,) and setruid() functions, so
2245           Perl would pretend they did not exist.
2246
2247           These functions are now recognised on Mac OS 10.5 (Leopard; Darwin
2248           9) and higher, as they have been fixed [perl #72990].
2249
2250       MirBSD
2251
2252       ·   Previously if you built Perl with a shared libperl.so on MirBSD
2253           (the default config), it would work up to the installation;
2254           however, once installed, it would be unable to find libperl.  Path
2255           handling is now treated as in the other BSD dialects.
2256
2257       NetBSD
2258
2259       ·   The NetBSD hints file has been changed to make the system malloc
2260           the default.
2261
2262       OpenBSD
2263
2264       ·   OpenBSD > 3.7 has a new malloc implementation which is mmap-based,
2265           and as such can release memory back to the OS; however, Perl's use
2266           of this malloc causes a substantial slowdown, so we now default to
2267           using Perl's malloc instead [perl #75742].
2268
2269       OpenVOS
2270
2271       ·   Perl now builds again with OpenVOS (formerly known as Stratus VOS)
2272           [perl #78132] (5.12.3).
2273
2274       Solaris
2275
2276       ·   DTrace is now supported on Solaris.  There used to be build
2277           failures, but these have been fixed [perl #73630] (5.12.3).
2278
2279       VMS
2280
2281       ·   Extension building on older (pre 7.3-2) VMS systems was broken
2282           because configure.com hit the DCL symbol length limit of 1K.  We
2283           now work within this limit when assembling the list of extensions
2284           in the core build (5.12.1).
2285
2286       ·   We fixed configuring and building Perl with -Uuseperlio (5.12.1).
2287
2288       ·   "PerlIOUnix_open" now honours the default permissions on VMS.
2289
2290           When "perlio" became the default and "unix" became the default
2291           bottom layer, the most common path for creating files from Perl
2292           became "PerlIOUnix_open", which has always explicitly used 0666 as
2293           the permission mask.  This prevents inheriting permissions from RMS
2294           defaults and ACLs, so to avoid that problem, we now pass 0777 to
2295           open().  In the VMS CRTL, 0777 has a special meaning over and above
2296           intersecting with the current umask; specifically, it allows Unix
2297           syscalls to preserve native default permissions (5.12.3).
2298
2299       ·   The shortening of symbols longer than 31 characters in the core C
2300           sources and in extensions is now by default done by the C compiler
2301           rather than by xsubpp (which could only do so for generated symbols
2302           in XS code).  You can reenable xsubpp's symbol shortening by
2303           configuring with -Uuseshortenedsymbols, but you'll have some work
2304           to do to get the core sources to compile.
2305
2306       ·   Record-oriented files (record format variable or variable with
2307           fixed control) opened for write by the "perlio" layer will now be
2308           line-buffered to prevent the introduction of spurious line breaks
2309           whenever the perlio buffer fills up.
2310
2311       ·   git_version.h is now installed on VMS.  This was an oversight in
2312           v5.12.0 which caused some extensions to fail to build (5.12.2).
2313
2314       ·   Several memory leaks in stat() have been fixed (5.12.2).
2315
2316       ·   A memory leak in Perl_rename() due to a double allocation has been
2317           fixed (5.12.2).
2318
2319       ·   A memory leak in vms_fid_to_name() (used by realpath() and
2320           realname()> has been fixed (5.12.2).
2321
2322       Windows
2323
2324       See also "fork() emulation will not wait for signalled children" and
2325       "Perl source code is read in text mode on Windows", above.
2326
2327       ·   Fixed build process for SDK2003SP1 compilers.
2328
2329       ·   Compilation with Visual Studio 2010 is now supported.
2330
2331       ·   When using old 32-bit compilers, the define "_USE_32BIT_TIME_T" is
2332           now set in $Config{ccflags}.  This improves portability when
2333           compiling XS extensions using new compilers, but for a Perl
2334           compiled with old 32-bit compilers.
2335
2336       ·   $Config{gccversion} is now set correctly when Perl is built using
2337           the mingw64 compiler from <http://mingw64.org> [perl #73754].
2338
2339       ·   When building Perl with the mingw64 x64 cross-compiler "incpath",
2340           "libpth", "ldflags", "lddlflags" and "ldflags_nolargefiles" values
2341           in Config.pm and Config_heavy.pl were not previously being set
2342           correctly because, with that compiler, the include and lib
2343           directories are not immediately below "$(CCHOME)" (5.12.2).
2344
2345       ·   The build process proceeds more smoothly with mingw and dmake when
2346           C:\MSYS\bin is in the PATH, due to a "Cwd" fix.
2347
2348       ·   Support for building with Visual C++ 2010 is now underway, but is
2349           not yet complete.  See README.win32 or perlwin32 for more details.
2350
2351       ·   The option to use an externally-supplied crypt(), or to build with
2352           no crypt() at all, has been removed.  Perl supplies its own crypt()
2353           implementation for Windows, and the political situation that
2354           required this part of the distribution to sometimes be omitted is
2355           long gone.
2356

Internal Changes

2358   New APIs
2359       CLONE_PARAMS structure added to ease correct thread creation
2360
2361       Modules that create threads should now create "CLONE_PARAMS" structures
2362       by calling the new function Perl_clone_params_new(), and free them with
2363       Perl_clone_params_del().  This will ensure compatibility with any
2364       future changes to the internals of the "CLONE_PARAMS" structure layout,
2365       and that it is correctly allocated and initialised.
2366
2367       New parsing functions
2368
2369       Several functions have been added for parsing Perl statements and
2370       expressions.  These functions are meant to be used by XS code invoked
2371       during Perl parsing, in a recursive-descent manner, to allow modules to
2372       augment the standard Perl syntax.
2373
2374       ·   parse_stmtseq() parses a sequence of statements, up to closing
2375           brace or EOF.
2376
2377       ·   parse_fullstmt() parses a complete Perl statement, including
2378           optional label.
2379
2380       ·   parse_barestmt() parses a statement without a label.
2381
2382       ·   parse_block() parses a code block.
2383
2384       ·   parse_label() parses a statement label, separate from statements.
2385
2386       ·   "parse_fullexpr()", "parse_listexpr()", "parse_termexpr()", and
2387           "parse_arithexpr()" parse expressions at various precedence levels.
2388
2389       Hints hash API
2390
2391       A new C API for introspecting the hinthash "%^H" at runtime has been
2392       added.  See "cop_hints_2hv", "cop_hints_fetchpvn",
2393       "cop_hints_fetchpvs", "cop_hints_fetchsv", and "hv_copy_hints_hv" in
2394       perlapi for details.
2395
2396       A new, experimental API has been added for accessing the internal
2397       structure that Perl uses for "%^H".  See the functions beginning with
2398       "cophh_" in perlapi.
2399
2400       C interface to caller()
2401
2402       The "caller_cx" function has been added as an XSUB-writer's equivalent
2403       of caller().  See perlapi for details.
2404
2405       Custom per-subroutine check hooks
2406
2407       XS code in an extension module can now annotate a subroutine (whether
2408       implemented in XS or in Perl) so that nominated XS code will be called
2409       at compile time (specifically as part of op checking) to change the op
2410       tree of that subroutine.  The compile-time check function (supplied by
2411       the extension module) can implement argument processing that can't be
2412       expressed as a prototype, generate customised compile-time warnings,
2413       perform constant folding for a pure function, inline a subroutine
2414       consisting of sufficiently simple ops, replace the whole call with a
2415       custom op, and so on.  This was previously all possible by hooking the
2416       "entersub" op checker, but the new mechanism makes it easy to tie the
2417       hook to a specific subroutine.  See "cv_set_call_checker" in perlapi.
2418
2419       To help in writing custom check hooks, several subtasks within standard
2420       "entersub" op checking have been separated out and exposed in the API.
2421
2422       Improved support for custom OPs
2423
2424       Custom ops can now be registered with the new "custom_op_register" C
2425       function and the "XOP" structure.  This will make it easier to add new
2426       properties of custom ops in the future.  Two new properties have been
2427       added already, "xop_class" and "xop_peep".
2428
2429       "xop_class" is one of the OA_*OP constants.  It allows B and other
2430       introspection mechanisms to work with custom ops that aren't BASEOPs.
2431       "xop_peep" is a pointer to a function that will be called for ops of
2432       this type from "Perl_rpeep".
2433
2434       See "Custom Operators" in perlguts and "Custom Operators" in perlapi
2435       for more detail.
2436
2437       The old "PL_custom_op_names"/"PL_custom_op_descs" interface is still
2438       supported but discouraged.
2439
2440       Scope hooks
2441
2442       It is now possible for XS code to hook into Perl's lexical scope
2443       mechanism at compile time, using the new "Perl_blockhook_register"
2444       function.  See "Compile-time scope hooks" in perlguts.
2445
2446       The recursive part of the peephole optimizer is now hookable
2447
2448       In addition to "PL_peepp", for hooking into the toplevel peephole
2449       optimizer, a "PL_rpeepp" is now available to hook into the optimizer
2450       recursing into side-chains of the optree.
2451
2452       New non-magical variants of existing functions
2453
2454       The following functions/macros have been added to the API.  The *_nomg
2455       macros are equivalent to their non-"_nomg" variants, except that they
2456       ignore get-magic.  Those ending in "_flags" allow one to specify
2457       whether get-magic is processed.
2458
2459         sv_2bool_flags
2460         SvTRUE_nomg
2461         sv_2nv_flags
2462         SvNV_nomg
2463         sv_cmp_flags
2464         sv_cmp_locale_flags
2465         sv_eq_flags
2466         sv_collxfrm_flags
2467
2468       In some of these cases, the non-"_flags" functions have been replaced
2469       with wrappers around the new functions.
2470
2471       pv/pvs/sv versions of existing functions
2472
2473       Many functions ending with pvn now have equivalent "pv/pvs/sv"
2474       versions.
2475
2476       List op-building functions
2477
2478       List op-building functions have been added to the API.  See
2479       op_append_elem, op_append_list, and op_prepend_elem in perlapi.
2480
2481       "LINKLIST"
2482
2483       The LINKLIST macro, part of op building that constructs the execution-
2484       order op chain, has been added to the API.
2485
2486       Localisation functions
2487
2488       The "save_freeop", "save_op", "save_pushi32ptr" and "save_pushptrptr"
2489       functions have been added to the API.
2490
2491       Stash names
2492
2493       A stash can now have a list of effective names in addition to its usual
2494       name.  The first effective name can be accessed via the "HvENAME"
2495       macro, which is now the recommended name to use in MRO linearisations
2496       ("HvNAME" being a fallback if there is no "HvENAME").
2497
2498       These names are added and deleted via "hv_ename_add" and
2499       "hv_ename_delete".  These two functions are not part of the API.
2500
2501       New functions for finding and removing magic
2502
2503       The "mg_findext()" and "sv_unmagicext()" functions have been added to
2504       the API.  They allow extension authors to find and remove magic
2505       attached to scalars based on both the magic type and the magic virtual
2506       table, similar to how sv_magicext() attaches magic of a certain type
2507       and with a given virtual table to a scalar.  This eliminates the need
2508       for extensions to walk the list of "MAGIC" pointers of an "SV" to find
2509       the magic that belongs to them.
2510
2511       "find_rundefsv"
2512
2513       This function returns the SV representing $_, whether it's lexical or
2514       dynamic.
2515
2516       "Perl_croak_no_modify"
2517
2518       Perl_croak_no_modify() is short-hand for "Perl_croak("%s",
2519       PL_no_modify)".
2520
2521       "PERL_STATIC_INLINE" define
2522
2523       The "PERL_STATIC_INLINE" define has been added to provide the best-
2524       guess incantation to use for static inline functions, if the C compiler
2525       supports C99-style static inline.  If it doesn't, it'll give a plain
2526       "static".
2527
2528       "HAS_STATIC_INLINE" can be used to check if the compiler actually
2529       supports inline functions.
2530
2531       New "pv_escape" option for hexadecimal escapes
2532
2533       A new option, "PERL_PV_ESCAPE_NONASCII", has been added to "pv_escape"
2534       to dump all characters above ASCII in hexadecimal.  Before, one could
2535       get all characters as hexadecimal or the Latin1 non-ASCII as octal.
2536
2537       "lex_start"
2538
2539       "lex_start" has been added to the API, but is considered experimental.
2540
2541       op_scope() and op_lvalue()
2542
2543       The op_scope() and op_lvalue() functions have been added to the API,
2544       but are considered experimental.
2545
2546   C API Changes
2547       "PERL_POLLUTE" has been removed
2548
2549       The option to define "PERL_POLLUTE" to expose older 5.005 symbols for
2550       backwards compatibility has been removed.  Its use was always
2551       discouraged, and MakeMaker contains a more specific escape hatch:
2552
2553           perl Makefile.PL POLLUTE=1
2554
2555       This can be used for modules that have not been upgraded to 5.6 naming
2556       conventions (and really should be completely obsolete by now).
2557
2558       Check API compatibility when loading XS modules
2559
2560       When Perl's API changes in incompatible ways (which usually happens
2561       between major releases), XS modules compiled for previous versions of
2562       Perl will no longer work.  They need to be recompiled against the new
2563       Perl.
2564
2565       The "XS_APIVERSION_BOOTCHECK" macro has been added to ensure that
2566       modules are recompiled and to prevent users from accidentally loading
2567       modules compiled for old perls into newer perls.  That macro, which is
2568       called when loading every newly compiled extension, compares the API
2569       version of the running perl with the version a module has been compiled
2570       for and raises an exception if they don't match.
2571
2572       Perl_fetch_cop_label
2573
2574       The first argument of the C API function "Perl_fetch_cop_label" has
2575       changed from "struct refcounted_he *" to "COP *", to insulate the user
2576       from implementation details.
2577
2578       This API function was marked as "may change", and likely isn't in use
2579       outside the core.  (Neither an unpacked CPAN nor Google's codesearch
2580       finds any other references to it.)
2581
2582       GvCV() and GvGP() are no longer lvalues
2583
2584       The new GvCV_set() and GvGP_set() macros are now provided to replace
2585       assignment to those two macros.
2586
2587       This allows a future commit to eliminate some backref magic between GV
2588       and CVs, which will require complete control over assignment to the
2589       "gp_cv" slot.
2590
2591       CvGV() is no longer an lvalue
2592
2593       Under some circumstances, the CvGV() field of a CV is now reference-
2594       counted.  To ensure consistent behaviour, direct assignment to it, for
2595       example "CvGV(cv) = gv" is now a compile-time error.  A new macro,
2596       "CvGV_set(cv,gv)" has been introduced to run this operation safely.
2597       Note that modification of this field is not part of the public API,
2598       regardless of this new macro (and despite its being listed in this
2599       section).
2600
2601       CvSTASH() is no longer an lvalue
2602
2603       The CvSTASH() macro can now only be used as an rvalue.  CvSTASH_set()
2604       has been added to replace assignment to CvSTASH().  This is to ensure
2605       that backreferences are handled properly.  These macros are not part of
2606       the API.
2607
2608       Calling conventions for "newFOROP" and "newWHILEOP"
2609
2610       The way the parser handles labels has been cleaned up and refactored.
2611       As a result, the newFOROP() constructor function no longer takes a
2612       parameter stating what label is to go in the state op.
2613
2614       The newWHILEOP() and newFOROP() functions no longer accept a line
2615       number as a parameter.
2616
2617       Flags passed to "uvuni_to_utf8_flags" and "utf8n_to_uvuni"
2618
2619       Some of the flags parameters to uvuni_to_utf8_flags() and
2620       utf8n_to_uvuni() have changed.  This is a result of Perl's now allowing
2621       internal storage and manipulation of code points that are problematic
2622       in some situations.  Hence, the default actions for these functions has
2623       been complemented to allow these code points.  The new flags are
2624       documented in perlapi.  Code that requires the problematic code points
2625       to be rejected needs to change to use the new flags.  Some flag names
2626       are retained for backward source compatibility, though they do nothing,
2627       as they are now the default.  However the flags "UNICODE_ALLOW_FDD0",
2628       "UNICODE_ALLOW_FFFF", "UNICODE_ILLEGAL", and "UNICODE_IS_ILLEGAL" have
2629       been removed, as they stem from a fundamentally broken model of how the
2630       Unicode non-character code points should be handled, which is now
2631       described in "Non-character code points" in perlunicode.  See also the
2632       Unicode section under "Selected Bug Fixes".
2633
2634   Deprecated C APIs
2635       "Perl_ptr_table_clear"
2636           "Perl_ptr_table_clear" is no longer part of Perl's public API.
2637           Calling it now generates a deprecation warning, and it will be
2638           removed in a future release.
2639
2640       "sv_compile_2op"
2641           The sv_compile_2op() API function is now deprecated.  Searches
2642           suggest that nothing on CPAN is using it, so this should have zero
2643           impact.
2644
2645           It attempted to provide an API to compile code down to an optree,
2646           but failed to bind correctly to lexicals in the enclosing scope.
2647           It's not possible to fix this problem within the constraints of its
2648           parameters and return value.
2649
2650       "find_rundefsvoffset"
2651           The "find_rundefsvoffset" function has been deprecated.  It
2652           appeared that its design was insufficient for reliably getting the
2653           lexical $_ at run-time.
2654
2655           Use the new "find_rundefsv" function or the "UNDERBAR" macro
2656           instead.  They directly return the right SV representing $_,
2657           whether it's lexical or dynamic.
2658
2659       "CALL_FPTR" and "CPERLscope"
2660           Those are left from an old implementation of "MULTIPLICITY" using
2661           C++ objects, which was removed in Perl 5.8.  Nowadays these macros
2662           do exactly nothing, so they shouldn't be used anymore.
2663
2664           For compatibility, they are still defined for external "XS" code.
2665           Only extensions defining "PERL_CORE" must be updated now.
2666
2667   Other Internal Changes
2668       Stack unwinding
2669
2670       The protocol for unwinding the C stack at the last stage of a "die" has
2671       changed how it identifies the target stack frame.  This now uses a
2672       separate variable "PL_restartjmpenv", where previously it relied on the
2673       "blk_eval.cur_top_env" pointer in the "eval" context frame that has
2674       nominally just been discarded.  This change means that code running
2675       during various stages of Perl-level unwinding no longer needs to take
2676       care to avoid destroying the ghost frame.
2677
2678       Scope stack entries
2679
2680       The format of entries on the scope stack has been changed, resulting in
2681       a reduction of memory usage of about 10%.  In particular, the memory
2682       used by the scope stack to record each active lexical variable has been
2683       halved.
2684
2685       Memory allocation for pointer tables
2686
2687       Memory allocation for pointer tables has been changed.  Previously
2688       "Perl_ptr_table_store" allocated memory from the same arena system as
2689       "SV" bodies and "HE"s, with freed memory remaining bound to those
2690       arenas until interpreter exit.  Now it allocates memory from arenas
2691       private to the specific pointer table, and that memory is returned to
2692       the system when "Perl_ptr_table_free" is called.  Additionally,
2693       allocation and release are both less CPU intensive.
2694
2695       "UNDERBAR"
2696
2697       The "UNDERBAR" macro now calls "find_rundefsv".  "dUNDERBAR" is now a
2698       noop but should still be used to ensure past and future compatibility.
2699
2700       String comparison routines renamed
2701
2702       The "ibcmp_*" functions have been renamed and are now called "foldEQ",
2703       "foldEQ_locale", and "foldEQ_utf8".  The old names are still available
2704       as macros.
2705
2706       "chop" and "chomp" implementations merged
2707
2708       The opcode bodies for "chop" and "chomp" and for "schop" and "schomp"
2709       have been merged.  The implementation functions Perl_do_chop() and
2710       Perl_do_chomp(), never part of the public API, have been merged and
2711       moved to a static function in pp.c.  This shrinks the Perl binary
2712       slightly, and should not affect any code outside the core (unless it is
2713       relying on the order of side-effects when "chomp" is passed a list of
2714       values).
2715

Selected Bug Fixes

2717   I/O
2718       ·   Perl no longer produces this warning:
2719
2720               $ perl -we 'open(my $f, ">", \my $x); binmode($f, "scalar")'
2721               Use of uninitialized value in binmode at -e line 1.
2722
2723       ·   Opening a glob reference via "open($fh, ">", \*glob)" no longer
2724           causes the glob to be corrupted when the filehandle is printed to.
2725           This would cause Perl to crash whenever the glob's contents were
2726           accessed [perl #77492].
2727
2728       ·   PerlIO no longer crashes when called recursively, such as from a
2729           signal handler.  Now it just leaks memory [perl #75556].
2730
2731       ·   Most I/O functions were not warning for unopened handles unless the
2732           "closed" and "unopened" warnings categories were both enabled.  Now
2733           only "use warnings 'unopened'" is necessary to trigger these
2734           warnings, as had always been the intention.
2735
2736       ·   There have been several fixes to PerlIO layers:
2737
2738           When "binmode(FH, ":crlf")" pushes the ":crlf" layer on top of the
2739           stack, it no longer enables crlf layers lower in the stack so as to
2740           avoid unexpected results [perl #38456].
2741
2742           Opening a file in ":raw" mode now does what it advertises to do
2743           (first open the file, then "binmode" it), instead of simply leaving
2744           off the top layer [perl #80764].
2745
2746           The three layers ":pop", ":utf8", and ":bytes" didn't allow
2747           stacking when opening a file.  For example this:
2748
2749               open(FH, ">:pop:perlio", "some.file") or die $!;
2750
2751           would throw an "Invalid argument" error.  This has been fixed in
2752           this release [perl #82484].
2753
2754   Regular Expression Bug Fixes
2755       ·   The regular expression engine no longer loops when matching
2756           ""\N{LATIN SMALL LIGATURE FF}" =~ /f+/i" and similar expressions
2757           [perl #72998] (5.12.1).
2758
2759       ·   The trie runtime code should no longer allocate massive amounts of
2760           memory, fixing #74484.
2761
2762       ·   Syntax errors in "(?{...})" blocks no longer cause panic messages
2763           [perl #2353].
2764
2765       ·   A pattern like "(?:(o){2})?" no longer causes a "panic" error [perl
2766           #39233].
2767
2768       ·   A fatal error in regular expressions containing "(.*?)" when
2769           processing UTF-8 data has been fixed [perl #75680] (5.12.2).
2770
2771       ·   An erroneous regular expression engine optimisation that caused
2772           regex verbs like *COMMIT sometimes to be ignored has been removed.
2773
2774       ·   The regular expression bracketed character class "[\8\9]" was
2775           effectively the same as "[89\000]", incorrectly matching a NULL
2776           character.  It also gave incorrect warnings that the 8 and 9 were
2777           ignored.  Now "[\8\9]" is the same as "[89]" and gives legitimate
2778           warnings that "\8" and "\9" are unrecognized escape sequences,
2779           passed-through.
2780
2781       ·   A regular expression match in the right-hand side of a global
2782           substitution ("s///g") that is in the same scope will no longer
2783           cause match variables to have the wrong values on subsequent
2784           iterations.  This can happen when an array or hash subscript is
2785           interpolated in the right-hand side, as in "s|(.)|@a{ print($1),
2786           /./ }|g" [perl #19078].
2787
2788       ·   Several cases in which characters in the Latin-1 non-ASCII range
2789           (0x80 to 0xFF) used not to match themselves, or used to match both
2790           a character class and its complement, have been fixed.  For
2791           instance, U+00E2 could match both "\w" and "\W" [perl #78464] [perl
2792           #18281] [perl #60156].
2793
2794       ·   Matching a Unicode character against an alternation containing
2795           characters that happened to match continuation bytes in the
2796           former's UTF8 representation (like "qq{\x{30ab}} =~ /\xab|\xa9/")
2797           would cause erroneous warnings [perl #70998].
2798
2799       ·   The trie optimisation was not taking empty groups into account,
2800           preventing "foo" from matching "/\A(?:(?:)foo|bar|zot)\z/" [perl
2801           #78356].
2802
2803       ·   A pattern containing a "+" inside a lookahead would sometimes cause
2804           an incorrect match failure in a global match (for example,
2805           "/(?=(\S+))/g") [perl #68564].
2806
2807       ·   A regular expression optimisation would sometimes cause a match
2808           with a "{n,m}" quantifier to fail when it should have matched [perl
2809           #79152].
2810
2811       ·   Case-insensitive matching in regular expressions compiled under
2812           "use locale" now works much more sanely when the pattern or target
2813           string is internally encoded in UTF8.  Previously, under these
2814           conditions the localeness was completely lost.  Now, code points
2815           above 255 are treated as Unicode, but code points between 0 and 255
2816           are treated using the current locale rules, regardless of whether
2817           the pattern or the string is encoded in UTF8.  The few case-
2818           insensitive matches that cross the 255/256 boundary are not
2819           allowed.  For example, 0xFF does not caselessly match the character
2820           at 0x178, LATIN CAPITAL LETTER Y WITH DIAERESIS, because 0xFF may
2821           not be LATIN SMALL LETTER Y in the current locale, and Perl has no
2822           way of knowing if that character even exists in the locale, much
2823           less what code point it is.
2824
2825       ·   The "(?|...)" regular expression construct no longer crashes if the
2826           final branch has more sets of capturing parentheses than any other
2827           branch.  This was fixed in Perl 5.10.1 for the case of a single
2828           branch, but that fix did not take multiple branches into account
2829           [perl #84746].
2830
2831       ·   A bug has been fixed in the implementation of "{...}" quantifiers
2832           in regular expressions that prevented the code block in "/((\w+)(?{
2833           print $2 })){2}/" from seeing the $2 sometimes [perl #84294].
2834
2835   Syntax/Parsing Bugs
2836       ·   "when (scalar) {...}" no longer crashes, but produces a syntax
2837           error [perl #74114] (5.12.1).
2838
2839       ·   A label right before a string eval ("foo: eval $string") no longer
2840           causes the label to be associated also with the first statement
2841           inside the eval [perl #74290] (5.12.1).
2842
2843       ·   The "no 5.13.2" form of "no" no longer tries to turn on features or
2844           pragmata (like strict) [perl #70075] (5.12.2).
2845
2846       ·   "BEGIN {require 5.12.0}" now behaves as documented, rather than
2847           behaving identically to "use 5.12.0".  Previously, "require" in a
2848           "BEGIN" block was erroneously executing the "use feature ':5.12.0'"
2849           and "use strict" behaviour, which only "use" was documented to
2850           provide [perl #69050].
2851
2852       ·   A regression introduced in Perl 5.12.0, making "my $x = 3; $x =
2853           length(undef)" result in $x set to 3 has been fixed.  $x will now
2854           be "undef" [perl #85508] (5.12.2).
2855
2856       ·   When strict "refs" mode is off, "%{...}" in rvalue context returns
2857           "undef" if its argument is undefined.  An optimisation introduced
2858           in Perl 5.12.0 to make "keys %{...}" faster when used as a boolean
2859           did not take this into account, causing "keys %{+undef}" (and "keys
2860           %$foo" when $foo is undefined) to be an error, which it should be
2861           so in strict mode only [perl #81750].
2862
2863       ·   Constant-folding used to cause
2864
2865             $text =~ ( 1 ? /phoo/ : /bear/)
2866
2867           to turn into
2868
2869             $text =~ /phoo/
2870
2871           at compile time.  Now it correctly matches against $_ [perl
2872           #20444].
2873
2874       ·   Parsing Perl code (either with string "eval" or by loading modules)
2875           from within a "UNITCHECK" block no longer causes the interpreter to
2876           crash [perl #70614].
2877
2878       ·   String "eval"s no longer fail after 2 billion scopes have been
2879           compiled [perl #83364].
2880
2881       ·   The parser no longer hangs when encountering certain Unicode
2882           characters, such as U+387 [perl #74022].
2883
2884       ·   Defining a constant with the same name as one of Perl's special
2885           blocks (like "INIT") stopped working in 5.12.0, but has now been
2886           fixed [perl #78634].
2887
2888       ·   A reference to a literal value used as a hash key ($hash{\"foo"})
2889           used to be stringified, even if the hash was tied [perl #79178].
2890
2891       ·   A closure containing an "if" statement followed by a constant or
2892           variable is no longer treated as a constant [perl #63540].
2893
2894       ·   "state" can now be used with attributes.  It used to mean the same
2895           thing as "my" if any attributes were present [perl #68658].
2896
2897       ·   Expressions like "@$a > 3" no longer cause $a to be mentioned in
2898           the "Use of uninitialized value in numeric gt" warning when $a is
2899           undefined (since it is not part of the ">" expression, but the
2900           operand of the "@") [perl #72090].
2901
2902       ·   Accessing an element of a package array with a hard-coded number
2903           (as opposed to an arbitrary expression) would crash if the array
2904           did not exist.  Usually the array would be autovivified during
2905           compilation, but typeglob manipulation could remove it, as in these
2906           two cases which used to crash:
2907
2908             *d = *a;  print $d[0];
2909             undef *d; print $d[0];
2910
2911       ·   The -C command-line option, when used on the shebang line, can now
2912           be followed by other options [perl #72434].
2913
2914       ·   The "B" module was returning "B::OP"s instead of "B::LOGOP"s for
2915           "entertry" [perl #80622].  This was due to a bug in the Perl core,
2916           not in "B" itself.
2917
2918   Stashes, Globs and Method Lookup
2919       Perl 5.10.0 introduced a new internal mechanism for caching MROs
2920       (method resolution orders, or lists of parent classes; aka "isa"
2921       caches) to make method lookup faster (so @ISA arrays would not have to
2922       be searched repeatedly).  Unfortunately, this brought with it quite a
2923       few bugs.  Almost all of these have been fixed now, along with a few
2924       MRO-related bugs that existed before 5.10.0:
2925
2926       ·   The following used to have erratic effects on method resolution,
2927           because the "isa" caches were not reset or otherwise ended up
2928           listing the wrong classes.  These have been fixed.
2929
2930           Aliasing packages by assigning to globs [perl #77358]
2931           Deleting packages by deleting their containing stash elements
2932           Undefining the glob containing a package ("undef *Foo::")
2933           Undefining an ISA glob ("undef *Foo::ISA")
2934           Deleting an ISA stash element ("delete $Foo::{ISA}")
2935           Sharing @ISA arrays between classes (via "*Foo::ISA = \@Bar::ISA"
2936           or "*Foo::ISA = *Bar::ISA") [perl #77238]
2937
2938           "undef *Foo::ISA" would even stop a new @Foo::ISA array from
2939           updating caches.
2940
2941       ·   Typeglob assignments would crash if the glob's stash no longer
2942           existed, so long as the glob assigned to were named "ISA" or the
2943           glob on either side of the assignment contained a subroutine.
2944
2945       ·   "PL_isarev", which is accessible to Perl via "mro::get_isarev" is
2946           now updated properly when packages are deleted or removed from the
2947           @ISA of other classes.  This allows many packages to be created and
2948           deleted without causing a memory leak [perl #75176].
2949
2950       In addition, various other bugs related to typeglobs and stashes have
2951       been fixed:
2952
2953       ·   Some work has been done on the internal pointers that link between
2954           symbol tables (stashes), typeglobs, and subroutines.  This has the
2955           effect that various edge cases related to deleting stashes or stash
2956           entries (for example, <%FOO:: = ()>), and complex typeglob or code-
2957           reference aliasing, will no longer crash the interpreter.
2958
2959       ·   Assigning a reference to a glob copy now assigns to a glob slot
2960           instead of overwriting the glob with a scalar [perl #1804] [perl
2961           #77508].
2962
2963       ·   A bug when replacing the glob of a loop variable within the loop
2964           has been fixed [perl #21469].  This means the following code will
2965           no longer crash:
2966
2967               for $x (...) {
2968                   *x = *y;
2969               }
2970
2971       ·   Assigning a glob to a PVLV used to convert it to a plain string.
2972           Now it works correctly, and a PVLV can hold a glob.  This would
2973           happen when a nonexistent hash or array element was passed to a
2974           subroutine:
2975
2976             sub { $_[0] = *foo }->($hash{key});
2977             # $_[0] would have been the string "*main::foo"
2978
2979           It also happened when a glob was assigned to, or returned from, an
2980           element of a tied array or hash [perl #36051].
2981
2982       ·   When trying to report "Use of uninitialized value $Foo::BAR",
2983           crashes could occur if the glob holding the global variable in
2984           question had been detached from its original stash by, for example,
2985           "delete $::{"Foo::"}".  This has been fixed by disabling the
2986           reporting of variable names in those cases.
2987
2988       ·   During the restoration of a localised typeglob on scope exit, any
2989           destructors called as a result would be able to see the typeglob in
2990           an inconsistent state, containing freed entries, which could result
2991           in a crash.  This would affect code like this:
2992
2993             local *@;
2994             eval { die bless [] }; # puts an object in $@
2995             sub DESTROY {
2996               local $@; # boom
2997             }
2998
2999           Now the glob entries are cleared before any destructors are called.
3000           This also means that destructors can vivify entries in the glob.
3001           So Perl tries again and, if the entries are re-created too many
3002           times, dies with a "panic: gp_free ..." error message.
3003
3004       ·   If a typeglob is freed while a subroutine attached to it is still
3005           referenced elsewhere, the subroutine is renamed to "__ANON__" in
3006           the same package, unless the package has been undefined, in which
3007           case the "__ANON__" package is used.  This could cause packages to
3008           be sometimes autovivified, such as if the package had been deleted.
3009           Now this no longer occurs.  The "__ANON__" package is also now used
3010           when the original package is no longer attached to the symbol
3011           table.  This avoids memory leaks in some cases [perl #87664].
3012
3013       ·   Subroutines and package variables inside a package whose name ends
3014           with "::" can now be accessed with a fully qualified name.
3015
3016   Unicode
3017       ·   What has become known as "the Unicode Bug" is almost completely
3018           resolved in this release.  Under "use feature 'unicode_strings'"
3019           (which is automatically selected by "use 5.012" and above), the
3020           internal storage format of a string no longer affects the external
3021           semantics.  [perl #58182].
3022
3023           There are two known exceptions:
3024
3025           1.  The now-deprecated, user-defined case-changing functions
3026               require utf8-encoded strings to operate.  The CPAN module
3027               Unicode::Casing has been written to replace this feature
3028               without its drawbacks, and the feature is scheduled to be
3029               removed in 5.16.
3030
3031           2.  quotemeta() (and its in-line equivalent "\Q") can also give
3032               different results depending on whether a string is encoded in
3033               UTF-8.  See "The "Unicode Bug"" in perlunicode.
3034
3035       ·   Handling of Unicode non-character code points has changed.
3036           Previously they were mostly considered illegal, except that in some
3037           place only one of the 66 of them was known.  The Unicode Standard
3038           considers them all legal, but forbids their "open interchange".
3039           This is part of the change to allow internal use of any code point
3040           (see "Core Enhancements").  Together, these changes resolve [perl
3041           #38722], [perl #51918], [perl #51936], and [perl #63446].
3042
3043       ·   Case-insensitive "/i" regular expression matching of Unicode
3044           characters that match multiple characters now works much more as
3045           intended.  For example
3046
3047            "\N{LATIN SMALL LIGATURE FFI}" =~ /ffi/ui
3048
3049           and
3050
3051            "ffi" =~ /\N{LATIN SMALL LIGATURE FFI}/ui
3052
3053           are both true.  Previously, there were many bugs with this feature.
3054           What hasn't been fixed are the places where the pattern contains
3055           the multiple characters, but the characters are split up by other
3056           things, such as in
3057
3058            "\N{LATIN SMALL LIGATURE FFI}" =~ /(f)(f)i/ui
3059
3060           or
3061
3062            "\N{LATIN SMALL LIGATURE FFI}" =~ /ffi*/ui
3063
3064           or
3065
3066            "\N{LATIN SMALL LIGATURE FFI}" =~ /[a-f][f-m][g-z]/ui
3067
3068           None of these match.
3069
3070           Also, this matching doesn't fully conform to the current Unicode
3071           Standard, which asks that the matching be made upon the NFD
3072           (Normalization Form Decomposed) of the text.  However, as of this
3073           writing (April 2010), the Unicode Standard is currently in flux
3074           about what they will recommend doing with regard in such scenarios.
3075           It may be that they will throw out the whole concept of multi-
3076           character matches.  [perl #71736].
3077
3078       ·   Naming a deprecated character in "\N{NAME}" no longer leaks memory.
3079
3080       ·   We fixed a bug that could cause "\N{NAME}" constructs followed by a
3081           single "." to be parsed incorrectly [perl #74978] (5.12.1).
3082
3083       ·   "chop" now correctly handles characters above "\x{7fffffff}" [perl
3084           #73246].
3085
3086       ·   Passing to "index" an offset beyond the end of the string when the
3087           string is encoded internally in UTF8 no longer causes panics [perl
3088           #75898].
3089
3090       ·   warn() and die() now respect utf8-encoded scalars [perl #45549].
3091
3092       ·   Sometimes the UTF8 length cache would not be reset on a value
3093           returned by substr, causing "length(substr($uni_string, ...))" to
3094           give wrong answers.  With "${^UTF8CACHE}" set to -1, it would also
3095           produce a "panic" error message [perl #77692].
3096
3097   Ties, Overloading and Other Magic
3098       ·   Overloading now works properly in conjunction with tied variables.
3099           What formerly happened was that most ops checked their arguments
3100           for overloading before checking for magic, so for example an
3101           overloaded object returned by a tied array access would usually be
3102           treated as not overloaded [RT #57012].
3103
3104       ·   Various instances of magic (like tie methods) being called on tied
3105           variables too many or too few times have been fixed:
3106
3107           ·   "$tied->()" did not always call FETCH [perl #8438].
3108
3109           ·   Filetest operators and "y///" and "tr///" were calling FETCH
3110               too many times.
3111
3112           ·   The "=" operator used to ignore magic on its right-hand side if
3113               the scalar happened to hold a typeglob (if a typeglob was the
3114               last thing returned from or assigned to a tied scalar) [perl
3115               #77498].
3116
3117           ·   Dereference operators used to ignore magic if the argument was
3118               a reference already (such as from a previous FETCH) [perl
3119               #72144].
3120
3121           ·   "splice" now calls set-magic (so changes made by "splice @ISA"
3122               are respected by method calls) [perl #78400].
3123
3124           ·   In-memory files created by "open($fh, ">", \$buffer)" were not
3125               calling FETCH/STORE at all [perl #43789] (5.12.2).
3126
3127           ·   utf8::is_utf8() now respects get-magic (like $1) (5.12.1).
3128
3129       ·   Non-commutative binary operators used to swap their operands if the
3130           same tied scalar was used for both operands and returned a
3131           different value for each FETCH.  For instance, if $t returned 2 the
3132           first time and 3 the second, then "$t/$t" would evaluate to 1.5.
3133           This has been fixed [perl #87708].
3134
3135       ·   String "eval" now detects taintedness of overloaded or tied
3136           arguments [perl #75716].
3137
3138       ·   String "eval" and regular expression matches against objects with
3139           string overloading no longer cause memory corruption or crashes
3140           [perl #77084].
3141
3142       ·   readline now honors "<>" overloading on tied arguments.
3143
3144       ·   "<expr>" always respects overloading now if the expression is
3145           overloaded.
3146
3147           Because "<> as glob" was parsed differently from "<> as filehandle"
3148           from 5.6 onwards, something like "<$foo[0]>" did not handle
3149           overloading, even if $foo[0] was an overloaded object.  This was
3150           contrary to the documentation for overload, and meant that "<>"
3151           could not be used as a general overloaded iterator operator.
3152
3153       ·   The fallback behaviour of overloading on binary operators was
3154           asymmetric [perl #71286].
3155
3156       ·   Magic applied to variables in the main package no longer affects
3157           other packages.  See "Magic variables outside the main package"
3158           above [perl #76138].
3159
3160       ·   Sometimes magic (ties, taintedness, etc.) attached to variables
3161           could cause an object to last longer than it should, or cause a
3162           crash if a tied variable were freed from within a tie method.
3163           These have been fixed [perl #81230].
3164
3165       ·   DESTROY methods of objects implementing ties are no longer able to
3166           crash by accessing the tied variable through a weak reference [perl
3167           #86328].
3168
3169       ·   Fixed a regression of kill() when a match variable is used for the
3170           process ID to kill [perl #75812].
3171
3172       ·   $AUTOLOAD used to remain tainted forever if it ever became tainted.
3173           Now it is correctly untainted if an autoloaded method is called and
3174           the method name was not tainted.
3175
3176       ·   "sprintf" now dies when passed a tainted scalar for the format.  It
3177           did already die for arbitrary expressions, but not for simple
3178           scalars [perl #82250].
3179
3180       ·   "lc", "uc", "lcfirst", and "ucfirst" no longer return untainted
3181           strings when the argument is tainted.  This has been broken since
3182           perl 5.8.9 [perl #87336].
3183
3184   The Debugger
3185       ·   The Perl debugger now also works in taint mode [perl #76872].
3186
3187       ·   Subroutine redefinition works once more in the debugger [perl
3188           #48332].
3189
3190       ·   When -d is used on the shebang ("#!") line, the debugger now has
3191           access to the lines of the main program.  In the past, this
3192           sometimes worked and sometimes did not, depending on the order in
3193           which things happened to be arranged in memory [perl #71806].
3194
3195       ·   A possible memory leak when using caller() to set @DB::args has
3196           been fixed (5.12.2).
3197
3198       ·   Perl no longer stomps on $DB::single, $DB::trace, and $DB::signal
3199           if these variables already have values when $^P is assigned to
3200           [perl #72422].
3201
3202       ·   "#line" directives in string evals were not properly updating the
3203           arrays of lines of code ("@{"_< ..."}") that the debugger (or any
3204           debugging or profiling module) uses.  In threaded builds, they were
3205           not being updated at all.  In non-threaded builds, the line number
3206           was ignored, so any change to the existing line number would cause
3207           the lines to be misnumbered [perl #79442].
3208
3209   Threads
3210       ·   Perl no longer accidentally clones lexicals in scope within active
3211           stack frames in the parent when creating a child thread [perl
3212           #73086].
3213
3214       ·   Several memory leaks in cloning and freeing threaded Perl
3215           interpreters have been fixed [perl #77352].
3216
3217       ·   Creating a new thread when directory handles were open used to
3218           cause a crash, because the handles were not cloned, but simply
3219           passed to the new thread, resulting in a double free.
3220
3221           Now directory handles are cloned properly on Windows and on systems
3222           that have a "fchdir" function.  On other systems, new threads
3223           simply do not inherit directory handles from their parent threads
3224           [perl #75154].
3225
3226       ·   The typeglob "*,", which holds the scalar variable $, (output field
3227           separator), had the wrong reference count in child threads.
3228
3229       ·   [perl #78494] When pipes are shared between threads, the "close"
3230           function (and any implicit close, such as on thread exit) no longer
3231           blocks.
3232
3233       ·   Perl now does a timely cleanup of SVs that are cloned into a new
3234           thread but then discovered to be orphaned (that is, their owners
3235           are not cloned).  This eliminates several "scalars leaked" warnings
3236           when joining threads.
3237
3238   Scoping and Subroutines
3239       ·   Lvalue subroutines are again able to return copy-on-write scalars.
3240           This had been broken since version 5.10.0 [perl #75656] (5.12.3).
3241
3242       ·   "require" no longer causes "caller" to return the wrong file name
3243           for the scope that called "require" and other scopes higher up that
3244           had the same file name [perl #68712].
3245
3246       ·   "sort" with a "($$)"-prototyped comparison routine used to cause
3247           the value of @_ to leak out of the sort.  Taking a reference to @_
3248           within the sorting routine could cause a crash [perl #72334].
3249
3250       ·   Match variables (like $1) no longer persist between calls to a sort
3251           subroutine [perl #76026].
3252
3253       ·   Iterating with "foreach" over an array returned by an lvalue sub
3254           now works [perl #23790].
3255
3256       ·   $@ is now localised during calls to "binmode" to prevent action at
3257           a distance [perl #78844].
3258
3259       ·   Calling a closure prototype (what is passed to an attribute handler
3260           for a closure) now results in a "Closure prototype called" error
3261           message instead of a crash [perl #68560].
3262
3263       ·   Mentioning a read-only lexical variable from the enclosing scope in
3264           a string "eval" no longer causes the variable to become writable
3265           [perl #19135].
3266
3267   Signals
3268       ·   Within signal handlers, $! is now implicitly localized.
3269
3270       ·   CHLD signals are no longer unblocked after a signal handler is
3271           called if they were blocked before by "POSIX::sigprocmask" [perl
3272           #82040].
3273
3274       ·   A signal handler called within a signal handler could cause leaks
3275           or double-frees.  Now fixed [perl #76248].
3276
3277   Miscellaneous Memory Leaks
3278       ·   Several memory leaks when loading XS modules were fixed (5.12.2).
3279
3280       ·   substr(), pos(), keys(), and vec() could, when used in combination
3281           with lvalues, result in leaking the scalar value they operate on,
3282           and cause its destruction to happen too late.  This has now been
3283           fixed.
3284
3285       ·   The postincrement and postdecrement operators, "++" and "--", used
3286           to cause leaks when used on references.  This has now been fixed.
3287
3288       ·   Nested "map" and "grep" blocks no longer leak memory when
3289           processing large lists [perl #48004].
3290
3291       ·   "use VERSION" and "no VERSION" no longer leak memory [perl #78436]
3292           [perl #69050].
3293
3294       ·   ".=" followed by "<>" or "readline" would leak memory if $/
3295           contained characters beyond the octet range and the scalar assigned
3296           to happened to be encoded as UTF8 internally [perl #72246].
3297
3298       ·   "eval 'BEGIN{die}'" no longer leaks memory on non-threaded builds.
3299
3300   Memory Corruption and Crashes
3301       ·   glob() no longer crashes when %File::Glob:: is empty and
3302           "CORE::GLOBAL::glob" isn't present [perl #75464] (5.12.2).
3303
3304       ·   readline() has been fixed when interrupted by signals so it no
3305           longer returns the "same thing" as before or random memory.
3306
3307       ·   When assigning a list with duplicated keys to a hash, the
3308           assignment used to return garbage and/or freed values:
3309
3310               @a = %h = (list with some duplicate keys);
3311
3312           This has now been fixed [perl #31865].
3313
3314       ·   The mechanism for freeing objects in globs used to leave dangling
3315           pointers to freed SVs, meaning Perl users could see corrupted state
3316           during destruction.
3317
3318           Perl now frees only the affected slots of the GV, rather than
3319           freeing the GV itself.  This makes sure that there are no dangling
3320           refs or corrupted state during destruction.
3321
3322       ·   The interpreter no longer crashes when freeing deeply-nested arrays
3323           of arrays.  Hashes have not been fixed yet [perl #44225].
3324
3325       ·   Concatenating long strings under "use encoding" no longer causes
3326           Perl to crash [perl #78674].
3327
3328       ·   Calling "->import" on a class lacking an import method could
3329           corrupt the stack, resulting in strange behaviour.  For instance,
3330
3331             push @a, "foo", $b = bar->import;
3332
3333           would assign "foo" to $b [perl #63790].
3334
3335       ·   The "recv" function could crash when called with the MSG_TRUNC flag
3336           [perl #75082].
3337
3338       ·   "formline" no longer crashes when passed a tainted format picture.
3339           It also taints $^A now if its arguments are tainted [perl #79138].
3340
3341       ·   A bug in how we process filetest operations could cause a segfault.
3342           Filetests don't always expect an op on the stack, so we now use
3343           TOPs only if we're sure that we're not "stat"ing the "_"
3344           filehandle.  This is indicated by "OPf_KIDS" (as checked in
3345           ck_ftst) [perl #74542] (5.12.1).
3346
3347       ·   unpack() now handles scalar context correctly for %32H and %32u,
3348           fixing a potential crash.  split() would crash because the third
3349           item on the stack wasn't the regular expression it expected.
3350           "unpack("%2H", ...)" would return both the unpacked result and the
3351           checksum on the stack, as would "unpack("%2u", ...)" [perl #73814]
3352           (5.12.2).
3353
3354   Fixes to Various Perl Operators
3355       ·   The "&", "|", and "^" bitwise operators no longer coerce read-only
3356           arguments [perl #20661].
3357
3358       ·   Stringifying a scalar containing "-0.0" no longer has the effect of
3359           turning false into true [perl #45133].
3360
3361       ·   Some numeric operators were converting integers to floating point,
3362           resulting in loss of precision on 64-bit platforms [perl #77456].
3363
3364       ·   sprintf() was ignoring locales when called with constant arguments
3365           [perl #78632].
3366
3367       ·   Combining the vector (%v) flag and dynamic precision would cause
3368           "sprintf" to confuse the order of its arguments, making it treat
3369           the string as the precision and vice-versa [perl #83194].
3370
3371   Bugs Relating to the C API
3372       ·   The C-level "lex_stuff_pvn" function would sometimes cause a
3373           spurious syntax error on the last line of the file if it lacked a
3374           final semicolon [perl #74006] (5.12.1).
3375
3376       ·   The "eval_sv" and "eval_pv" C functions now set $@ correctly when
3377           there is a syntax error and no "G_KEEPERR" flag, and never set it
3378           if the "G_KEEPERR" flag is present [perl #3719].
3379
3380       ·   The XS multicall API no longer causes subroutines to lose reference
3381           counts if called via the multicall interface from within those very
3382           subroutines.  This affects modules like List::Util.  Calling one of
3383           its functions with an active subroutine as the first argument could
3384           cause a crash [perl #78070].
3385
3386       ·   The "SvPVbyte" function available to XS modules now calls magic
3387           before downgrading the SV, to avoid warnings about wide characters
3388           [perl #72398].
3389
3390       ·   The ref types in the typemap for XS bindings now support magical
3391           variables [perl #72684].
3392
3393       ·   "sv_catsv_flags" no longer calls "mg_get" on its second argument
3394           (the source string) if the flags passed to it do not include
3395           SV_GMAGIC.  So it now matches the documentation.
3396
3397       ·   "my_strftime" no longer leaks memory.  This fixes a memory leak in
3398           "POSIX::strftime" [perl #73520].
3399
3400       ·   XSUB.h now correctly redefines fgets under PERL_IMPLICIT_SYS [perl
3401           #55049] (5.12.1).
3402
3403       ·   XS code using fputc() or fputs() on Windows could cause an error
3404           due to their arguments being swapped [perl #72704] (5.12.1).
3405
3406       ·   A possible segfault in the "T_PTROBJ" default typemap has been
3407           fixed (5.12.2).
3408
3409       ·   A bug that could cause "Unknown error" messages when "call_sv(code,
3410           G_EVAL)" is called from an XS destructor has been fixed (5.12.2).
3411

Known Problems

3413       This is a list of significant unresolved issues which are regressions
3414       from earlier versions of Perl or which affect widely-used CPAN modules.
3415
3416       ·   "List::Util::first" misbehaves in the presence of a lexical $_
3417           (typically introduced by "my $_" or implicitly by "given").  The
3418           variable that gets set for each iteration is the package variable
3419           $_, not the lexical $_.
3420
3421           A similar issue may occur in other modules that provide functions
3422           which take a block as their first argument, like
3423
3424               foo { ... $_ ...} list
3425
3426           See also: <http://rt.perl.org/rt3/Public/Bug/Display.html?id=67694>
3427
3428       ·   readline() returns an empty string instead of a cached previous
3429           value when it is interrupted by a signal
3430
3431       ·   The changes in prototype handling break Switch.  A patch has been
3432           sent upstream and will hopefully appear on CPAN soon.
3433
3434       ·   The upgrade to ExtUtils-MakeMaker-6.57_05 has caused some tests in
3435           the Module-Install distribution on CPAN to fail. (Specifically,
3436           02_mymeta.t tests 5 and 21; 18_all_from.t tests 6 and 15;
3437           19_authors.t tests 5, 13, 21, and 29; and
3438           20_authors_with_special_characters.t tests 6, 15, and 23 in version
3439           1.00 of that distribution now fail.)
3440
3441       ·   On VMS, "Time::HiRes" tests will fail due to a bug in the CRTL's
3442           implementation of "setitimer": previous timer values would be
3443           cleared if a timer expired but not if the timer was reset before
3444           expiring.  HP OpenVMS Engineering have corrected the problem and
3445           will release a patch in due course (Quix case # QXCM1001115136).
3446
3447       ·   On VMS, there were a handful of "Module::Build" test failures we
3448           didn't get to before the release; please watch CPAN for updates.
3449

Errata

3451   keys(), values(), and each() work on arrays
3452       You can now use the keys(), values(), and each() builtins on arrays;
3453       previously you could use them only on hashes.  See perlfunc for
3454       details.  This is actually a change introduced in perl 5.12.0, but it
3455       was missed from that release's perl5120delta.
3456
3457   split() and @_
3458       split() no longer modifies @_ when called in scalar or void context.
3459       In void context it now produces a "Useless use of split" warning.  This
3460       was also a perl 5.12.0 change that missed the perldelta.
3461

Obituary

3463       Randy Kobes, creator of http://kobesearch.cpan.org/ and
3464       contributor/maintainer to several core Perl toolchain modules, passed
3465       away on September 18, 2010 after a battle with lung cancer.  The
3466       community was richer for his involvement.  He will be missed.
3467

Acknowledgements

3469       Perl 5.14.0 represents one year of development since Perl 5.12.0 and
3470       contains nearly 550,000 lines of changes across nearly 3,000 files from
3471       150 authors and committers.
3472
3473       Perl continues to flourish into its third decade thanks to a vibrant
3474       community of users and developers.  The following people are known to
3475       have contributed the improvements that became Perl 5.14.0:
3476
3477       Aaron Crane, Abhijit Menon-Sen, Abigail, var Arnfjoerd` Bjarmason,
3478       Alastair Douglas, Alexander Alekseev, Alexander Hartmaier, Alexandr
3479       Ciornii, Alex Davies, Alex Vandiver, Ali Polatel, Allen Smith, Andreas
3480       Koenig, Andrew Rodland, Andy Armstrong, Andy Dougherty, Aristotle
3481       Pagaltzis, Arkturuz, Arvan, A. Sinan Unur, Ben Morrow, Bo Lindbergh,
3482       Boris Ratner, Brad Gilbert, Bram, brian d foy, Brian Phillips, Casey
3483       West, Charles Bailey, Chas. Owens, Chip Salzenberg, Chris 'BinGOs'
3484       Williams, chromatic, Craig A. Berry, Curtis Jewell, Dagfinn Ilmari
3485       Mannsaaker, Dan Dascalescu, Dave Rolsky, David Caldwell, David
3486       Cantrell, David Golden, David Leadbeater, David Mitchell, David
3487       Wheeler, Eric Brine, Father Chrysostomos, Fingle Nark, Florian Ragwitz,
3488       Frank Wiegand, Franz Fasching, Gene Sullivan, George Greer, Gerard
3489       Goossen, Gisle Aas, Goro Fuji, Grant McLean, gregor herrmann, H.Merijn
3490       Brand, Hongwen Qiu, Hugo van der Sanden, Ian Goodacre, James E Keenan,
3491       James Mastros, Jan Dubois, Jay Hannah, Jerry D. Hedden, Jesse Vincent,
3492       Jim Cromie, Jirka HruXka, John Peacock, Joshua ben Jore, Joshua
3493       Pritikin, Karl Williamson, Kevin Ryde, kmx, Lars DXXXXXX XXX, Larwan
3494       Berke, Leon Brocard, Leon Timmermans, Lubomir Rintel, Lukas Mai, Maik
3495       Hentsche, Marty Pauley, Marvin Humphrey, Matt Johnson, Matt S Trout,
3496       Max Maischein, Michael Breen, Michael Fig, Michael G Schwern, Michael
3497       Parker, Michael Stevens, Michael Witten, Mike Kelly, Moritz Lenz,
3498       Nicholas Clark, Nick Cleaton, Nick Johnston, Nicolas Kaiser, Niko Tyni,
3499       Noirin Shirley, Nuno Carvalho, Paul Evans, Paul Green, Paul Johnson,
3500       Paul Marquess, Peter J. Holzer, Peter John Acklam, Peter Martini,
3501       Philippe Bruhat (BooK), Piotr Fusik, Rafael Garcia-Suarez, Rainer
3502       Tammer, Reini Urban, Renee Baecker, Ricardo Signes, Richard Moehn,
3503       Richard Soderberg, Rob Hoelz, Robin Barker, Ruslan Zakirov, Salvador
3504       Fandin~o, Salvador Ortiz Garcia, Shlomi Fish, Sinan Unur, Sisyphus,
3505       Slaven Rezic, Steffen Mueller, Steve Hay, Steven Schubiger, Steve
3506       Peters, Sullivan Beck, Tatsuhiko Miyagawa, Tim Bunce, Todd Rinaldo, Tom
3507       Christiansen, Tom Hukins, Tony Cook, Tye McQueen, Vadim Konovalov,
3508       Vernon Lyon, Vincent Pit, Walt Mankowski, Wolfram Humann, Yves Orton,
3509       Zefram, and Zsban Ambrus.
3510
3511       This is woefully incomplete as it's automatically generated from
3512       version control history.  In particular, it doesn't include the names
3513       of the (very much appreciated) contributors who reported issues in
3514       previous versions of Perl that helped make Perl 5.14.0 better. For a
3515       more complete list of all of Perl's historical contributors, please see
3516       the "AUTHORS" file in the Perl 5.14.0 distribution.
3517
3518       Many of the changes included in this version originated in the CPAN
3519       modules included in Perl's core. We're grateful to the entire CPAN
3520       community for helping Perl to flourish.
3521

Reporting Bugs

3523       If you find what you think is a bug, you might check the articles
3524       recently posted to the comp.lang.perl.misc newsgroup and the Perl bug
3525       database at http://rt.perl.org/perlbug/ .  There may also be
3526       information at http://www.perl.org/ , the Perl Home Page.
3527
3528       If you believe you have an unreported bug, please run the perlbug
3529       program included with your release.  Be sure to trim your bug down to a
3530       tiny but sufficient test case.  Your bug report, along with the output
3531       of "perl -V", will be sent off to perlbug@perl.org to be analysed by
3532       the Perl porting team.
3533
3534       If the bug you are reporting has security implications, which make it
3535       inappropriate to send to a publicly archived mailing list, then please
3536       send it to perl5-security-report@perl.org.  This points to a closed
3537       subscription unarchived mailing list, which includes all the core
3538       committers, who are able to help assess the impact of issues, figure
3539       out a resolution, and help co-ordinate the release of patches to
3540       mitigate or fix the problem across all platforms on which Perl is
3541       supported.  Please use this address for security issues in the Perl
3542       core only, not for modules independently distributed on CPAN.
3543

SEE ALSO

3545       The Changes file for an explanation of how to view exhaustive details
3546       on what changed.
3547
3548       The INSTALL file for how to build Perl.
3549
3550       The README file for general stuff.
3551
3552       The Artistic and Copying files for copyright information.
3553
3554
3555
3556perl v5.16.3                      2013-03-04                  PERL5140DELTA(1)
Impressum