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

NAME

6       perl5160delta - what is new for perl v5.16.0
7

DESCRIPTION

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

Notice

19       With the release of Perl 5.16.0, the 5.12.x series of releases is now
20       out of its support period.  There may be future 5.12.x releases, but
21       only in the event of a critical security issue.  Users of Perl 5.12 or
22       earlier should consider upgrading to a more recent release of Perl.
23
24       This policy is described in greater detail in perlpolicy.
25

Core Enhancements

27   "use VERSION"
28       As of this release, version declarations like "use v5.16" now disable
29       all features before enabling the new feature bundle.  This means that
30       the following holds true:
31
32           use 5.016;
33           # only 5.16 features enabled here
34           use 5.014;
35           # only 5.14 features enabled here (not 5.16)
36
37       "use v5.12" and higher continue to enable strict, but explicit "use
38       strict" and "no strict" now override the version declaration, even when
39       they come first:
40
41           no strict;
42           use 5.012;
43           # no strict here
44
45       There is a new ":default" feature bundle that represents the set of
46       features enabled before any version declaration or "use feature" has
47       been seen.  Version declarations below 5.10 now enable the ":default"
48       feature set.  This does not actually change the behavior of "use v5.8",
49       because features added to the ":default" set are those that were
50       traditionally enabled by default, before they could be turned off.
51
52       "no feature" now resets to the default feature set.  To disable all
53       features (which is likely to be a pretty special-purpose request, since
54       it presumably won't match any named set of semantics) you can now write
55       "no feature ':all'".
56
57       $[ is now disabled under "use v5.16".  It is part of the default
58       feature set and can be turned on or off explicitly with "use feature
59       'array_base'".
60
61   "__SUB__"
62       The new "__SUB__" token, available under the "current_sub" feature (see
63       feature) or "use v5.16", returns a reference to the current subroutine,
64       making it easier to write recursive closures.
65
66   New and Improved Built-ins
67       More consistent "eval"
68
69       The "eval" operator sometimes treats a string argument as a sequence of
70       characters and sometimes as a sequence of bytes, depending on the
71       internal encoding.  The internal encoding is not supposed to make any
72       difference, but there is code that relies on this inconsistency.
73
74       The new "unicode_eval" and "evalbytes" features (enabled under "use
75       5.16.0") resolve this.  The "unicode_eval" feature causes "eval
76       $string" to treat the string always as Unicode.  The "evalbytes"
77       features provides a function, itself called "evalbytes", which
78       evaluates its argument always as a string of bytes.
79
80       These features also fix oddities with source filters leaking to outer
81       dynamic scopes.
82
83       See feature for more detail.
84
85       "substr" lvalue revamp
86
87       When "substr" is called in lvalue or potential lvalue context with two
88       or three arguments, a special lvalue scalar is returned that modifies
89       the original string (the first argument) when assigned to.
90
91       Previously, the offsets (the second and third arguments) passed to
92       "substr" would be converted immediately to match the string, negative
93       offsets being translated to positive and offsets beyond the end of the
94       string being truncated.
95
96       Now, the offsets are recorded without modification in the special
97       lvalue scalar that is returned, and the original string is not even
98       looked at by "substr" itself, but only when the returned lvalue is read
99       or modified.
100
101       These changes result in an incompatible change:
102
103       If the original string changes length after the call to "substr" but
104       before assignment to its return value, negative offsets will remember
105       their position from the end of the string, affecting code like this:
106
107           my $string = "string";
108           my $lvalue = \substr $string, -4, 2;
109           print $$lvalue, "\n"; # prints "ri"
110           $string = "bailing twine";
111           print $$lvalue, "\n"; # prints "wi"; used to print "il"
112
113       The same thing happens with an omitted third argument.  The returned
114       lvalue will always extend to the end of the string, even if the string
115       becomes longer.
116
117       Since this change also allowed many bugs to be fixed (see "The "substr"
118       operator"), and since the behavior of negative offsets has never been
119       specified, the change was deemed acceptable.
120
121       Return value of "tied"
122
123       The value returned by "tied" on a tied variable is now the actual
124       scalar that holds the object to which the variable is tied.  This lets
125       ties be weakened with "Scalar::Util::weaken(tied $tied_variable)".
126
127   Unicode Support
128       Supports (almost) Unicode 6.1
129
130       Besides the addition of whole new scripts, and new characters in
131       existing scripts, this new version of Unicode, as always, makes some
132       changes to existing characters.  One change that may trip up some
133       applications is that the General Category of two characters in the
134       Latin-1 range, PILCROW SIGN and SECTION SIGN, has been changed from
135       Other_Symbol to Other_Punctuation.  The same change has been made for a
136       character in each of Tibetan, Ethiopic, and Aegean.  The code points
137       U+3248..U+324F (CIRCLED NUMBER TEN ON BLACK SQUARE through CIRCLED
138       NUMBER EIGHTY ON BLACK SQUARE) have had their General Category changed
139       from Other_Symbol to Other_Numeric.  The Line Break property has
140       changes for Hebrew and Japanese; and because of other changes in 6.1,
141       the Perl regular expression construct "\X" now works differently for
142       some characters in Thai and Lao.
143
144       New aliases (synonyms) have been defined for many property values;
145       these, along with the previously existing ones, are all cross-indexed
146       in perluniprops.
147
148       The return value of "charnames::viacode()" is affected by other
149       changes:
150
151        Code point      Old Name             New Name
152          U+000A    LINE FEED (LF)        LINE FEED
153          U+000C    FORM FEED (FF)        FORM FEED
154          U+000D    CARRIAGE RETURN (CR)  CARRIAGE RETURN
155          U+0085    NEXT LINE (NEL)       NEXT LINE
156          U+008E    SINGLE-SHIFT 2        SINGLE-SHIFT-2
157          U+008F    SINGLE-SHIFT 3        SINGLE-SHIFT-3
158          U+0091    PRIVATE USE 1         PRIVATE USE-1
159          U+0092    PRIVATE USE 2         PRIVATE USE-2
160          U+2118    SCRIPT CAPITAL P      WEIERSTRASS ELLIPTIC FUNCTION
161
162       Perl will accept any of these names as input, but
163       "charnames::viacode()" now returns the new name of each pair.  The
164       change for U+2118 is considered by Unicode to be a correction, that is
165       the original name was a mistake (but again, it will remain forever
166       valid to use it to refer to U+2118).  But most of these changes are the
167       fallout of the mistake Unicode 6.0 made in naming a character used in
168       Japanese cell phones to be "BELL", which conflicts with the
169       longstanding industry use of (and Unicode's recommendation to use) that
170       name to mean the ASCII control character at U+0007.  Therefore, that
171       name has been deprecated in Perl since v5.14, and any use of it will
172       raise a warning message (unless turned off).  The name "ALERT" is now
173       the preferred name for this code point, with "BEL" an acceptable short
174       form.  The name for the new cell phone character, at code point
175       U+1F514, remains undefined in this version of Perl (hence we don't
176       implement quite all of Unicode 6.1), but starting in v5.18, BELL will
177       mean this character, and not U+0007.
178
179       Unicode has taken steps to make sure that this sort of mistake does not
180       happen again.  The Standard now includes all generally accepted names
181       and abbreviations for control characters, whereas previously it didn't
182       (though there were recommended names for most of them, which Perl
183       used).  This means that most of those recommended names are now
184       officially in the Standard.  Unicode did not recommend names for the
185       four code points listed above between U+008E and U+008F, and in
186       standardizing them Unicode subtly changed the names that Perl had
187       previously given them, by replacing the final blank in each name by a
188       hyphen.  Unicode also officially accepts names that Perl had
189       deprecated, such as FILE SEPARATOR.  Now the only deprecated name is
190       BELL.  Finally, Perl now uses the new official names instead of the old
191       (now considered obsolete) names for the first four code points in the
192       list above (the ones which have the parentheses in them).
193
194       Now that the names have been placed in the Unicode standard, these
195       kinds of changes should not happen again, though corrections, such as
196       to U+2118, are still possible.
197
198       Unicode also added some name abbreviations, which Perl now accepts: SP
199       for SPACE; TAB for CHARACTER TABULATION; NEW LINE, END OF LINE, NL, and
200       EOL for LINE FEED; LOCKING-SHIFT ONE for SHIFT OUT; LOCKING-SHIFT ZERO
201       for SHIFT IN; and ZWNBSP for ZERO WIDTH NO-BREAK SPACE.
202
203       More details on this version of Unicode are provided in
204       <http://www.unicode.org/versions/Unicode6.1.0/>.
205
206       "use charnames" is no longer needed for "\N{name}"
207
208       When "\N{name}" is encountered, the "charnames" module is now
209       automatically loaded when needed as if the ":full" and ":short" options
210       had been specified.  See charnames for more information.
211
212       "\N{...}" can now have Unicode loose name matching
213
214       This is described in the "charnames" item in "Updated Modules and
215       Pragmata" below.
216
217       Unicode Symbol Names
218
219       Perl now has proper support for Unicode in symbol names.  It used to be
220       that "*{$foo}" would ignore the internal UTF8 flag and use the bytes of
221       the underlying representation to look up the symbol.  That meant that
222       "*{"\x{100}"}" and "*{"\xc4\x80"}" would return the same thing.  All
223       these parts of Perl have been fixed to account for Unicode:
224
225       ·   Method names (including those passed to "use overload")
226
227       ·   Typeglob names (including names of variables, subroutines, and
228           filehandles)
229
230       ·   Package names
231
232       ·   "goto"
233
234       ·   Symbolic dereferencing
235
236       ·   Second argument to "bless()" and "tie()"
237
238       ·   Return value of "ref()"
239
240       ·   Subroutine prototypes
241
242       ·   Attributes
243
244       ·   Various warnings and error messages that mention variable names or
245           values, methods, etc.
246
247       In addition, a parsing bug has been fixed that prevented "*{e}" from
248       implicitly quoting the name, but instead interpreted it as "*{+e}",
249       which would cause a strict violation.
250
251       "*{"*a::b"}" automatically strips off the * if it is followed by an
252       ASCII letter.  That has been extended to all Unicode identifier
253       characters.
254
255       One-character non-ASCII non-punctuation variables (like "$e") are now
256       subject to "Used only once" warnings.  They used to be exempt, as they
257       were treated as punctuation variables.
258
259       Also, single-character Unicode punctuation variables (like $X) are now
260       supported [perl #69032].
261
262       Improved ability to mix locales and Unicode, including UTF-8 locales
263
264       An optional parameter has been added to "use locale"
265
266        use locale ':not_characters';
267
268       which tells Perl to use all but the "LC_CTYPE" and "LC_COLLATE"
269       portions of the current locale.  Instead, the character set is assumed
270       to be Unicode.  This lets locales and Unicode be seamlessly mixed,
271       including the increasingly frequent UTF-8 locales.  When using this
272       hybrid form of locales, the ":locale" layer to the open pragma can be
273       used to interface with the file system, and there are CPAN modules
274       available for ARGV and environment variable conversions.
275
276       Full details are in perllocale.
277
278       New function "fc" and corresponding escape sequence "\F" for Unicode
279       foldcase
280
281       Unicode foldcase is an extension to lowercase that gives better results
282       when comparing two strings case-insensitively.  It has long been used
283       internally in regular expression "/i" matching.  Now it is available
284       explicitly through the new "fc" function call (enabled by
285       "use feature 'fc'", or "use v5.16", or explicitly callable via
286       "CORE::fc") or through the new "\F" sequence in double-quotish strings.
287
288       Full details are in "fc" in perlfunc.
289
290       The Unicode "Script_Extensions" property is now supported.
291
292       New in Unicode 6.0, this is an improved "Script" property.  Details are
293       in "Scripts" in perlunicode.
294
295   XS Changes
296       Improved typemaps for Some Builtin Types
297
298       Most XS authors will know there is a longstanding bug in the OUTPUT
299       typemap for T_AVREF ("AV*"), T_HVREF ("HV*"), T_CVREF ("CV*"), and
300       T_SVREF ("SVREF" or "\$foo") that requires manually decrementing the
301       reference count of the return value instead of the typemap taking care
302       of this.  For backwards-compatibility, this cannot be changed in the
303       default typemaps.  But we now provide additional typemaps
304       "T_AVREF_REFCOUNT_FIXED", etc. that do not exhibit this bug.  Using
305       them in your extension is as simple as having one line in your
306       "TYPEMAP" section:
307
308         HV*   T_HVREF_REFCOUNT_FIXED
309
310       "is_utf8_char()"
311
312       The XS-callable function "is_utf8_char()", when presented with
313       malformed UTF-8 input, can read up to 12 bytes beyond the end of the
314       string.  This cannot be fixed without changing its API, and so its use
315       is now deprecated.  Use "is_utf8_char_buf()" (described just below)
316       instead.
317
318       Added "is_utf8_char_buf()"
319
320       This function is designed to replace the deprecated "is_utf8_char()"
321       function.  It includes an extra parameter to make sure it doesn't read
322       past the end of the input buffer.
323
324       Other "is_utf8_foo()" functions, as well as "utf8_to_foo()", etc.
325
326       Most other XS-callable functions that take UTF-8 encoded input
327       implicitly assume that the UTF-8 is valid (not malformed) with respect
328       to buffer length.  Do not do things such as change a character's case
329       or see if it is alphanumeric without first being sure that it is valid
330       UTF-8.  This can be safely done for a whole string by using one of the
331       functions "is_utf8_string()", "is_utf8_string_loc()", and
332       "is_utf8_string_loclen()".
333
334       New Pad API
335
336       Many new functions have been added to the API for manipulating lexical
337       pads.  See "Pad Data Structures" in perlapi for more information.
338
339   Changes to Special Variables
340       $$ can be assigned to
341
342       $$ was made read-only in Perl 5.8.0.  But only sometimes: "local $$"
343       would make it writable again.  Some CPAN modules were using "local $$"
344       or XS code to bypass the read-only check, so there is no reason to keep
345       $$ read-only.  (This change also allowed a bug to be fixed while
346       maintaining backward compatibility.)
347
348       $^X converted to an absolute path on FreeBSD, OS X and Solaris
349
350       $^X is now converted to an absolute path on OS X, FreeBSD (without
351       needing /proc mounted) and Solaris 10 and 11.  This augments the
352       previous approach of using /proc on Linux, FreeBSD, and NetBSD (in all
353       cases, where mounted).
354
355       This makes relocatable perl installations more useful on these
356       platforms.  (See "Relocatable @INC" in INSTALL)
357
358   Debugger Changes
359       Features inside the debugger
360
361       The current Perl's feature bundle is now enabled for commands entered
362       in the interactive debugger.
363
364       New option for the debugger's t command
365
366       The t command in the debugger, which toggles tracing mode, now accepts
367       a numeric argument that determines how many levels of subroutine calls
368       to trace.
369
370       "enable" and "disable"
371
372       The debugger now has "disable" and "enable" commands for disabling
373       existing breakpoints and re-enabling them.  See perldebug.
374
375       Breakpoints with file names
376
377       The debugger's "b" command for setting breakpoints now lets a line
378       number be prefixed with a file name.  See "b [file]:[line] [condition]"
379       in perldebug.
380
381   The "CORE" Namespace
382       The "CORE::" prefix
383
384       The "CORE::" prefix can now be used on keywords enabled by feature.pm,
385       even outside the scope of "use feature".
386
387       Subroutines in the "CORE" namespace
388
389       Many Perl keywords are now available as subroutines in the CORE
390       namespace.  This lets them be aliased:
391
392           BEGIN { *entangle = \&CORE::tie }
393           entangle $variable, $package, @args;
394
395       And for prototypes to be bypassed:
396
397           sub mytie(\[%$*@]$@) {
398               my ($ref, $pack, @args) = @_;
399               ... do something ...
400               goto &CORE::tie;
401           }
402
403       Some of these cannot be called through references or via &foo syntax,
404       but must be called as barewords.
405
406       See CORE for details.
407
408   Other Changes
409       Anonymous handles
410
411       Automatically generated file handles are now named __ANONIO__ when the
412       variable name cannot be determined, rather than $__ANONIO__.
413
414       Autoloaded sort Subroutines
415
416       Custom sort subroutines can now be autoloaded [perl #30661]:
417
418           sub AUTOLOAD { ... }
419           @sorted = sort foo @list; # uses AUTOLOAD
420
421       "continue" no longer requires the "switch" feature
422
423       The "continue" keyword has two meanings.  It can introduce a "continue"
424       block after a loop, or it can exit the current "when" block.  Up to
425       now, the latter meaning was valid only with the "switch" feature
426       enabled, and was a syntax error otherwise.  Since the main purpose of
427       feature.pm is to avoid conflicts with user-defined subroutines, there
428       is no reason for "continue" to depend on it.
429
430       DTrace probes for interpreter phase change
431
432       The "phase-change" probes will fire when the interpreter's phase
433       changes, which tracks the "${^GLOBAL_PHASE}" variable.  "arg0" is the
434       new phase name; "arg1" is the old one.  This is useful for limiting
435       your instrumentation to one or more of: compile time, run time, or
436       destruct time.
437
438       "__FILE__()" Syntax
439
440       The "__FILE__", "__LINE__" and "__PACKAGE__" tokens can now be written
441       with an empty pair of parentheses after them.  This makes them parse
442       the same way as "time", "fork" and other built-in functions.
443
444       The "\$" prototype accepts any scalar lvalue
445
446       The "\$" and "\[$]" subroutine prototypes now accept any scalar lvalue
447       argument.  Previously they accepted only scalars beginning with "$" and
448       hash and array elements.  This change makes them consistent with the
449       way the built-in "read" and "recv" functions (among others) parse their
450       arguments.  This means that one can override the built-in functions
451       with custom subroutines that parse their arguments the same way.
452
453       "_" in subroutine prototypes
454
455       The "_" character in subroutine prototypes is now allowed before "@" or
456       "%".
457

Security

459   Use "is_utf8_char_buf()" and not "is_utf8_char()"
460       The latter function is now deprecated because its API is insufficient
461       to guarantee that it doesn't read (up to 12 bytes in the worst case)
462       beyond the end of its input string.  See is_utf8_char_buf().
463
464   Malformed UTF-8 input could cause attempts to read beyond the end of the
465       buffer
466       Two new XS-accessible functions, "utf8_to_uvchr_buf()" and
467       "utf8_to_uvuni_buf()" are now available to prevent this, and the Perl
468       core has been converted to use them.  See "Internal Changes".
469
470   "File::Glob::bsd_glob()" memory error with GLOB_ALTDIRFUNC (CVE-2011-2728).
471       Calling "File::Glob::bsd_glob" with the unsupported flag
472       GLOB_ALTDIRFUNC would cause an access violation / segfault.  A Perl
473       program that accepts a flags value from an external source could expose
474       itself to denial of service or arbitrary code execution attacks.  There
475       are no known exploits in the wild.  The problem has been corrected by
476       explicitly disabling all unsupported flags and setting unused function
477       pointers to null.  Bug reported by Clement Lecigne. (5.14.2)
478
479   Privileges are now set correctly when assigning to $(
480       A hypothetical bug (probably unexploitable in practice) because the
481       incorrect setting of the effective group ID while setting $( has been
482       fixed.  The bug would have affected only systems that have
483       "setresgid()" but not "setregid()", but no such systems are known to
484       exist.
485

Deprecations

487   Don't read the Unicode data base files in lib/unicore
488       It is now deprecated to directly read the Unicode data base files.
489       These are stored in the lib/unicore directory.  Instead, you should use
490       the new functions in Unicode::UCD.  These provide a stable API, and
491       give complete information.
492
493       Perl may at some point in the future change or remove these files.  The
494       file which applications were most likely to have used is
495       lib/unicore/ToDigit.pl.  "prop_invmap()" in Unicode::UCD can be used to
496       get at its data instead.
497
498   XS functions "is_utf8_char()", "utf8_to_uvchr()" and "utf8_to_uvuni()"
499       This function is deprecated because it could read beyond the end of the
500       input string.  Use the new is_utf8_char_buf(), "utf8_to_uvchr_buf()"
501       and "utf8_to_uvuni_buf()" instead.
502

Future Deprecations

504       This section serves as a notice of features that are likely to be
505       removed or deprecated in the next release of perl (5.18.0).  If your
506       code depends on these features, you should contact the Perl 5 Porters
507       via the mailing list <http://lists.perl.org/list/perl5-porters.html> or
508       perlbug to explain your use case and inform the deprecation process.
509
510   Core Modules
511       These modules may be marked as deprecated from the core.  This only
512       means that they will no longer be installed by default with the core
513       distribution, but will remain available on the CPAN.
514
515       ·   CPANPLUS
516
517       ·   Filter::Simple
518
519       ·   PerlIO::mmap
520
521       ·   Pod::LaTeX
522
523       ·   Pod::Parser
524
525       ·   SelfLoader
526
527       ·   Text::Soundex
528
529       ·   Thread.pm
530
531   Platforms with no supporting programmers
532       These platforms will probably have their special build support removed
533       during the 5.17.0 development series.
534
535       ·   BeOS
536
537       ·   djgpp
538
539       ·   dgux
540
541       ·   EPOC
542
543       ·   MPE/iX
544
545       ·   Rhapsody
546
547       ·   UTS
548
549       ·   VM/ESA
550
551   Other Future Deprecations
552       ·   Swapping of $< and $>
553
554           For more information about this future deprecation, see the
555           relevant RT ticket
556           <https://rt.perl.org/rt3/Ticket/Display.html?id=96212>.
557
558       ·   sfio, stdio
559
560           Perl supports being built without PerlIO proper, using a stdio or
561           sfio wrapper instead.  A perl build like this will not support IO
562           layers and thus Unicode IO, making it rather handicapped.
563
564           PerlIO supports a "stdio" layer if stdio use is desired, and
565           similarly a sfio layer could be produced.
566
567       ·   Unescaped literal "{" in regular expressions.
568
569           Starting with v5.20, it is planned to require a literal "{" to be
570           escaped, for example by preceding it with a backslash.  In v5.18, a
571           deprecated warning message will be emitted for all such uses.  This
572           affects only patterns that are to match a literal "{".  Other uses
573           of this character, such as part of a quantifier or sequence as in
574           those below, are completely unaffected:
575
576               /foo{3,5}/
577               /\p{Alphabetic}/
578               /\N{DIGIT ZERO}
579
580           Removing this will permit extensions to Perl's pattern syntax and
581           better error checking for existing syntax.  See "Quantifiers" in
582           perlre for an example.
583
584       ·   Revamping "\Q" semantics in double-quotish strings when combined
585           with other escapes.
586
587           There are several bugs and inconsistencies involving combinations
588           of "\Q" and escapes like "\x", "\L", etc., within a "\Q...\E" pair.
589           These need to be fixed, and doing so will necessarily change
590           current behavior.  The changes have not yet been settled.
591

Incompatible Changes

593   Special blocks called in void context
594       Special blocks ("BEGIN", "CHECK", "INIT", "UNITCHECK", "END") are now
595       called in void context.  This avoids wasteful copying of the result of
596       the last statement [perl #108794].
597
598   The "overloading" pragma and regexp objects
599       With "no overloading", regular expression objects returned by "qr//"
600       are now stringified as "Regexp=REGEXP(0xbe600d)" instead of the regular
601       expression itself [perl #108780].
602
603   Two XS typemap Entries removed
604       Two presumably unused XS typemap entries have been removed from the
605       core typemap: T_DATAUNIT and T_CALLBACK.  If you are, against all odds,
606       a user of these, please see the instructions on how to restore them in
607       perlxstypemap.
608
609   Unicode 6.1 has incompatibilities with Unicode 6.0
610       These are detailed in "Supports (almost) Unicode 6.1" above.  You can
611       compile this version of Perl to use Unicode 6.0.  See "Hacking Perl to
612       work on earlier Unicode versions (for very serious hackers only)" in
613       perlunicode.
614
615   Borland compiler
616       All support for the Borland compiler has been dropped.  The code had
617       not worked for a long time anyway.
618
619   Certain deprecated Unicode properties are no longer supported by default
620       Perl should never have exposed certain Unicode properties that are used
621       by Unicode internally and not meant to be publicly available.  Use of
622       these has generated deprecated warning messages since Perl 5.12.  The
623       removed properties are Other_Alphabetic,
624       Other_Default_Ignorable_Code_Point, Other_Grapheme_Extend,
625       Other_ID_Continue, Other_ID_Start, Other_Lowercase, Other_Math, and
626       Other_Uppercase.
627
628       Perl may be recompiled to include any or all of them; instructions are
629       given in "Unicode character properties that are NOT accepted by Perl"
630       in perluniprops.
631
632   Dereferencing IO thingies as typeglobs
633       The "*{...}" operator, when passed a reference to an IO thingy (as in
634       "*{*STDIN{IO}}"), creates a new typeglob containing just that IO
635       object.  Previously, it would stringify as an empty string, but some
636       operators would treat it as undefined, producing an "uninitialized"
637       warning.  Now it stringifies as __ANONIO__ [perl #96326].
638
639   User-defined case-changing operations
640       This feature was deprecated in Perl 5.14, and has now been removed.
641       The CPAN module Unicode::Casing provides better functionality without
642       the drawbacks that this feature had, as are detailed in the 5.14
643       documentation:
644       <http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
645
646   XSUBs are now 'static'
647       XSUB C functions are now 'static', that is, they are not visible from
648       outside the compilation unit.  Users can use the new
649       "XS_EXTERNAL(name)" and "XS_INTERNAL(name)" macros to pick the desired
650       linking behavior.  The ordinary "XS(name)" declaration for XSUBs will
651       continue to declare non-'static' XSUBs for compatibility, but the XS
652       compiler, ExtUtils::ParseXS ("xsubpp") will emit 'static' XSUBs by
653       default.  ExtUtils::ParseXS's behavior can be reconfigured from XS
654       using the "EXPORT_XSUB_SYMBOLS" keyword.  See perlxs for details.
655
656   Weakening read-only references
657       Weakening read-only references is no longer permitted.  It should never
658       have worked anyway, and could sometimes result in crashes.
659
660   Tying scalars that hold typeglobs
661       Attempting to tie a scalar after a typeglob was assigned to it would
662       instead tie the handle in the typeglob's IO slot.  This meant that it
663       was impossible to tie the scalar itself.  Similar problems affected
664       "tied" and "untie": "tied $scalar" would return false on a tied scalar
665       if the last thing returned was a typeglob, and "untie $scalar" on such
666       a tied scalar would do nothing.
667
668       We fixed this problem before Perl 5.14.0, but it caused problems with
669       some CPAN modules, so we put in a deprecation cycle instead.
670
671       Now the deprecation has been removed and this bug has been fixed.  So
672       "tie $scalar" will always tie the scalar, not the handle it holds.  To
673       tie the handle, use "tie *$scalar" (with an explicit asterisk).  The
674       same applies to "tied *$scalar" and "untie *$scalar".
675
676   IPC::Open3 no longer provides "xfork()", "xclose_on_exec()" and
677       "xpipe_anon()"
678       All three functions were private, undocumented, and unexported.  They
679       do not appear to be used by any code on CPAN.  Two have been inlined
680       and one deleted entirely.
681
682   $$ no longer caches PID
683       Previously, if one called fork(3) from C, Perl's notion of $$ could go
684       out of sync with what getpid() returns.  By always fetching the value
685       of $$ via getpid(), this potential bug is eliminated.  Code that
686       depends on the caching behavior will break.  As described in Core
687       Enhancements, $$ is now writable, but it will be reset during a fork.
688
689   $$ and "getppid()" no longer emulate POSIX semantics under LinuxThreads
690       The POSIX emulation of $$ and "getppid()" under the obsolete
691       LinuxThreads implementation has been removed.  This only impacts users
692       of Linux 2.4 and users of Debian GNU/kFreeBSD up to and including 6.0,
693       not the vast majority of Linux installations that use NPTL threads.
694
695       This means that "getppid()", like $$, is now always guaranteed to
696       return the OS's idea of the current state of the process, not perl's
697       cached version of it.
698
699       See the documentation for $$ for details.
700
701   $<, $>, $( and $) are no longer cached
702       Similarly to the changes to $$ and "getppid()", the internal caching of
703       $<, $>, $( and $) has been removed.
704
705       When we cached these values our idea of what they were would drift out
706       of sync with reality if someone (e.g., someone embedding perl) called
707       "sete?[ug]id()" without updating "PL_e?[ug]id".  Having to deal with
708       this complexity wasn't worth it given how cheap the "gete?[ug]id()"
709       system call is.
710
711       This change will break a handful of CPAN modules that use the XS-level
712       "PL_uid", "PL_gid", "PL_euid" or "PL_egid" variables.
713
714       The fix for those breakages is to use "PerlProc_gete?[ug]id()" to
715       retrieve them (e.g., "PerlProc_getuid()"), and not to assign to
716       "PL_e?[ug]id" if you change the UID/GID/EUID/EGID.  There is no longer
717       any need to do so since perl will always retrieve the up-to-date
718       version of those values from the OS.
719
720   Which Non-ASCII characters get quoted by "quotemeta" and "\Q" has changed
721       This is unlikely to result in a real problem, as Perl does not attach
722       special meaning to any non-ASCII character, so it is currently
723       irrelevant which are quoted or not.  This change fixes bug [perl
724       #77654] and brings Perl's behavior more into line with Unicode's
725       recommendations.  See "quotemeta" in perlfunc.
726

Performance Enhancements

728       ·   Improved performance for Unicode properties in regular expressions
729
730           Matching a code point against a Unicode property is now done via a
731           binary search instead of linear.  This means for example that the
732           worst case for a 1000 item property is 10 probes instead of 1000.
733           This inefficiency has been compensated for in the past by
734           permanently storing in a hash the results of a given probe plus the
735           results for the adjacent 64 code points, under the theory that
736           near-by code points are likely to be searched for.  A separate hash
737           was used for each mention of a Unicode property in each regular
738           expression.  Thus, "qr/\p{foo}abc\p{foo}/" would generate two
739           hashes.  Any probes in one instance would be unknown to the other,
740           and the hashes could expand separately to be quite large if the
741           regular expression were used on many different widely-separated
742           code points.  Now, however, there is just one hash shared by all
743           instances of a given property.  This means that if "\p{foo}" is
744           matched against "A" in one regular expression in a thread, the
745           result will be known immediately to all regular expressions, and
746           the relentless march of using up memory is slowed considerably.
747
748       ·   Version declarations with the "use" keyword (e.g., "use 5.012") are
749           now faster, as they enable features without loading feature.pm.
750
751       ·   "local $_" is faster now, as it no longer iterates through magic
752           that it is not going to copy anyway.
753
754       ·   Perl 5.12.0 sped up the destruction of objects whose classes define
755           empty "DESTROY" methods (to prevent autoloading), by simply not
756           calling such empty methods.  This release takes this optimization a
757           step further, by not calling any "DESTROY" method that begins with
758           a "return" statement.  This can be useful for destructors that are
759           only used for debugging:
760
761               use constant DEBUG => 1;
762               sub DESTROY { return unless DEBUG; ... }
763
764           Constant-folding will reduce the first statement to "return;" if
765           DEBUG is set to 0, triggering this optimization.
766
767       ·   Assigning to a variable that holds a typeglob or copy-on-write
768           scalar is now much faster.  Previously the typeglob would be
769           stringified or the copy-on-write scalar would be copied before
770           being clobbered.
771
772       ·   Assignment to "substr" in void context is now more than twice its
773           previous speed.  Instead of creating and returning a special lvalue
774           scalar that is then assigned to, "substr" modifies the original
775           string itself.
776
777       ·   "substr" no longer calculates a value to return when called in void
778           context.
779
780       ·   Due to changes in File::Glob, Perl's "glob" function and its
781           "<...>" equivalent are now much faster.  The splitting of the
782           pattern into words has been rewritten in C, resulting in speed-ups
783           of 20% for some cases.
784
785           This does not affect "glob" on VMS, as it does not use File::Glob.
786
787       ·   The short-circuiting operators "&&", "||", and "//", when chained
788           (such as "$a || $b || $c"), are now considerably faster to short-
789           circuit, due to reduced optree traversal.
790
791       ·   The implementation of "s///r" makes one fewer copy of the scalar's
792           value.
793
794       ·   Recursive calls to lvalue subroutines in lvalue scalar context use
795           less memory.
796

Modules and Pragmata

798   Deprecated Modules
799       Version::Requirements
800           Version::Requirements is now DEPRECATED, use
801           CPAN::Meta::Requirements, which is a drop-in replacement.  It will
802           be deleted from perl.git blead in v5.17.0.
803
804   New Modules and Pragmata
805       ·   arybase -- this new module implements the $[ variable.
806
807       ·   PerlIO::mmap 0.010 has been added to the Perl core.
808
809           The "mmap" PerlIO layer is no longer implemented by perl itself,
810           but has been moved out into the new PerlIO::mmap module.
811
812   Updated Modules and Pragmata
813       This is only an overview of selected module updates.  For a complete
814       list of updates, run:
815
816           $ corelist --diff 5.14.0 5.16.0
817
818       You can substitute your favorite version in place of 5.14.0, too.
819
820       ·   Archive::Extract has been upgraded from version 0.48 to 0.58.
821
822           Includes a fix for FreeBSD to only use "unzip" if it is located in
823           "/usr/local/bin", as FreeBSD 9.0 will ship with a limited "unzip"
824           in "/usr/bin".
825
826       ·   Archive::Tar has been upgraded from version 1.76 to 1.82.
827
828           Adjustments to handle files >8gb (>0777777777777 octal) and a
829           feature to return the MD5SUM of files in the archive.
830
831       ·   base has been upgraded from version 2.16 to 2.18.
832
833           "base" no longer sets a module's $VERSION to "-1" when a module it
834           loads does not define a $VERSION.  This change has been made
835           because "-1" is not a valid version number under the new "lax"
836           criteria used internally by "UNIVERSAL::VERSION".  (See version for
837           more on "lax" version criteria.)
838
839           "base" no longer internally skips loading modules it has already
840           loaded and instead relies on "require" to inspect %INC.  This fixes
841           a bug when "base" is used with code that clear %INC to force a
842           module to be reloaded.
843
844       ·   Carp has been upgraded from version 1.20 to 1.26.
845
846           It now includes last read filehandle info and puts a dot after the
847           file and line number, just like errors from "die" [perl #106538].
848
849       ·   charnames has been updated from version 1.18 to 1.30.
850
851           "charnames" can now be invoked with a new option, ":loose", which
852           is like the existing ":full" option, but enables Unicode loose name
853           matching.  Details are in "LOOSE MATCHES" in charnames.
854
855       ·   B::Deparse has been upgraded from version 1.03 to 1.14.  This fixes
856           numerous deparsing bugs.
857
858       ·   CGI has been upgraded from version 3.52 to 3.59.
859
860           It uses the public and documented FCGI.pm API in CGI::Fast.
861           CGI::Fast was using an FCGI API that was deprecated and removed
862           from documentation more than ten years ago.  Usage of this
863           deprecated API with FCGI >= 0.70 or FCGI <= 0.73 introduces a
864           security issue.
865           <https://rt.cpan.org/Public/Bug/Display.html?id=68380>
866           <http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-2766>
867
868           Things that may break your code:
869
870           "url()" was fixed to return "PATH_INFO" when it is explicitly
871           requested with either the "path=>1" or "path_info=>1" flag.
872
873           If your code is running under mod_rewrite (or compatible) and you
874           are calling "self_url()" or you are calling "url()" and passing
875           "path_info=>1", these methods will actually be returning
876           "PATH_INFO" now, as you have explicitly requested or "self_url()"
877           has requested on your behalf.
878
879           The "PATH_INFO" has been omitted in such URLs since the issue was
880           introduced in the 3.12 release in December, 2005.
881
882           This bug is so old your application may have come to depend on it
883           or workaround it. Check for application before upgrading to this
884           release.
885
886           Examples of affected method calls:
887
888             $q->url(-absolute => 1, -query => 1, -path_info => 1);
889             $q->url(-path=>1);
890             $q->url(-full=>1,-path=>1);
891             $q->url(-rewrite=>1,-path=>1);
892             $q->self_url();
893
894           We no longer read from STDIN when the Content-Length is not set,
895           preventing requests with no Content-Length from sometimes freezing.
896           This is consistent with the CGI RFC 3875, and is also consistent
897           with CGI::Simple.  However, the old behavior may have been expected
898           by some command-line uses of CGI.pm.
899
900           In addition, the DELETE HTTP verb is now supported.
901
902       ·   Compress::Zlib has been upgraded from version 2.035 to 2.048.
903
904           IO::Compress::Zip and IO::Uncompress::Unzip now have support for
905           LZMA (method 14).  There is a fix for a CRC issue in
906           IO::Compress::Unzip and it supports Streamed Stored context now.
907           And fixed a Zip64 issue in IO::Compress::Zip when the content size
908           was exactly 0xFFFFFFFF.
909
910       ·   Digest::SHA has been upgraded from version 5.61 to 5.71.
911
912           Added BITS mode to the addfile method and shasum.  This makes
913           partial-byte inputs possible via files/STDIN and lets shasum check
914           all 8074 NIST Msg vectors, where previously special programming was
915           required to do this.
916
917       ·   Encode has been upgraded from version 2.42 to 2.44.
918
919           Missing aliases added, a deep recursion error fixed and various
920           documentation updates.
921
922           Addressed 'decode_xs n-byte heap-overflow' security bug in
923           Unicode.xs (CVE-2011-2939). (5.14.2)
924
925       ·   ExtUtils::CBuilder updated from version 0.280203 to 0.280206.
926
927           The new version appends CFLAGS and LDFLAGS to their Config.pm
928           counterparts.
929
930       ·   ExtUtils::ParseXS has been upgraded from version 2.2210 to 3.16.
931
932           Much of ExtUtils::ParseXS, the module behind the XS compiler
933           "xsubpp", was rewritten and cleaned up.  It has been made somewhat
934           more extensible and now finally uses strictures.
935
936           The typemap logic has been moved into a separate module,
937           ExtUtils::Typemaps.  See "New Modules and Pragmata", above.
938
939           For a complete set of changes, please see the ExtUtils::ParseXS
940           changelog, available on the CPAN.
941
942       ·   File::Glob has been upgraded from version 1.12 to 1.17.
943
944           On Windows, tilde (~) expansion now checks the "USERPROFILE"
945           environment variable, after checking "HOME".
946
947           It has a new ":bsd_glob" export tag, intended to replace ":glob".
948           Like ":glob" it overrides "glob" with a function that does not
949           split the glob pattern into words, but, unlike ":glob", it iterates
950           properly in scalar context, instead of returning the last file.
951
952           There are other changes affecting Perl's own "glob" operator (which
953           uses File::Glob internally, except on VMS).  See "Performance
954           Enhancements" and "Selected Bug Fixes".
955
956       ·   FindBin updated from version 1.50 to 1.51.
957
958           It no longer returns a wrong result if a script of the same name as
959           the current one exists in the path and is executable.
960
961       ·   HTTP::Tiny has been upgraded from version 0.012 to 0.017.
962
963           Added support for using $ENV{http_proxy} to set the default proxy
964           host.
965
966           Adds additional shorthand methods for all common HTTP verbs, a
967           "post_form()" method for POST-ing x-www-form-urlencoded data and a
968           "www_form_urlencode()" utility method.
969
970       ·   IO has been upgraded from version 1.25_04 to 1.25_06, and
971           IO::Handle from version 1.31 to 1.33.
972
973           Together, these upgrades fix a problem with IO::Handle's "getline"
974           and "getlines" methods.  When these methods are called on the
975           special ARGV handle, the next file is automatically opened, as
976           happens with the built-in "<>" and "readline" functions.  But,
977           unlike the built-ins, these methods were not respecting the
978           caller's use of the open pragma and applying the appropriate I/O
979           layers to the newly-opened file [rt.cpan.org #66474].
980
981       ·   IPC::Cmd has been upgraded from version 0.70 to 0.76.
982
983           Capturing of command output (both "STDOUT" and "STDERR") is now
984           supported using IPC::Open3 on MSWin32 without requiring IPC::Run.
985
986       ·   IPC::Open3 has been upgraded from version 1.09 to 1.12.
987
988           Fixes a bug which prevented use of "open3" on Windows when *STDIN,
989           *STDOUT or *STDERR had been localized.
990
991           Fixes a bug which prevented duplicating numeric file descriptors on
992           Windows.
993
994           "open3" with "-" for the program name works once more.  This was
995           broken in version 1.06 (and hence in Perl 5.14.0) [perl #95748].
996
997       ·   Locale::Codes has been upgraded from version 3.16 to 3.21.
998
999           Added Language Extension codes (langext) and Language Variation
1000           codes (langvar) as defined in the IANA language registry.
1001
1002           Added language codes from ISO 639-5
1003
1004           Added language/script codes from the IANA language subtag registry
1005
1006           Fixed an uninitialized value warning [rt.cpan.org #67438].
1007
1008           Fixed the return value for the all_XXX_codes and all_XXX_names
1009           functions [rt.cpan.org #69100].
1010
1011           Reorganized modules to move Locale::MODULE to Locale::Codes::MODULE
1012           to allow for cleaner future additions.  The original four modules
1013           (Locale::Language, Locale::Currency, Locale::Country,
1014           Locale::Script) will continue to work, but all new sets of codes
1015           will be added in the Locale::Codes namespace.
1016
1017           The code2XXX, XXX2code, all_XXX_codes, and all_XXX_names functions
1018           now support retired codes.  All codesets may be specified by a
1019           constant or by their name now.  Previously, they were specified
1020           only by a constant.
1021
1022           The alias_code function exists for backward compatibility.  It has
1023           been replaced by rename_country_code.  The alias_code function will
1024           be removed some time after September, 2013.
1025
1026           All work is now done in the central module (Locale::Codes).
1027           Previously, some was still done in the wrapper modules
1028           (Locale::Codes::*).  Added Language Family codes (langfam) as
1029           defined in ISO 639-5.
1030
1031       ·   Math::BigFloat has been upgraded from version 1.993 to 1.997.
1032
1033           The "numify" method has been corrected to return a normalized Perl
1034           number (the result of "0 + $thing"), instead of a string
1035           [rt.cpan.org #66732].
1036
1037       ·   Math::BigInt has been upgraded from version 1.994 to 1.998.
1038
1039           It provides a new "bsgn" method that complements the "babs" method.
1040
1041           It fixes the internal "objectify" function's handling of "foreign
1042           objects" so they are converted to the appropriate class
1043           (Math::BigInt or Math::BigFloat).
1044
1045       ·   Math::BigRat has been upgraded from version 0.2602 to 0.2603.
1046
1047           "int()" on a Math::BigRat object containing -1/2 now creates a
1048           Math::BigInt containing 0, rather than -0.  Math::BigInt does not
1049           even support negative zero, so the resulting object was actually
1050           malformed [perl #95530].
1051
1052       ·   Math::Complex has been upgraded from version 1.56 to 1.59 and
1053           Math::Trig from version 1.2 to 1.22.
1054
1055           Fixes include: correct copy constructor usage; fix polarwise
1056           formatting with numeric format specifier; and more stable
1057           "great_circle_direction" algorithm.
1058
1059       ·   Module::CoreList has been upgraded from version 2.51 to 2.66.
1060
1061           The "corelist" utility now understands the "-r" option for
1062           displaying Perl release dates and the "--diff" option to print the
1063           set of modlib changes between two perl distributions.
1064
1065       ·   Module::Metadata has been upgraded from version 1.000004 to
1066           1.000009.
1067
1068           Adds "provides" method to generate a CPAN META provides data
1069           structure correctly; use of "package_versions_from_directory" is
1070           discouraged.
1071
1072       ·   ODBM_File has been upgraded from version 1.10 to 1.12.
1073
1074           The XS code is now compiled with "PERL_NO_GET_CONTEXT", which will
1075           aid performance under ithreads.
1076
1077       ·   open has been upgraded from version 1.08 to 1.10.
1078
1079           It no longer turns off layers on standard handles when invoked
1080           without the ":std" directive.  Similarly, when invoked with the
1081           ":std" directive, it now clears layers on STDERR before applying
1082           the new ones, and not just on STDIN and STDOUT [perl #92728].
1083
1084       ·   overload has been upgraded from version 1.13 to 1.18.
1085
1086           "overload::Overloaded" no longer calls "can" on the class, but uses
1087           another means to determine whether the object has overloading.  It
1088           was never correct for it to call "can", as overloading does not
1089           respect AUTOLOAD.  So classes that autoload methods and implement
1090           "can" no longer have to account for overloading [perl #40333].
1091
1092           A warning is now produced for invalid arguments.  See "New
1093           Diagnostics".
1094
1095       ·   PerlIO::scalar has been upgraded from version 0.11 to 0.14.
1096
1097           (This is the module that implements "open $fh, '>', \$scalar".)
1098
1099           It fixes a problem with "open my $fh, ">", \$scalar" not working if
1100           $scalar is a copy-on-write scalar. (5.14.2)
1101
1102           It also fixes a hang that occurs with "readline" or "<$fh>" if a
1103           typeglob has been assigned to $scalar [perl #92258].
1104
1105           It no longer assumes during "seek" that $scalar is a string
1106           internally.  If it didn't crash, it was close to doing so [perl
1107           #92706].  Also, the internal print routine no longer assumes that
1108           the position set by "seek" is valid, but extends the string to that
1109           position, filling the intervening bytes (between the old length and
1110           the seek position) with nulls [perl #78980].
1111
1112           Printing to an in-memory handle now works if the $scalar holds a
1113           reference, stringifying the reference before modifying it.
1114           References used to be treated as empty strings.
1115
1116           Printing to an in-memory handle no longer crashes if the $scalar
1117           happens to hold a number internally, but no string buffer.
1118
1119           Printing to an in-memory handle no longer creates scalars that
1120           confuse the regular expression engine [perl #108398].
1121
1122       ·   Pod::Functions has been upgraded from version 1.04 to 1.05.
1123
1124           Functions.pm is now generated at perl build time from annotations
1125           in perlfunc.pod.  This will ensure that Pod::Functions and perlfunc
1126           remain in synchronisation.
1127
1128       ·   Pod::Html has been upgraded from version 1.11 to 1.1502.
1129
1130           This is an extensive rewrite of Pod::Html to use Pod::Simple under
1131           the hood.  The output has changed significantly.
1132
1133       ·   Pod::Perldoc has been upgraded from version 3.15_03 to 3.17.
1134
1135           It corrects the search paths on VMS [perl #90640]. (5.14.1)
1136
1137           The -v option now fetches the right section for $0.
1138
1139           This upgrade has numerous significant fixes.  Consult its changelog
1140           on the CPAN for more information.
1141
1142       ·   POSIX has been upgraded from version 1.24 to 1.30.
1143
1144           POSIX no longer uses AutoLoader.  Any code which was relying on
1145           this implementation detail was buggy, and may fail because of this
1146           change.  The module's Perl code has been considerably simplified,
1147           roughly halving the number of lines, with no change in
1148           functionality.  The XS code has been refactored to reduce the size
1149           of the shared object by about 12%, with no change in functionality.
1150           More POSIX functions now have tests.
1151
1152           "sigsuspend" and "pause" now run signal handlers before returning,
1153           as the whole point of these two functions is to wait until a signal
1154           has arrived, and then return after it has been triggered.  Delayed,
1155           or "safe", signals were preventing that from happening, possibly
1156           resulting in race conditions [perl #107216].
1157
1158           "POSIX::sleep" is now a direct call into the underlying OS "sleep"
1159           function, instead of being a Perl wrapper on "CORE::sleep".
1160           "POSIX::dup2" now returns the correct value on Win32 (i.e., the
1161           file descriptor).  "POSIX::SigSet" "sigsuspend" and "sigpending"
1162           and "POSIX::pause" now dispatch safe signals immediately before
1163           returning to their caller.
1164
1165           "POSIX::Termios::setattr" now defaults the third argument to
1166           "TCSANOW", instead of 0. On most platforms "TCSANOW" is defined to
1167           be 0, but on some 0 is not a valid parameter, which caused a call
1168           with defaults to fail.
1169
1170       ·   Socket has been upgraded from version 1.94 to 2.001.
1171
1172           It has new functions and constants for handling IPv6 sockets:
1173
1174               pack_ipv6_mreq
1175               unpack_ipv6_mreq
1176               IPV6_ADD_MEMBERSHIP
1177               IPV6_DROP_MEMBERSHIP
1178               IPV6_MTU
1179               IPV6_MTU_DISCOVER
1180               IPV6_MULTICAST_HOPS
1181               IPV6_MULTICAST_IF
1182               IPV6_MULTICAST_LOOP
1183               IPV6_UNICAST_HOPS
1184               IPV6_V6ONLY
1185
1186       ·   Storable has been upgraded from version 2.27 to 2.34.
1187
1188           It no longer turns copy-on-write scalars into read-only scalars
1189           when freezing and thawing.
1190
1191       ·   Sys::Syslog has been upgraded from version 0.27 to 0.29.
1192
1193           This upgrade closes many outstanding bugs.
1194
1195       ·   Term::ANSIColor has been upgraded from version 3.00 to 3.01.
1196
1197           Only interpret an initial array reference as a list of colors, not
1198           any initial reference, allowing the colored function to work
1199           properly on objects with stringification defined.
1200
1201       ·   Term::ReadLine has been upgraded from version 1.07 to 1.09.
1202
1203           Term::ReadLine now supports any event loop, including unpublished
1204           ones and simple IO::Select, loops without the need to rewrite
1205           existing code for any particular framework [perl #108470].
1206
1207       ·   threads::shared has been upgraded from version 1.37 to 1.40.
1208
1209           Destructors on shared objects used to be ignored sometimes if the
1210           objects were referenced only by shared data structures.  This has
1211           been mostly fixed, but destructors may still be ignored if the
1212           objects still exist at global destruction time [perl #98204].
1213
1214       ·   Unicode::Collate has been upgraded from version 0.73 to 0.89.
1215
1216           Updated to CLDR 1.9.1
1217
1218           Locales updated to CLDR 2.0: mk, mt, nb, nn, ro, ru, sk, sr, sv,
1219           uk, zh__pinyin, zh__stroke
1220
1221           Newly supported locales: bn, fa, ml, mr, or, pa, sa, si,
1222           si__dictionary, sr_Latn, sv__reformed, ta, te, th, ur, wae.
1223
1224           Tailored compatibility ideographs as well as unified ideographs for
1225           the locales: ja, ko, zh__big5han, zh__gb2312han, zh__pinyin,
1226           zh__stroke.
1227
1228           Locale/*.pl files are now searched for in @INC.
1229
1230       ·   Unicode::Normalize has been upgraded from version 1.10 to 1.14.
1231
1232           Fixes for the removal of unicore/CompositionExclusions.txt from
1233           core.
1234
1235       ·   Unicode::UCD has been upgraded from version 0.32 to 0.43.
1236
1237           This adds four new functions:  "prop_aliases()" and
1238           "prop_value_aliases()", which are used to find all Unicode-approved
1239           synonyms for property names, or to convert from one name to
1240           another; "prop_invlist" which returns all code points matching a
1241           given Unicode binary property; and "prop_invmap" which returns the
1242           complete specification of a given Unicode property.
1243
1244       ·   Win32API::File has been upgraded from version 0.1101 to 0.1200.
1245
1246           Added SetStdHandle and GetStdHandle functions
1247
1248   Removed Modules and Pragmata
1249       As promised in Perl 5.14.0's release notes, the following modules have
1250       been removed from the core distribution, and if needed should be
1251       installed from CPAN instead.
1252
1253       ·   Devel::DProf has been removed from the Perl core.  Prior version
1254           was 20110228.00.
1255
1256       ·   Shell has been removed from the Perl core.  Prior version was
1257           0.72_01.
1258
1259       ·   Several old perl4-style libraries which have been deprecated with
1260           5.14 are now removed:
1261
1262               abbrev.pl assert.pl bigfloat.pl bigint.pl bigrat.pl cacheout.pl
1263               complete.pl ctime.pl dotsh.pl exceptions.pl fastcwd.pl flush.pl
1264               getcwd.pl getopt.pl getopts.pl hostname.pl importenv.pl
1265               lib/find{,depth}.pl look.pl newgetopt.pl open2.pl open3.pl
1266               pwd.pl shellwords.pl stat.pl tainted.pl termcap.pl timelocal.pl
1267
1268           They can be found on CPAN as Perl4::CoreLibs.
1269

Documentation

1271   New Documentation
1272       perldtrace
1273
1274       perldtrace describes Perl's DTrace support, listing the provided probes
1275       and gives examples of their use.
1276
1277       perlexperiment
1278
1279       This document is intended to provide a list of experimental features in
1280       Perl.  It is still a work in progress.
1281
1282       perlootut
1283
1284       This a new OO tutorial.  It focuses on basic OO concepts, and then
1285       recommends that readers choose an OO framework from CPAN.
1286
1287       perlxstypemap
1288
1289       The new manual describes the XS typemapping mechanism in unprecedented
1290       detail and combines new documentation with information extracted from
1291       perlxs and the previously unofficial list of all core typemaps.
1292
1293   Changes to Existing Documentation
1294       perlapi
1295
1296       ·   The HV API has long accepted negative lengths to show that the key
1297           is in UTF8.  This is now documented.
1298
1299       ·   The "boolSV()" macro is now documented.
1300
1301       perlfunc
1302
1303       ·   "dbmopen" treats a 0 mode as a special case, that prevents a
1304           nonexistent file from being created.  This has been the case since
1305           Perl 5.000, but was never documented anywhere.  Now the perlfunc
1306           entry mentions it [perl #90064].
1307
1308       ·   As an accident of history, "open $fh, '<:', ..." applies the
1309           default layers for the platform (":raw" on Unix, ":crlf" on
1310           Windows), ignoring whatever is declared by open.pm.  This seems
1311           such a useful feature it has been documented in perlfunc and open.
1312
1313       ·   The entry for "split" has been rewritten.  It is now far clearer
1314           than before.
1315
1316       perlguts
1317
1318       ·   A new section, Autoloading with XSUBs, has been added, which
1319           explains the two APIs for accessing the name of the autoloaded sub.
1320
1321       ·   Some function descriptions in perlguts were confusing, as it was
1322           not clear whether they referred to the function above or below the
1323           description.  This has been clarified [perl #91790].
1324
1325       perlobj
1326
1327       ·   This document has been rewritten from scratch, and its coverage of
1328           various OO concepts has been expanded.
1329
1330       perlop
1331
1332       ·   Documentation of the smartmatch operator has been reworked and
1333           moved from perlsyn to perlop where it belongs.
1334
1335           It has also been corrected for the case of "undef" on the left-hand
1336           side.  The list of different smart match behaviors had an item in
1337           the wrong place.
1338
1339       ·   Documentation of the ellipsis statement ("...") has been reworked
1340           and moved from perlop to perlsyn.
1341
1342       ·   The explanation of bitwise operators has been expanded to explain
1343           how they work on Unicode strings (5.14.1).
1344
1345       ·   More examples for "m//g" have been added (5.14.1).
1346
1347       ·   The "<<\FOO" here-doc syntax has been documented (5.14.1).
1348
1349       perlpragma
1350
1351       ·   There is now a standard convention for naming keys in the "%^H",
1352           documented under Key naming.
1353
1354       "Laundering and Detecting Tainted Data" in perlsec
1355
1356       ·   The example function for checking for taintedness contained a
1357           subtle error.  $@ needs to be localized to prevent its changing
1358           this global's value outside the function.  The preferred method to
1359           check for this remains "tainted" in Scalar::Util.
1360
1361       perllol
1362
1363       ·   perllol has been expanded with examples using the new "push
1364           $scalar" syntax introduced in Perl 5.14.0 (5.14.1).
1365
1366       perlmod
1367
1368       ·   perlmod now states explicitly that some types of explicit symbol
1369           table manipulation are not supported.  This codifies what was
1370           effectively already the case [perl #78074].
1371
1372       perlpodstyle
1373
1374       ·   The tips on which formatting codes to use have been corrected and
1375           greatly expanded.
1376
1377       ·   There are now a couple of example one-liners for previewing POD
1378           files after they have been edited.
1379
1380       perlre
1381
1382       ·   The "(*COMMIT)" directive is now listed in the right section (Verbs
1383           without an argument).
1384
1385       perlrun
1386
1387       ·   perlrun has undergone a significant clean-up.  Most notably, the
1388           -0x... form of the -0 flag has been clarified, and the final
1389           section on environment variables has been corrected and expanded
1390           (5.14.1).
1391
1392       perlsub
1393
1394       ·   The ($;) prototype syntax, which has existed for rather a long
1395           time, is now documented in perlsub.  It lets a unary function have
1396           the same precedence as a list operator.
1397
1398       perltie
1399
1400       ·   The required syntax for tying handles has been documented.
1401
1402       perlvar
1403
1404       ·   The documentation for $! has been corrected and clarified.  It used
1405           to state that $! could be "undef", which is not the case.  It was
1406           also unclear whether system calls set C's "errno" or Perl's $!
1407           [perl #91614].
1408
1409       ·   Documentation for $$ has been amended with additional cautions
1410           regarding changing the process ID.
1411
1412       Other Changes
1413
1414       ·   perlxs was extended with documentation on inline typemaps.
1415
1416       ·   perlref has a new Circular References section explaining how
1417           circularities may not be freed and how to solve that with weak
1418           references.
1419
1420       ·   Parts of perlapi were clarified, and Perl equivalents of some C
1421           functions have been added as an additional mode of exposition.
1422
1423       ·   A few parts of perlre and perlrecharclass were clarified.
1424
1425   Removed Documentation
1426       Old OO Documentation
1427
1428       The old OO tutorials, perltoot, perltooc, and perlboot, have been
1429       removed.  The perlbot (bag of object tricks) document has been removed
1430       as well.
1431
1432       Development Deltas
1433
1434       The perldelta files for development releases are no longer packaged
1435       with perl.  These can still be found in the perl source code
1436       repository.
1437

Diagnostics

1439       The following additions or changes have been made to diagnostic output,
1440       including warnings and fatal error messages.  For the complete list of
1441       diagnostic messages, see perldiag.
1442
1443   New Diagnostics
1444       New Errors
1445
1446       ·   Cannot set tied @DB::args
1447
1448           This error occurs when "caller" tries to set @DB::args but finds it
1449           tied.  Before this error was added, it used to crash instead.
1450
1451       ·   Cannot tie unreifiable array
1452
1453           This error is part of a safety check that the "tie" operator does
1454           before tying a special array like @_.  You should never see this
1455           message.
1456
1457       ·   &CORE::%s cannot be called directly
1458
1459           This occurs when a subroutine in the "CORE::" namespace is called
1460           with &foo syntax or through a reference.  Some subroutines in this
1461           package cannot yet be called that way, but must be called as
1462           barewords.  See "Subroutines in the "CORE" namespace", above.
1463
1464       ·   Source filters apply only to byte streams
1465
1466           This new error occurs when you try to activate a source filter
1467           (usually by loading a source filter module) within a string passed
1468           to "eval" under the "unicode_eval" feature.
1469
1470       New Warnings
1471
1472       ·   defined(@array) is deprecated
1473
1474           The long-deprecated "defined(@array)" now also warns for package
1475           variables.  Previously it issued a warning for lexical variables
1476           only.
1477
1478       ·   length() used on %s
1479
1480           This new warning occurs when "length" is used on an array or hash,
1481           instead of "scalar(@array)" or "scalar(keys %hash)".
1482
1483       ·   lvalue attribute %s already-defined subroutine
1484
1485           attributes.pm now emits this warning when the :lvalue attribute is
1486           applied to a Perl subroutine that has already been defined, as
1487           doing so can have unexpected side-effects.
1488
1489       ·   overload arg '%s' is invalid
1490
1491           This warning, in the "overload" category, is produced when the
1492           overload pragma is given an argument it doesn't recognize,
1493           presumably a mistyped operator.
1494
1495       ·   $[ used in %s (did you mean $] ?)
1496
1497           This new warning exists to catch the mistaken use of $[ in version
1498           checks.  $], not $[, contains the version number.
1499
1500       ·   Useless assignment to a temporary
1501
1502           Assigning to a temporary scalar returned from an lvalue subroutine
1503           now produces this warning [perl #31946].
1504
1505       ·   Useless use of \E
1506
1507           "\E" does nothing unless preceded by "\Q", "\L" or "\U".
1508
1509   Removed Errors
1510       ·   "sort is now a reserved word"
1511
1512           This error used to occur when "sort" was called without arguments,
1513           followed by ";" or ")".  (E.g., "sort;" would die, but "{sort}" was
1514           OK.)  This error message was added in Perl 3 to catch code like
1515           "close(sort)" which would no longer work.  More than two decades
1516           later, this message is no longer appropriate.  Now "sort" without
1517           arguments is always allowed, and returns an empty list, as it did
1518           in those cases where it was already allowed [perl #90030].
1519
1520   Changes to Existing Diagnostics
1521       ·   The "Applying pattern match..." or similar warning produced when an
1522           array or hash is on the left-hand side of the "=~" operator now
1523           mentions the name of the variable.
1524
1525       ·   The "Attempt to free non-existent shared string" has had the
1526           spelling of "non-existent" corrected to "nonexistent".  It was
1527           already listed with the correct spelling in perldiag.
1528
1529       ·   The error messages for using "default" and "when" outside a
1530           topicalizer have been standardized to match the messages for
1531           "continue" and loop controls.  They now read 'Can't "default"
1532           outside a topicalizer' and 'Can't "when" outside a topicalizer'.
1533           They both used to be 'Can't use when() outside a topicalizer' [perl
1534           #91514].
1535
1536       ·   The message, "Code point 0x%X is not Unicode, no properties match
1537           it; all inverse properties do" has been changed to "Code point 0x%X
1538           is not Unicode, all \p{} matches fail; all \P{} matches succeed".
1539
1540       ·   Redefinition warnings for constant subroutines used to be
1541           mandatory, even occurring under "no warnings".  Now they respect
1542           the warnings pragma.
1543
1544       ·   The "glob failed" warning message is now suppressible via "no
1545           warnings" [perl #111656].
1546
1547       ·   The Invalid version format error message now says "negative version
1548           number" within the parentheses, rather than "non-numeric data", for
1549           negative numbers.
1550
1551       ·   The two warnings Possible attempt to put comments in qw() list and
1552           Possible attempt to separate words with commas are no longer
1553           mutually exclusive: the same "qw" construct may produce both.
1554
1555       ·   The uninitialized warning for "y///r" when $_ is implicit and
1556           undefined now mentions the variable name, just like the non-/r
1557           variation of the operator.
1558
1559       ·   The 'Use of "foo" without parentheses is ambiguous' warning has
1560           been extended to apply also to user-defined subroutines with a (;$)
1561           prototype, and not just to built-in functions.
1562
1563       ·   Warnings that mention the names of lexical ("my") variables with
1564           Unicode characters in them now respect the presence or absence of
1565           the ":utf8" layer on the output handle, instead of outputting UTF8
1566           regardless.  Also, the correct names are included in the strings
1567           passed to $SIG{__WARN__} handlers, rather than the raw UTF8 bytes.
1568

Utility Changes

1570       h2ph
1571
1572       ·   h2ph used to generate code of the form
1573
1574             unless(defined(&FOO)) {
1575               sub FOO () {42;}
1576             }
1577
1578           But the subroutine is a compile-time declaration, and is hence
1579           unaffected by the condition.  It has now been corrected to emit a
1580           string "eval" around the subroutine [perl #99368].
1581
1582       splain
1583
1584       ·   splain no longer emits backtraces with the first line number
1585           repeated.
1586
1587           This:
1588
1589               Uncaught exception from user code:
1590                       Cannot fwiddle the fwuddle at -e line 1.
1591                at -e line 1
1592                       main::baz() called at -e line 1
1593                       main::bar() called at -e line 1
1594                       main::foo() called at -e line 1
1595
1596           has become this:
1597
1598               Uncaught exception from user code:
1599                       Cannot fwiddle the fwuddle at -e line 1.
1600                       main::baz() called at -e line 1
1601                       main::bar() called at -e line 1
1602                       main::foo() called at -e line 1
1603
1604       ·   Some error messages consist of multiple lines that are listed as
1605           separate entries in perldiag.  splain has been taught to find the
1606           separate entries in these cases, instead of simply failing to find
1607           the message.
1608
1609       zipdetails
1610
1611       ·   This is a new utility, included as part of an IO::Compress::Base
1612           upgrade.
1613
1614           zipdetails displays information about the internal record structure
1615           of the zip file.  It is not concerned with displaying any details
1616           of the compressed data stored in the zip file.
1617

Configuration and Compilation

1619       ·   regexp.h has been modified for compatibility with GCC's -Werror
1620           option, as used by some projects that include perl's header files
1621           (5.14.1).
1622
1623       ·   "USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}" have been added the output
1624           of perl -V as they have affect the behavior of the interpreter
1625           binary (albeit in only a small area).
1626
1627       ·   The code and tests for IPC::Open2 have been moved from
1628           ext/IPC-Open2 into ext/IPC-Open3, as "IPC::Open2::open2()" is
1629           implemented as a thin wrapper around "IPC::Open3::_open3()", and
1630           hence is very tightly coupled to it.
1631
1632       ·   The magic types and magic vtables are now generated from data in a
1633           new script regen/mg_vtable.pl, instead of being maintained by hand.
1634           As different EBCDIC variants can't agree on the code point for '~',
1635           the character to code point conversion is done at build time by
1636           generate_uudmap to a new generated header mg_data.h.  "PL_vtbl_bm"
1637           and "PL_vtbl_fm" are now defined by the pre-processor as
1638           "PL_vtbl_regexp", instead of being distinct C variables.
1639           "PL_vtbl_sig" has been removed.
1640
1641       ·   Building with "-DPERL_GLOBAL_STRUCT" works again.  This
1642           configuration is not generally used.
1643
1644       ·   Perl configured with MAD now correctly frees "MADPROP" structures
1645           when OPs are freed.  "MADPROP"s are now allocated with
1646           "PerlMemShared_malloc()"
1647
1648       ·   makedef.pl has been refactored.  This should have no noticeable
1649           affect on any of the platforms that use it as part of their build
1650           (AIX, VMS, Win32).
1651
1652       ·   "useperlio" can no longer be disabled.
1653
1654       ·   The file global.sym is no longer needed, and has been removed.  It
1655           contained a list of all exported functions, one of the files
1656           generated by regen/embed.pl from data in embed.fnc and
1657           regen/opcodes.  The code has been refactored so that the only user
1658           of global.sym, makedef.pl, now reads embed.fnc and regen/opcodes
1659           directly, removing the need to store the list of exported functions
1660           in an intermediate file.
1661
1662           As global.sym was never installed, this change should not be
1663           visible outside the build process.
1664
1665       ·   pod/buildtoc, used by the build process to build perltoc, has been
1666           refactored and simplified.  It now contains only code to build
1667           perltoc; the code to regenerate Makefiles has been moved to
1668           Porting/pod_rules.pl.  It's a bug if this change has any material
1669           effect on the build process.
1670
1671       ·   pod/roffitall is now built by pod/buildtoc, instead of being
1672           shipped with the distribution.  Its list of manpages is now
1673           generated (and therefore current).  See also RT #103202 for an
1674           unresolved related issue.
1675
1676       ·   The man page for "XS::Typemap" is no longer installed.
1677           "XS::Typemap" is a test module which is not installed, hence
1678           installing its documentation makes no sense.
1679
1680       ·   The -Dusesitecustomize and -Duserelocatableinc options now work
1681           together properly.
1682

Platform Support

1684   Platform-Specific Notes
1685       Cygwin
1686
1687       ·   Since version 1.7, Cygwin supports native UTF-8 paths.  If Perl is
1688           built under that environment, directory and filenames will be UTF-8
1689           encoded.
1690
1691       ·   Cygwin does not initialize all original Win32 environment
1692           variables.  See README.cygwin for a discussion of the newly-added
1693           "Cygwin::sync_winenv()" function [perl #110190] and for further
1694           links.
1695
1696       HP-UX
1697
1698       ·   HP-UX PA-RISC/64 now supports gcc-4.x
1699
1700           A fix to correct the socketsize now makes the test suite pass on
1701           HP-UX PA-RISC for 64bitall builds. (5.14.2)
1702
1703       VMS
1704
1705       ·   Remove unnecessary includes, fix miscellaneous compiler warnings
1706           and close some unclosed comments on vms/vms.c.
1707
1708       ·   Remove sockadapt layer from the VMS build.
1709
1710       ·   Explicit support for VMS versions before v7.0 and DEC C versions
1711           before v6.0 has been removed.
1712
1713       ·   Since Perl 5.10.1, the home-grown "stat" wrapper has been unable to
1714           distinguish between a directory name containing an underscore and
1715           an otherwise-identical filename containing a dot in the same
1716           position (e.g., t/test_pl as a directory and t/test.pl as a file).
1717           This problem has been corrected.
1718
1719       ·   The build on VMS now permits names of the resulting symbols in C
1720           code for Perl longer than 31 characters.  Symbols like
1721           "Perl__it_was_the_best_of_times_it_was_the_worst_of_times" can now
1722           be created freely without causing the VMS linker to seize up.
1723
1724       GNU/Hurd
1725
1726       ·   Numerous build and test failures on GNU/Hurd have been resolved
1727           with hints for building DBM modules, detection of the library
1728           search path, and enabling of large file support.
1729
1730       OpenVOS
1731
1732       ·   Perl is now built with dynamic linking on OpenVOS, the minimum
1733           supported version of which is now Release 17.1.0.
1734
1735       SunOS
1736
1737       The CC workshop C++ compiler is now detected and used on systems that
1738       ship without cc.
1739

Internal Changes

1741       ·   The compiled representation of formats is now stored via the
1742           "mg_ptr" of their "PERL_MAGIC_fm".  Previously it was stored in the
1743           string buffer, beyond "SvLEN()", the regular end of the string.
1744           "SvCOMPILED()" and "SvCOMPILED_{on,off}()" now exist solely for
1745           compatibility for XS code.  The first is always 0, the other two
1746           now no-ops. (5.14.1)
1747
1748       ·   Some global variables have been marked "const", members in the
1749           interpreter structure have been re-ordered, and the opcodes have
1750           been re-ordered.  The op "OP_AELEMFAST" has been split into
1751           "OP_AELEMFAST" and "OP_AELEMFAST_LEX".
1752
1753       ·   When empting a hash of its elements (e.g., via undef(%h), or
1754           %h=()), HvARRAY field is no longer temporarily zeroed.  Any
1755           destructors called on the freed elements see the remaining
1756           elements.  Thus, %h=() becomes more like "delete $h{$_} for keys
1757           %h".
1758
1759       ·   Boyer-Moore compiled scalars are now PVMGs, and the Boyer-Moore
1760           tables are now stored via the mg_ptr of their "PERL_MAGIC_bm".
1761           Previously they were PVGVs, with the tables stored in the string
1762           buffer, beyond "SvLEN()".  This eliminates the last place where the
1763           core stores data beyond "SvLEN()".
1764
1765       ·   Simplified logic in "Perl_sv_magic()" introduces a small change of
1766           behavior for error cases involving unknown magic types.
1767           Previously, if "Perl_sv_magic()" was passed a magic type unknown to
1768           it, it would
1769
1770           1.  Croak "Modification of a read-only value attempted" if read
1771               only
1772
1773           2.  Return without error if the SV happened to already have this
1774               magic
1775
1776           3.  otherwise croak "Don't know how to handle magic of type \\%o"
1777
1778           Now it will always croak "Don't know how to handle magic of type
1779           \\%o", even on read-only values, or SVs which already have the
1780           unknown magic type.
1781
1782       ·   The experimental "fetch_cop_label" function has been renamed to
1783           "cop_fetch_label".
1784
1785       ·   The "cop_store_label" function has been added to the API, but is
1786           experimental.
1787
1788       ·   embedvar.h has been simplified, and one level of macro indirection
1789           for PL_* variables has been removed for the default (non-
1790           multiplicity) configuration.  PERLVAR*() macros now directly expand
1791           their arguments to tokens such as "PL_defgv", instead of expanding
1792           to "PL_Idefgv", with embedvar.h defining a macro to map "PL_Idefgv"
1793           to "PL_defgv".  XS code which has unwarranted chumminess with the
1794           implementation may need updating.
1795
1796       ·   An API has been added to explicitly choose whether to export XSUB
1797           symbols.  More detail can be found in the comments for commit
1798           e64345f8.
1799
1800       ·   The "is_gv_magical_sv" function has been eliminated and merged with
1801           "gv_fetchpvn_flags".  It used to be called to determine whether a
1802           GV should be autovivified in rvalue context.  Now it has been
1803           replaced with a new "GV_ADDMG" flag (not part of the API).
1804
1805       ·   The returned code point from the function "utf8n_to_uvuni()" when
1806           the input is malformed UTF-8, malformations are allowed, and "utf8"
1807           warnings are off is now the Unicode REPLACEMENT CHARACTER whenever
1808           the malformation is such that no well-defined code point can be
1809           computed.  Previously the returned value was essentially garbage.
1810           The only malformations that have well-defined values are a zero-
1811           length string (0 is the return), and overlong UTF-8 sequences.
1812
1813       ·   Padlists are now marked "AvREAL"; i.e., reference-counted.  They
1814           have always been reference-counted, but were not marked real,
1815           because pad.c did its own clean-up, instead of using the usual
1816           clean-up code in sv.c.  That caused problems in thread cloning, so
1817           now the "AvREAL" flag is on, but is turned off in pad.c right
1818           before the padlist is freed (after pad.c has done its custom
1819           freeing of the pads).
1820
1821       ·   All C files that make up the Perl core have been converted to
1822           UTF-8.
1823
1824       ·   These new functions have been added as part of the work on Unicode
1825           symbols:
1826
1827               HvNAMELEN
1828               HvNAMEUTF8
1829               HvENAMELEN
1830               HvENAMEUTF8
1831               gv_init_pv
1832               gv_init_pvn
1833               gv_init_pvsv
1834               gv_fetchmeth_pv
1835               gv_fetchmeth_pvn
1836               gv_fetchmeth_sv
1837               gv_fetchmeth_pv_autoload
1838               gv_fetchmeth_pvn_autoload
1839               gv_fetchmeth_sv_autoload
1840               gv_fetchmethod_pv_flags
1841               gv_fetchmethod_pvn_flags
1842               gv_fetchmethod_sv_flags
1843               gv_autoload_pv
1844               gv_autoload_pvn
1845               gv_autoload_sv
1846               newGVgen_flags
1847               sv_derived_from_pv
1848               sv_derived_from_pvn
1849               sv_derived_from_sv
1850               sv_does_pv
1851               sv_does_pvn
1852               sv_does_sv
1853               whichsig_pv
1854               whichsig_pvn
1855               whichsig_sv
1856               newCONSTSUB_flags
1857
1858           The gv_fetchmethod_*_flags functions, like gv_fetchmethod_flags,
1859           are experimental and may change in a future release.
1860
1861       ·   The following functions were added.  These are not part of the API:
1862
1863               GvNAMEUTF8
1864               GvENAMELEN
1865               GvENAME_HEK
1866               CopSTASH_flags
1867               CopSTASH_flags_set
1868               PmopSTASH_flags
1869               PmopSTASH_flags_set
1870               sv_sethek
1871               HEKfARG
1872
1873           There is also a "HEKf" macro corresponding to "SVf", for
1874           interpolating HEKs in formatted strings.
1875
1876       ·   "sv_catpvn_flags" takes a couple of new internal-only flags,
1877           "SV_CATBYTES" and "SV_CATUTF8", which tell it whether the char
1878           array to be concatenated is UTF8.  This allows for more efficient
1879           concatenation than creating temporary SVs to pass to "sv_catsv".
1880
1881       ·   For XS AUTOLOAD subs, $AUTOLOAD is set once more, as it was in
1882           5.6.0.  This is in addition to setting "SvPVX(cv)", for
1883           compatibility with 5.8 to 5.14.  See "Autoloading with XSUBs" in
1884           perlguts.
1885
1886       ·   Perl now checks whether the array (the linearized isa) returned by
1887           a MRO plugin begins with the name of the class itself, for which
1888           the array was created, instead of assuming that it does.  This
1889           prevents the first element from being skipped during method lookup.
1890           It also means that "mro::get_linear_isa" may return an array with
1891           one more element than the MRO plugin provided [perl #94306].
1892
1893       ·   "PL_curstash" is now reference-counted.
1894
1895       ·   There are now feature bundle hints in "PL_hints" ($^H) that version
1896           declarations use, to avoid having to load feature.pm.  One setting
1897           of the hint bits indicates a "custom" feature bundle, which means
1898           that the entries in "%^H" still apply.  feature.pm uses that.
1899
1900           The "HINT_FEATURE_MASK" macro is defined in perl.h along with other
1901           hints.  Other macros for setting and testing features and bundles
1902           are in the new feature.h.  "FEATURE_IS_ENABLED" (which has moved to
1903           feature.h) is no longer used throughout the codebase, but more
1904           specific macros, e.g., "FEATURE_SAY_IS_ENABLED", that are defined
1905           in feature.h.
1906
1907       ·   lib/feature.pm is now a generated file, created by the new
1908           regen/feature.pl script, which also generates feature.h.
1909
1910       ·   Tied arrays are now always "AvREAL".  If @_ or "DB::args" is tied,
1911           it is reified first, to make sure this is always the case.
1912
1913       ·   Two new functions "utf8_to_uvchr_buf()" and "utf8_to_uvuni_buf()"
1914           have been added.  These are the same as "utf8_to_uvchr" and
1915           "utf8_to_uvuni" (which are now deprecated), but take an extra
1916           parameter that is used to guard against reading beyond the end of
1917           the input string.  See "utf8_to_uvchr_buf" in perlapi and
1918           "utf8_to_uvuni_buf" in perlapi.
1919
1920       ·   The regular expression engine now does TRIE case insensitive
1921           matches under Unicode. This may change the output of "use re
1922           'debug';", and will speed up various things.
1923
1924       ·   There is a new "wrap_op_checker()" function, which provides a
1925           thread-safe alternative to writing to "PL_check" directly.
1926

Selected Bug Fixes

1928   Array and hash
1929       ·   A bug has been fixed that would cause a "Use of freed value in
1930           iteration" error if the next two hash elements that would be
1931           iterated over are deleted [perl #85026]. (5.14.1)
1932
1933       ·   Deleting the current hash iterator (the hash element that would be
1934           returned by the next call to "each") in void context used not to
1935           free it [perl #85026].
1936
1937       ·   Deletion of methods via "delete $Class::{method}" syntax used to
1938           update method caches if called in void context, but not scalar or
1939           list context.
1940
1941       ·   When hash elements are deleted in void context, the internal hash
1942           entry is now freed before the value is freed, to prevent
1943           destructors called by that latter freeing from seeing the hash in
1944           an inconsistent state.  It was possible to cause double-frees if
1945           the destructor freed the hash itself [perl #100340].
1946
1947       ·   A "keys" optimization in Perl 5.12.0 to make it faster on empty
1948           hashes caused "each" not to reset the iterator if called after the
1949           last element was deleted.
1950
1951       ·   Freeing deeply nested hashes no longer crashes [perl #44225].
1952
1953       ·   It is possible from XS code to create hashes with elements that
1954           have no values.  The hash element and slice operators used to crash
1955           when handling these in lvalue context.  They now produce a
1956           "Modification of non-creatable hash value attempted" error message.
1957
1958       ·   If list assignment to a hash or array triggered destructors that
1959           freed the hash or array itself, a crash would ensue.  This is no
1960           longer the case [perl #107440].
1961
1962       ·   It used to be possible to free the typeglob of a localized array or
1963           hash (e.g., "local @{"x"}; delete $::{x}"), resulting in a crash on
1964           scope exit.
1965
1966       ·   Some core bugs affecting Hash::Util have been fixed: locking a hash
1967           element that is a glob copy no longer causes the next assignment to
1968           it to corrupt the glob (5.14.2), and unlocking a hash element that
1969           holds a copy-on-write scalar no longer causes modifications to that
1970           scalar to modify other scalars that were sharing the same string
1971           buffer.
1972
1973   C API fixes
1974       ·   The "newHVhv" XS function now works on tied hashes, instead of
1975           crashing or returning an empty hash.
1976
1977       ·   The "SvIsCOW" C macro now returns false for read-only copies of
1978           typeglobs, such as those created by:
1979
1980             $hash{elem} = *foo;
1981             Hash::Util::lock_value %hash, 'elem';
1982
1983           It used to return true.
1984
1985       ·   The "SvPVutf8" C function no longer tries to modify its argument,
1986           resulting in errors [perl #108994].
1987
1988       ·   "SvPVutf8" now works properly with magical variables.
1989
1990       ·   "SvPVbyte" now works properly non-PVs.
1991
1992       ·   When presented with malformed UTF-8 input, the XS-callable
1993           functions "is_utf8_string()", "is_utf8_string_loc()", and
1994           "is_utf8_string_loclen()" could read beyond the end of the input
1995           string by up to 12 bytes.  This no longer happens.  [perl #32080].
1996           However, currently, "is_utf8_char()" still has this defect, see
1997           "is_utf8_char()" above.
1998
1999       ·   The C-level "pregcomp" function could become confused about whether
2000           the pattern was in UTF8 if the pattern was an overloaded, tied, or
2001           otherwise magical scalar [perl #101940].
2002
2003   Compile-time hints
2004       ·   Tying "%^H" no longer causes perl to crash or ignore the contents
2005           of "%^H" when entering a compilation scope [perl #106282].
2006
2007       ·   "eval $string" and "require" used not to localize "%^H" during
2008           compilation if it was empty at the time the "eval" call itself was
2009           compiled.  This could lead to scary side effects, like "use re
2010           "/m"" enabling other flags that the surrounding code was trying to
2011           enable for its caller [perl #68750].
2012
2013       ·   "eval $string" and "require" no longer localize hints ($^H and
2014           "%^H") at run time, but only during compilation of the $string or
2015           required file.  This makes "BEGIN { $^H{foo}=7 }" equivalent to
2016           "BEGIN { eval '$^H{foo}=7' }" [perl #70151].
2017
2018       ·   Creating a BEGIN block from XS code (via "newXS" or "newATTRSUB")
2019           would, on completion, make the hints of the current compiling code
2020           the current hints.  This could cause warnings to occur in a non-
2021           warning scope.
2022
2023   Copy-on-write scalars
2024       Copy-on-write or shared hash key scalars were introduced in 5.8.0, but
2025       most Perl code did not encounter them (they were used mostly
2026       internally).  Perl 5.10.0 extended them, such that assigning
2027       "__PACKAGE__" or a hash key to a scalar would make it copy-on-write.
2028       Several parts of Perl were not updated to account for them, but have
2029       now been fixed.
2030
2031       ·   "utf8::decode" had a nasty bug that would modify copy-on-write
2032           scalars' string buffers in place (i.e., skipping the copy).  This
2033           could result in hashes having two elements with the same key [perl
2034           #91834]. (5.14.2)
2035
2036       ·   Lvalue subroutines were not allowing COW scalars to be returned.
2037           This was fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0,
2038           but list context was not fixed until this release.
2039
2040       ·   Elements of restricted hashes (see the fields pragma) containing
2041           copy-on-write values couldn't be deleted, nor could such hashes be
2042           cleared ("%hash = ()"). (5.14.2)
2043
2044       ·   Localizing a tied variable used to make it read-only if it
2045           contained a copy-on-write string. (5.14.2)
2046
2047       ·   Assigning a copy-on-write string to a stash element no longer
2048           causes a double free.  Regardless of this change, the results of
2049           such assignments are still undefined.
2050
2051       ·   Assigning a copy-on-write string to a tied variable no longer stops
2052           that variable from being tied if it happens to be a PVMG or PVLV
2053           internally.
2054
2055       ·   Doing a substitution on a tied variable returning a copy-on-write
2056           scalar used to cause an assertion failure or an "Attempt to free
2057           nonexistent shared string" warning.
2058
2059       ·   This one is a regression from 5.12: In 5.14.0, the bitwise
2060           assignment operators "|=", "^=" and "&=" started leaving the left-
2061           hand side undefined if it happened to be a copy-on-write string
2062           [perl #108480].
2063
2064       ·   Storable, Devel::Peek and PerlIO::scalar had similar problems.  See
2065           "Updated Modules and Pragmata", above.
2066
2067   The debugger
2068       ·   dumpvar.pl, and therefore the "x" command in the debugger, have
2069           been fixed to handle objects blessed into classes whose names
2070           contain "=".  The contents of such objects used not to be dumped
2071           [perl #101814].
2072
2073       ·   The "R" command for restarting a debugger session has been fixed to
2074           work on Windows, or any other system lacking a
2075           "POSIX::_SC_OPEN_MAX" constant [perl #87740].
2076
2077       ·   The "#line 42 foo" directive used not to update the arrays of lines
2078           used by the debugger if it occurred in a string eval.  This was
2079           partially fixed in 5.14, but it worked only for a single "#line 42
2080           foo" in each eval.  Now it works for multiple.
2081
2082       ·   When subroutine calls are intercepted by the debugger, the name of
2083           the subroutine or a reference to it is stored in $DB::sub, for the
2084           debugger to access.  Sometimes (such as "$foo = *bar; undef *bar;
2085           &$foo") $DB::sub would be set to a name that could not be used to
2086           find the subroutine, and so the debugger's attempt to call it would
2087           fail.  Now the check to see whether a reference is needed is more
2088           robust, so those problems should not happen anymore [rt.cpan.org
2089           #69862].
2090
2091       ·   Every subroutine has a filename associated with it that the
2092           debugger uses.  The one associated with constant subroutines used
2093           to be misallocated when cloned under threads.  Consequently,
2094           debugging threaded applications could result in memory corruption
2095           [perl #96126].
2096
2097   Dereferencing operators
2098       ·   "defined(${"..."})", "defined(*{"..."})", etc., used to return true
2099           for most, but not all built-in variables, if they had not been used
2100           yet.  This bug affected "${^GLOBAL_PHASE}" and "${^UTF8CACHE}",
2101           among others.  It also used to return false if the package name was
2102           given as well ("${"::!"}") [perl #97978, #97492].
2103
2104       ·   Perl 5.10.0 introduced a similar bug: "defined(*{"foo"})" where
2105           "foo" represents the name of a built-in global variable used to
2106           return false if the variable had never been used before, but only
2107           on the first call.  This, too, has been fixed.
2108
2109       ·   Since 5.6.0, "*{ ... }" has been inconsistent in how it treats
2110           undefined values.  It would die in strict mode or lvalue context
2111           for most undefined values, but would be treated as the empty string
2112           (with a warning) for the specific scalar return by "undef()"
2113           (&PL_sv_undef internally).  This has been corrected.  "undef()" is
2114           now treated like other undefined scalars, as in Perl 5.005.
2115
2116   Filehandle, last-accessed
2117       Perl has an internal variable that stores the last filehandle to be
2118       accessed.  It is used by $. and by "tell" and "eof" without arguments.
2119
2120       ·   It used to be possible to set this internal variable to a glob copy
2121           and then modify that glob copy to be something other than a glob,
2122           and still have the last-accessed filehandle associated with the
2123           variable after assigning a glob to it again:
2124
2125               my $foo = *STDOUT;  # $foo is a glob copy
2126               <$foo>;             # $foo is now the last-accessed handle
2127               $foo = 3;           # no longer a glob
2128               $foo = *STDERR;     # still the last-accessed handle
2129
2130           Now the "$foo = 3" assignment unsets that internal variable, so
2131           there is no last-accessed filehandle, just as if "<$foo>" had never
2132           happened.
2133
2134           This also prevents some unrelated handle from becoming the last-
2135           accessed handle if $foo falls out of scope and the same internal SV
2136           gets used for another handle [perl #97988].
2137
2138       ·   A regression in 5.14 caused these statements not to set that
2139           internal variable:
2140
2141               my $fh = *STDOUT;
2142               tell $fh;
2143               eof  $fh;
2144               seek $fh, 0,0;
2145               tell     *$fh;
2146               eof      *$fh;
2147               seek     *$fh, 0,0;
2148               readline *$fh;
2149
2150           This is now fixed, but "tell *{ *$fh }" still has the problem, and
2151           it is not clear how to fix it [perl #106536].
2152
2153   Filetests and "stat"
2154       The term "filetests" refers to the operators that consist of a hyphen
2155       followed by a single letter: "-r", "-x", "-M", etc.  The term "stacked"
2156       when applied to filetests means followed by another filetest operator
2157       sharing the same operand, as in "-r -x -w $fooo".
2158
2159       ·   "stat" produces more consistent warnings.  It no longer warns for
2160           "_" [perl #71002] and no longer skips the warning at times for
2161           other unopened handles.  It no longer warns about an unopened
2162           handle when the operating system's "fstat" function fails.
2163
2164       ·   "stat" would sometimes return negative numbers for large inode
2165           numbers, because it was using the wrong internal C type. [perl
2166           #84590]
2167
2168       ·   "lstat" is documented to fall back to "stat" (with a warning) when
2169           given a filehandle.  When passed an IO reference, it was actually
2170           doing the equivalent of "stat _" and ignoring the handle.
2171
2172       ·   "-T _" with no preceding "stat" used to produce a confusing
2173           "uninitialized" warning, even though there is no visible
2174           uninitialized value to speak of.
2175
2176       ·   "-T", "-B", "-l" and "-t" now work when stacked with other filetest
2177           operators [perl #77388].
2178
2179       ·   In 5.14.0, filetest ops ("-r", "-x", etc.) started calling FETCH on
2180           a tied argument belonging to the previous argument to a list
2181           operator, if called with a bareword argument or no argument at all.
2182           This has been fixed, so "push @foo, $tied, -r" no longer calls
2183           FETCH on $tied.
2184
2185       ·   In Perl 5.6, "-l" followed by anything other than a bareword would
2186           treat its argument as a file name.  That was changed in 5.8 for
2187           glob references ("\*foo"), but not for globs themselves (*foo).
2188           "-l" started returning "undef" for glob references without setting
2189           the last stat buffer that the "_" handle uses, but only if warnings
2190           were turned on.  With warnings off, it was the same as 5.6.  In
2191           other words, it was simply buggy and inconsistent.  Now the 5.6
2192           behavior has been restored.
2193
2194       ·   "-l" followed by a bareword no longer "eats" the previous argument
2195           to the list operator in whose argument list it resides.  Hence,
2196           "print "bar", -l foo" now actually prints "bar", because "-l" on
2197           longer eats it.
2198
2199       ·   Perl keeps several internal variables to keep track of the last
2200           stat buffer, from which file(handle) it originated, what type it
2201           was, and whether the last stat succeeded.
2202
2203           There were various cases where these could get out of synch,
2204           resulting in inconsistent or erratic behavior in edge cases (every
2205           mention of "-T" applies to "-B" as well):
2206
2207           ·   "-T HANDLE", even though it does a "stat", was not resetting
2208               the last stat type, so an "lstat _" following it would merrily
2209               return the wrong results.  Also, it was not setting the success
2210               status.
2211
2212           ·   Freeing the handle last used by "stat" or a filetest could
2213               result in "-T _" using an unrelated handle.
2214
2215           ·   "stat" with an IO reference would not reset the stat type or
2216               record the filehandle for "-T _" to use.
2217
2218           ·   Fatal warnings could cause the stat buffer not to be reset for
2219               a filetest operator on an unopened filehandle or "-l" on any
2220               handle.  Fatal warnings also stopped "-T" from setting $!.
2221
2222           ·   When the last stat was on an unreadable file, "-T _" is
2223               supposed to return "undef", leaving the last stat buffer
2224               unchanged.  But it was setting the stat type, causing "lstat _"
2225               to stop working.
2226
2227           ·   "-T FILENAME" was not resetting the internal stat buffers for
2228               unreadable files.
2229
2230           These have all been fixed.
2231
2232   Formats
2233       ·   Several edge cases have been fixed with formats and "formline"; in
2234           particular, where the format itself is potentially variable (such
2235           as with ties and overloading), and where the format and data differ
2236           in their encoding.  In both these cases, it used to possible for
2237           the output to be corrupted [perl #91032].
2238
2239       ·   "formline" no longer converts its argument into a string in-place.
2240           So passing a reference to "formline" no longer destroys the
2241           reference [perl #79532].
2242
2243       ·   Assignment to $^A (the format output accumulator) now recalculates
2244           the number of lines output.
2245
2246   "given" and "when"
2247       ·   "given" was not scoping its implicit $_ properly, resulting in
2248           memory leaks or "Variable is not available" warnings [perl #94682].
2249
2250       ·   "given" was not calling set-magic on the implicit lexical $_ that
2251           it uses.  This meant, for example, that "pos" would be remembered
2252           from one execution of the same "given" block to the next, even if
2253           the input were a different variable [perl #84526].
2254
2255       ·   "when" blocks are now capable of returning variables declared
2256           inside the enclosing "given" block [perl #93548].
2257
2258   The "glob" operator
2259       ·   On OSes other than VMS, Perl's "glob" operator (and the "<...>"
2260           form) use File::Glob underneath.  File::Glob splits the pattern
2261           into words, before feeding each word to its "bsd_glob" function.
2262
2263           There were several inconsistencies in the way the split was done.
2264           Now quotation marks (' and ") are always treated as shell-style
2265           word delimiters (that allow whitespace as part of a word) and
2266           backslashes are always preserved, unless they exist to escape
2267           quotation marks.  Before, those would only sometimes be the case,
2268           depending on whether the pattern contained whitespace.  Also,
2269           escaped whitespace at the end of the pattern is no longer stripped
2270           [perl #40470].
2271
2272       ·   "CORE::glob" now works as a way to call the default globbing
2273           function.  It used to respect overrides, despite the "CORE::"
2274           prefix.
2275
2276       ·   Under miniperl (used to configure modules when perl itself is
2277           built), "glob" now clears %ENV before calling csh, since the latter
2278           croaks on some systems if it does not like the contents of the
2279           LS_COLORS environment variable [perl #98662].
2280
2281   Lvalue subroutines
2282       ·   Explicit return now returns the actual argument passed to return,
2283           instead of copying it [perl #72724, #72706].
2284
2285       ·   Lvalue subroutines used to enforce lvalue syntax (i.e., whatever
2286           can go on the left-hand side of "=") for the last statement and the
2287           arguments to return.  Since lvalue subroutines are not always
2288           called in lvalue context, this restriction has been lifted.
2289
2290       ·   Lvalue subroutines are less restrictive about what values can be
2291           returned.  It used to croak on values returned by "shift" and
2292           "delete" and from other subroutines, but no longer does so [perl
2293           #71172].
2294
2295       ·   Empty lvalue subroutines ("sub :lvalue {}") used to return @_ in
2296           list context.  All subroutines used to do this, but regular subs
2297           were fixed in Perl 5.8.2.  Now lvalue subroutines have been
2298           likewise fixed.
2299
2300       ·   Autovivification now works on values returned from lvalue
2301           subroutines [perl #7946], as does returning "keys" in lvalue
2302           context.
2303
2304       ·   Lvalue subroutines used to copy their return values in rvalue
2305           context.  Not only was this a waste of CPU cycles, but it also
2306           caused bugs.  A "($)" prototype would cause an lvalue sub to copy
2307           its return value [perl #51408], and "while(lvalue_sub() =~ m/.../g)
2308           { ... }" would loop endlessly [perl #78680].
2309
2310       ·   When called in potential lvalue context (e.g., subroutine arguments
2311           or a list passed to "for"), lvalue subroutines used to copy any
2312           read-only value that was returned.  E.g., " sub :lvalue { $] } "
2313           would not return $], but a copy of it.
2314
2315       ·   When called in potential lvalue context, an lvalue subroutine
2316           returning arrays or hashes used to bind the arrays or hashes to
2317           scalar variables, resulting in bugs.  This was fixed in 5.14.0 if
2318           an array were the first thing returned from the subroutine (but not
2319           for "$scalar, @array" or hashes being returned).  Now a more
2320           general fix has been applied [perl #23790].
2321
2322       ·   Method calls whose arguments were all surrounded with "my()" or
2323           "our()" (as in "$object->method(my($a,$b))") used to force lvalue
2324           context on the subroutine.  This would prevent lvalue methods from
2325           returning certain values.
2326
2327       ·   Lvalue sub calls that are not determined to be such at compile time
2328           (&$name or &{"name"}) are no longer exempt from strict refs if they
2329           occur in the last statement of an lvalue subroutine [perl #102486].
2330
2331       ·   Sub calls whose subs are not visible at compile time, if they
2332           occurred in the last statement of an lvalue subroutine, would
2333           reject non-lvalue subroutines and die with "Can't modify non-lvalue
2334           subroutine call" [perl #102486].
2335
2336           Non-lvalue sub calls whose subs are visible at compile time
2337           exhibited the opposite bug.  If the call occurred in the last
2338           statement of an lvalue subroutine, there would be no error when the
2339           lvalue sub was called in lvalue context.  Perl would blindly assign
2340           to the temporary value returned by the non-lvalue subroutine.
2341
2342       ·   "AUTOLOAD" routines used to take precedence over the actual sub
2343           being called (i.e., when autoloading wasn't needed), for sub calls
2344           in lvalue or potential lvalue context, if the subroutine was not
2345           visible at compile time.
2346
2347       ·   Applying the ":lvalue" attribute to an XSUB or to an aliased
2348           subroutine stub with "sub foo :lvalue;" syntax stopped working in
2349           Perl 5.12.  This has been fixed.
2350
2351       ·   Applying the :lvalue attribute to subroutine that is already
2352           defined does not work properly, as the attribute changes the way
2353           the sub is compiled.  Hence, Perl 5.12 began warning when an
2354           attempt is made to apply the attribute to an already defined sub.
2355           In such cases, the attribute is discarded.
2356
2357           But the change in 5.12 missed the case where custom attributes are
2358           also present: that case still silently and ineffectively applied
2359           the attribute.  That omission has now been corrected.  "sub foo
2360           :lvalue :Whatever" (when "foo" is already defined) now warns about
2361           the :lvalue attribute, and does not apply it.
2362
2363       ·   A bug affecting lvalue context propagation through nested lvalue
2364           subroutine calls has been fixed.  Previously, returning a value in
2365           nested rvalue context would be treated as lvalue context by the
2366           inner subroutine call, resulting in some values (such as read-only
2367           values) being rejected.
2368
2369   Overloading
2370       ·   Arithmetic assignment ("$left += $right") involving overloaded
2371           objects that rely on the 'nomethod' override no longer segfault
2372           when the left operand is not overloaded.
2373
2374       ·   Errors that occur when methods cannot be found during overloading
2375           now mention the correct package name, as they did in 5.8.x, instead
2376           of erroneously mentioning the "overload" package, as they have
2377           since 5.10.0.
2378
2379       ·   Undefining %overload:: no longer causes a crash.
2380
2381   Prototypes of built-in keywords
2382       ·   The "prototype" function no longer dies for the "__FILE__",
2383           "__LINE__" and "__PACKAGE__" directives.  It now returns an empty-
2384           string prototype for them, because they are syntactically
2385           indistinguishable from nullary functions like "time".
2386
2387       ·   "prototype" now returns "undef" for all overridable infix
2388           operators, such as "eq", which are not callable in any way
2389           resembling functions.  It used to return incorrect prototypes for
2390           some and die for others [perl #94984].
2391
2392       ·   The prototypes of several built-in functions--"getprotobynumber",
2393           "lock", "not" and "select"--have been corrected, or at least are
2394           now closer to reality than before.
2395
2396   Regular expressions
2397       ·   "/[[:ascii:]]/" and "/[[:blank:]]/" now use locale rules under "use
2398           locale" when the platform supports that.  Previously, they used the
2399           platform's native character set.
2400
2401       ·   "m/[[:ascii:]]/i" and "/\p{ASCII}/i" now match identically (when
2402           not under a differing locale).  This fixes a regression introduced
2403           in 5.14 in which the first expression could match characters
2404           outside of ASCII, such as the KELVIN SIGN.
2405
2406       ·   "/.*/g" would sometimes refuse to match at the end of a string that
2407           ends with "\n".  This has been fixed [perl #109206].
2408
2409       ·   Starting with 5.12.0, Perl used to get its internal bookkeeping
2410           muddled up after assigning "${ qr// }" to a hash element and
2411           locking it with Hash::Util.  This could result in double frees,
2412           crashes, or erratic behavior.
2413
2414       ·   The new (in 5.14.0) regular expression modifier "/a" when repeated
2415           like "/aa" forbids the characters outside the ASCII range that
2416           match characters inside that range from matching under "/i".  This
2417           did not work under some circumstances, all involving alternation,
2418           such as:
2419
2420            "\N{KELVIN SIGN}" =~ /k|foo/iaa;
2421
2422           succeeded inappropriately.  This is now fixed.
2423
2424       ·   5.14.0 introduced some memory leaks in regular expression character
2425           classes such as "[\w\s]", which have now been fixed. (5.14.1)
2426
2427       ·   An edge case in regular expression matching could potentially loop.
2428           This happened only under "/i" in bracketed character classes that
2429           have characters with multi-character folds, and the target string
2430           to match against includes the first portion of the fold, followed
2431           by another character that has a multi-character fold that begins
2432           with the remaining portion of the fold, plus some more.
2433
2434            "s\N{U+DF}" =~ /[\x{DF}foo]/i
2435
2436           is one such case.  "\xDF" folds to "ss". (5.14.1)
2437
2438       ·   A few characters in regular expression pattern matches did not
2439           match correctly in some circumstances, all involving "/i".  The
2440           affected characters are: COMBINING GREEK YPOGEGRAMMENI, GREEK
2441           CAPITAL LETTER IOTA, GREEK CAPITAL LETTER UPSILON, GREEK
2442           PROSGEGRAMMENI, GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
2443           GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS, GREEK SMALL
2444           LETTER UPSILON WITH DIALYTIKA AND OXIA, GREEK SMALL LETTER UPSILON
2445           WITH DIALYTIKA AND TONOS, LATIN SMALL LETTER LONG S, LATIN SMALL
2446           LIGATURE LONG S T, and LATIN SMALL LIGATURE ST.
2447
2448       ·   A memory leak regression in regular expression compilation under
2449           threading has been fixed.
2450
2451       ·   A regression introduced in 5.14.0 has been fixed.  This involved an
2452           inverted bracketed character class in a regular expression that
2453           consisted solely of a Unicode property.  That property wasn't
2454           getting inverted outside the Latin1 range.
2455
2456       ·   Three problematic Unicode characters now work better in regex
2457           pattern matching under "/i".
2458
2459           In the past, three Unicode characters: LATIN SMALL LETTER SHARP S,
2460           GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS, and GREEK SMALL
2461           LETTER UPSILON WITH DIALYTIKA AND TONOS, along with the sequences
2462           that they fold to (including "ss" for LATIN SMALL LETTER SHARP S),
2463           did not properly match under "/i".  5.14.0 fixed some of these
2464           cases, but introduced others, including a panic when one of the
2465           characters or sequences was used in the "(?(DEFINE)" regular
2466           expression predicate.  The known bugs that were introduced in 5.14
2467           have now been fixed; as well as some other edge cases that have
2468           never worked until now.  These all involve using the characters and
2469           sequences outside bracketed character classes under "/i".  This
2470           closes [perl #98546].
2471
2472           There remain known problems when using certain characters with
2473           multi-character folds inside bracketed character classes, including
2474           such constructs as "qr/[\N{LATIN SMALL LETTER SHARP}a-z]/i".  These
2475           remaining bugs are addressed in [perl #89774].
2476
2477       ·   RT #78266: The regex engine has been leaking memory when accessing
2478           named captures that weren't matched as part of a regex ever since
2479           5.10 when they were introduced; e.g., this would consume over a
2480           hundred MB of memory:
2481
2482               for (1..10_000_000) {
2483                   if ("foo" =~ /(foo|(?<capture>bar))?/) {
2484                       my $capture = $+{capture}
2485                   }
2486               }
2487               system "ps -o rss $$"'
2488
2489       ·   In 5.14, "/[[:lower:]]/i" and "/[[:upper:]]/i" no longer matched
2490           the opposite case.  This has been fixed [perl #101970].
2491
2492       ·   A regular expression match with an overloaded object on the right-
2493           hand side would sometimes stringify the object too many times.
2494
2495       ·   A regression has been fixed that was introduced in 5.14, in "/i"
2496           regular expression matching, in which a match improperly fails if
2497           the pattern is in UTF-8, the target string is not, and a Latin-1
2498           character precedes a character in the string that should match the
2499           pattern.  [perl #101710]
2500
2501       ·   In case-insensitive regular expression pattern matching, no longer
2502           on UTF-8 encoded strings does the scan for the start of match look
2503           only at the first possible position.  This caused matches such as
2504           ""f\x{FB00}" =~ /ff/i" to fail.
2505
2506       ·   The regexp optimizer no longer crashes on debugging builds when
2507           merging fixed-string nodes with inconvenient contents.
2508
2509       ·   A panic involving the combination of the regular expression
2510           modifiers "/aa" and the "\b" escape sequence introduced in 5.14.0
2511           has been fixed [perl #95964]. (5.14.2)
2512
2513       ·   The combination of the regular expression modifiers "/aa" and the
2514           "\b" and "\B" escape sequences did not work properly on UTF-8
2515           encoded strings.  All non-ASCII characters under "/aa" should be
2516           treated as non-word characters, but what was happening was that
2517           Unicode rules were used to determine wordness/non-wordness for non-
2518           ASCII characters.  This is now fixed [perl #95968].
2519
2520       ·   "(?foo: ...)" no longer loses passed in character set.
2521
2522       ·   The trie optimization used to have problems with alternations
2523           containing an empty "(?:)", causing ""x" =~
2524           /\A(?>(?:(?:)A|B|C?x))\z/" not to match, whereas it should [perl
2525           #111842].
2526
2527       ·   Use of lexical ("my") variables in code blocks embedded in regular
2528           expressions will no longer result in memory corruption or crashes.
2529
2530           Nevertheless, these code blocks are still experimental, as there
2531           are still problems with the wrong variables being closed over (in
2532           loops for instance) and with abnormal exiting (e.g., "die") causing
2533           memory corruption.
2534
2535       ·   The "\h", "\H", "\v" and "\V" regular expression metacharacters
2536           used to cause a panic error message when trying to match at the end
2537           of the string [perl #96354].
2538
2539       ·   The abbreviations for four C1 control characters "MW" "PM", "RI",
2540           and "ST" were previously unrecognized by "\N{}", vianame(), and
2541           string_vianame().
2542
2543       ·   Mentioning a variable named "&" other than $& (i.e., "@&" or "%&")
2544           no longer stops $& from working.  The same applies to variables
2545           named "'" and "`" [perl #24237].
2546
2547       ·   Creating a "UNIVERSAL::AUTOLOAD" sub no longer stops "%+", "%-" and
2548           "%!" from working some of the time [perl #105024].
2549
2550   Smartmatching
2551       ·   "~~" now correctly handles the precedence of Any~~Object, and is
2552           not tricked by an overloaded object on the left-hand side.
2553
2554       ·   In Perl 5.14.0, "$tainted ~~ @array" stopped working properly.
2555           Sometimes it would erroneously fail (when $tainted contained a
2556           string that occurs in the array after the first element) or
2557           erroneously succeed (when "undef" occurred after the first element)
2558           [perl #93590].
2559
2560   The "sort" operator
2561       ·   "sort" was not treating "sub {}" and "sub {()}" as equivalent when
2562           such a sub was provided as the comparison routine.  It used to
2563           croak on "sub {()}".
2564
2565       ·   "sort" now works once more with custom sort routines that are
2566           XSUBs.  It stopped working in 5.10.0.
2567
2568       ·   "sort" with a constant for a custom sort routine, although it
2569           produces unsorted results, no longer crashes.  It started crashing
2570           in 5.10.0.
2571
2572       ·   Warnings emitted by "sort" when a custom comparison routine returns
2573           a non-numeric value now contain "in sort" and show the line number
2574           of the "sort" operator, rather than the last line of the comparison
2575           routine.  The warnings also now occur only if warnings are enabled
2576           in the scope where "sort" occurs.  Previously the warnings would
2577           occur if enabled in the comparison routine's scope.
2578
2579       ·   "sort { $a <=> $b }", which is optimized internally, now produces
2580           "uninitialized" warnings for NaNs (not-a-number values), since
2581           "<=>" returns "undef" for those.  This brings it in line with
2582           "sort { 1; $a <=> $b }" and other more complex cases, which are not
2583           optimized [perl #94390].
2584
2585   The "substr" operator
2586       ·   Tied (and otherwise magical) variables are no longer exempt from
2587           the "Attempt to use reference as lvalue in substr" warning.
2588
2589       ·   That warning now occurs when the returned lvalue is assigned to,
2590           not when "substr" itself is called.  This makes a difference only
2591           if the return value of "substr" is referenced and later assigned
2592           to.
2593
2594       ·   Passing a substring of a read-only value or a typeglob to a
2595           function (potential lvalue context) no longer causes an immediate
2596           "Can't coerce" or "Modification of a read-only value" error.  That
2597           error occurs only if the passed value is assigned to.
2598
2599           The same thing happens with the "substr outside of string" error.
2600           If the lvalue is only read from, not written to, it is now just a
2601           warning, as with rvalue "substr".
2602
2603       ·   "substr" assignments no longer call FETCH twice if the first
2604           argument is a tied variable, just once.
2605
2606   Support for embedded nulls
2607       Some parts of Perl did not work correctly with nulls ("chr 0") embedded
2608       in strings.  That meant that, for instance, "$m = "a\0b"; foo->$m"
2609       would call the "a" method, instead of the actual method name contained
2610       in $m.  These parts of perl have been fixed to support nulls:
2611
2612       ·   Method names
2613
2614       ·   Typeglob names (including filehandle and subroutine names)
2615
2616       ·   Package names, including the return value of "ref()"
2617
2618       ·   Typeglob elements (*foo{"THING\0stuff"})
2619
2620       ·   Signal names
2621
2622       ·   Various warnings and error messages that mention variable names or
2623           values, methods, etc.
2624
2625       One side effect of these changes is that blessing into "\0" no longer
2626       causes "ref()" to return false.
2627
2628   Threading bugs
2629       ·   Typeglobs returned from threads are no longer cloned if the parent
2630           thread already has a glob with the same name.  This means that
2631           returned subroutines will now assign to the right package variables
2632           [perl #107366].
2633
2634       ·   Some cases of threads crashing due to memory allocation during
2635           cloning have been fixed [perl #90006].
2636
2637       ·   Thread joining would sometimes emit "Attempt to free unreferenced
2638           scalar" warnings if "caller" had been used from the "DB" package
2639           before thread creation [perl #98092].
2640
2641       ·   Locking a subroutine (via "lock &sub") is no longer a compile-time
2642           error for regular subs.  For lvalue subroutines, it no longer tries
2643           to return the sub as a scalar, resulting in strange side effects
2644           like "ref \$_" returning "CODE" in some instances.
2645
2646           "lock &sub" is now a run-time error if threads::shared is loaded (a
2647           no-op otherwise), but that may be rectified in a future version.
2648
2649   Tied variables
2650       ·   Various cases in which FETCH was being ignored or called too many
2651           times have been fixed:
2652
2653           ·   "PerlIO::get_layers" [perl #97956]
2654
2655           ·   "$tied =~ y/a/b/", "chop $tied" and "chomp $tied" when $tied
2656               holds a reference.
2657
2658           ·   When calling "local $_" [perl #105912]
2659
2660           ·   Four-argument "select"
2661
2662           ·   A tied buffer passed to "sysread"
2663
2664           ·   "$tied .= <>"
2665
2666           ·   Three-argument "open", the third being a tied file handle (as
2667               in "open $fh, ">&", $tied")
2668
2669           ·   "sort" with a reference to a tied glob for the comparison
2670               routine.
2671
2672           ·   ".." and "..." in list context [perl #53554].
2673
2674           ·   "${$tied}", "@{$tied}", "%{$tied}" and "*{$tied}" where the
2675               tied variable returns a string ("&{}" was unaffected)
2676
2677           ·   "defined ${ $tied_variable }"
2678
2679           ·   Various functions that take a filehandle argument in rvalue
2680               context ("close", "readline", etc.) [perl #97482]
2681
2682           ·   Some cases of dereferencing a complex expression, such as "${
2683               (), $tied } = 1", used to call "FETCH" multiple times, but now
2684               call it once.
2685
2686           ·   "$tied->method" where $tied returns a package name--even
2687               resulting in a failure to call the method, due to memory
2688               corruption
2689
2690           ·   Assignments like "*$tied = \&{"..."}" and "*glob = $tied"
2691
2692           ·   "chdir", "chmod", "chown", "utime", "truncate", "stat", "lstat"
2693               and the filetest ops ("-r", "-x", etc.)
2694
2695       ·   "caller" sets @DB::args to the subroutine arguments when called
2696           from the DB package.  It used to crash when doing so if @DB::args
2697           happened to be tied.  Now it croaks instead.
2698
2699       ·   Tying an element of %ENV or "%^H" and then deleting that element
2700           would result in a call to the tie object's DELETE method, even
2701           though tying the element itself is supposed to be equivalent to
2702           tying a scalar (the element is, of course, a scalar) [perl #67490].
2703
2704       ·   When Perl autovivifies an element of a tied array or hash (which
2705           entails calling STORE with a new reference), it now calls FETCH
2706           immediately after the STORE, instead of assuming that FETCH would
2707           have returned the same reference.  This can make it easier to
2708           implement tied objects [perl #35865, #43011].
2709
2710       ·   Four-argument "select" no longer produces its "Non-string passed as
2711           bitmask" warning on tied or tainted variables that are strings.
2712
2713       ·   Localizing a tied scalar that returns a typeglob no longer stops it
2714           from being tied till the end of the scope.
2715
2716       ·   Attempting to "goto" out of a tied handle method used to cause
2717           memory corruption or crashes.  Now it produces an error message
2718           instead [perl #8611].
2719
2720       ·   A bug has been fixed that occurs when a tied variable is used as a
2721           subroutine reference:  if the last thing assigned to or returned
2722           from the variable was a reference or typeglob, the "\&$tied" could
2723           either crash or return the wrong subroutine.  The reference case is
2724           a regression introduced in Perl 5.10.0.  For typeglobs, it has
2725           probably never worked till now.
2726
2727   Version objects and vstrings
2728       ·   The bitwise complement operator (and possibly other operators, too)
2729           when passed a vstring would leave vstring magic attached to the
2730           return value, even though the string had changed.  This meant that
2731           "version->new(~v1.2.3)" would create a version looking like
2732           "v1.2.3" even though the string passed to "version->new" was
2733           actually "\376\375\374".  This also caused B::Deparse to deparse
2734           "~v1.2.3" incorrectly, without the "~" [perl #29070].
2735
2736       ·   Assigning a vstring to a magic (e.g., tied, $!) variable and then
2737           assigning something else used to blow away all magic.  This meant
2738           that tied variables would come undone, $! would stop getting
2739           updated on failed system calls, $| would stop setting autoflush,
2740           and other mischief would take place.  This has been fixed.
2741
2742       ·   "version->new("version")" and "printf "%vd", "version"" no longer
2743           crash [perl #102586].
2744
2745       ·   Version comparisons, such as those that happen implicitly with "use
2746           v5.43", no longer cause locale settings to change [perl #105784].
2747
2748       ·   Version objects no longer cause memory leaks in boolean context
2749           [perl #109762].
2750
2751   Warnings, redefinition
2752       ·   Subroutines from the "autouse" namespace are once more exempt from
2753           redefinition warnings.  This used to work in 5.005, but was broken
2754           in 5.6 for most subroutines.  For subs created via XS that redefine
2755           subroutines from the "autouse" package, this stopped working in
2756           5.10.
2757
2758       ·   New XSUBs now produce redefinition warnings if they overwrite
2759           existing subs, as they did in 5.8.x.  (The "autouse" logic was
2760           reversed in 5.10-14.  Only subroutines from the "autouse" namespace
2761           would warn when clobbered.)
2762
2763       ·   "newCONSTSUB" used to use compile-time warning hints, instead of
2764           run-time hints.  The following code should never produce a
2765           redefinition warning, but it used to, if "newCONSTSUB" redefined an
2766           existing subroutine:
2767
2768               use warnings;
2769               BEGIN {
2770                   no warnings;
2771                   some_XS_function_that_calls_new_CONSTSUB();
2772               }
2773
2774       ·   Redefinition warnings for constant subroutines are on by default
2775           (what are known as severe warnings in perldiag).  This occurred
2776           only when it was a glob assignment or declaration of a Perl
2777           subroutine that caused the warning.  If the creation of XSUBs
2778           triggered the warning, it was not a default warning.  This has been
2779           corrected.
2780
2781       ·   The internal check to see whether a redefinition warning should
2782           occur used to emit "uninitialized" warnings in cases like this:
2783
2784               use warnings "uninitialized";
2785               use constant {u => undef, v => undef};
2786               sub foo(){u}
2787               sub foo(){v}
2788
2789   Warnings, "Uninitialized"
2790       ·   Various functions that take a filehandle argument in rvalue context
2791           ("close", "readline", etc.) used to warn twice for an undefined
2792           handle [perl #97482].
2793
2794       ·   "dbmopen" now only warns once, rather than three times, if the mode
2795           argument is "undef" [perl #90064].
2796
2797       ·   The "+=" operator does not usually warn when the left-hand side is
2798           "undef", but it was doing so for tied variables.  This has been
2799           fixed [perl #44895].
2800
2801       ·   A bug fix in Perl 5.14 introduced a new bug, causing
2802           "uninitialized" warnings to report the wrong variable if the
2803           operator in question had two operands and one was "%{...}" or
2804           "@{...}".  This has been fixed [perl #103766].
2805
2806       ·   ".." and "..." in list context now mention the name of the variable
2807           in "uninitialized" warnings for string (as opposed to numeric)
2808           ranges.
2809
2810   Weak references
2811       ·   Weakening the first argument to an automatically-invoked "DESTROY"
2812           method could result in erroneous "DESTROY created new reference"
2813           errors or crashes.  Now it is an error to weaken a read-only
2814           reference.
2815
2816       ·   Weak references to lexical hashes going out of scope were not going
2817           stale (becoming undefined), but continued to point to the hash.
2818
2819       ·   Weak references to lexical variables going out of scope are now
2820           broken before any magical methods (e.g., DESTROY on a tie object)
2821           are called.  This prevents such methods from modifying the variable
2822           that will be seen the next time the scope is entered.
2823
2824       ·   Creating a weak reference to an @ISA array or accessing the array
2825           index ($#ISA) could result in confused internal bookkeeping for
2826           elements later added to the @ISA array.  For instance, creating a
2827           weak reference to the element itself could push that weak reference
2828           on to @ISA; and elements added after use of $#ISA would be ignored
2829           by method lookup [perl #85670].
2830
2831   Other notable fixes
2832       ·   "quotemeta" now quotes consistently the same non-ASCII characters
2833           under "use feature 'unicode_strings'", regardless of whether the
2834           string is encoded in UTF-8 or not, hence fixing the last vestiges
2835           (we hope) of the notorious "The "Unicode Bug"" in perlunicode.
2836           [perl #77654].
2837
2838           Which of these code points is quoted has changed, based on
2839           Unicode's recommendations.  See "quotemeta" in perlfunc for
2840           details.
2841
2842       ·   "study" is now a no-op, presumably fixing all outstanding bugs
2843           related to study causing regex matches to behave incorrectly!
2844
2845       ·   When one writes "open foo || die", which used to work in Perl 4, a
2846           "Precedence problem" warning is produced.  This warning used
2847           erroneously to apply to fully-qualified bareword handle names not
2848           followed by "||".  This has been corrected.
2849
2850       ·   After package aliasing ("*foo:: = *bar::"), "select" with 0 or 1
2851           argument would sometimes return a name that could not be used to
2852           refer to the filehandle, or sometimes it would return "undef" even
2853           when a filehandle was selected.  Now it returns a typeglob
2854           reference in such cases.
2855
2856       ·   "PerlIO::get_layers" no longer ignores some arguments that it
2857           thinks are numeric, while treating others as filehandle names.  It
2858           is now consistent for flat scalars (i.e., not references).
2859
2860       ·   Unrecognized switches on "#!" line
2861
2862           If a switch, such as -x, that cannot occur on the "#!" line is used
2863           there, perl dies with "Can't emulate...".
2864
2865           It used to produce the same message for switches that perl did not
2866           recognize at all, whether on the command line or the "#!" line.
2867
2868           Now it produces the "Unrecognized switch" error message [perl
2869           #104288].
2870
2871       ·   "system" now temporarily blocks the SIGCHLD signal handler, to
2872           prevent the signal handler from stealing the exit status [perl
2873           #105700].
2874
2875       ·   The %n formatting code for "printf" and "sprintf", which causes the
2876           number of characters to be assigned to the next argument, now
2877           actually assigns the number of characters, instead of the number of
2878           bytes.
2879
2880           It also works now with special lvalue functions like "substr" and
2881           with nonexistent hash and array elements [perl #3471, #103492].
2882
2883       ·   Perl skips copying values returned from a subroutine, for the sake
2884           of speed, if doing so would make no observable difference.  Because
2885           of faulty logic, this would happen with the result of "delete",
2886           "shift" or "splice", even if the result was referenced elsewhere.
2887           It also did so with tied variables about to be freed [perl #91844,
2888           #95548].
2889
2890       ·   "utf8::decode" now refuses to modify read-only scalars [perl
2891           #91850].
2892
2893       ·   Freeing $_ inside a "grep" or "map" block, a code block embedded in
2894           a regular expression, or an @INC filter (a subroutine returned by a
2895           subroutine in @INC) used to result in double frees or crashes [perl
2896           #91880, #92254, #92256].
2897
2898       ·   "eval" returns "undef" in scalar context or an empty list in list
2899           context when there is a run-time error.  When "eval" was passed a
2900           string in list context and a syntax error occurred, it used to
2901           return a list containing a single undefined element.  Now it
2902           returns an empty list in list context for all errors [perl #80630].
2903
2904       ·   "goto &func" no longer crashes, but produces an error message, when
2905           the unwinding of the current subroutine's scope fires a destructor
2906           that undefines the subroutine being "goneto" [perl #99850].
2907
2908       ·   Perl now holds an extra reference count on the package that code is
2909           currently compiling in.  This means that the following code no
2910           longer crashes [perl #101486]:
2911
2912               package Foo;
2913               BEGIN {*Foo:: = *Bar::}
2914               sub foo;
2915
2916       ·   The "x" repetition operator no longer crashes on 64-bit builds with
2917           large repeat counts [perl #94560].
2918
2919       ·   Calling "require" on an implicit $_ when *CORE::GLOBAL::require has
2920           been overridden does not segfault anymore, and $_ is now passed to
2921           the overriding subroutine [perl #78260].
2922
2923       ·   "use" and "require" are no longer affected by the I/O layers active
2924           in the caller's scope (enabled by open.pm) [perl #96008].
2925
2926       ·   "our $::e; $e" (which is invalid) no longer produces the
2927           "Compilation error at lib/utf8_heavy.pl..." error message, which it
2928           started emitting in 5.10.0 [perl #99984].
2929
2930       ·   On 64-bit systems, "read()" now understands large string offsets
2931           beyond the 32-bit range.
2932
2933       ·   Errors that occur when processing subroutine attributes no longer
2934           cause the subroutine's op tree to leak.
2935
2936       ·   Passing the same constant subroutine to both "index" and "formline"
2937           no longer causes one or the other to fail [perl #89218]. (5.14.1)
2938
2939       ·   List assignment to lexical variables declared with attributes in
2940           the same statement ("my ($x,@y) : blimp = (72,94)") stopped working
2941           in Perl 5.8.0.  It has now been fixed.
2942
2943       ·   Perl 5.10.0 introduced some faulty logic that made "U*" in the
2944           middle of a pack template equivalent to "U0" if the input string
2945           was empty.  This has been fixed [perl #90160]. (5.14.2)
2946
2947       ·   Destructors on objects were not called during global destruction on
2948           objects that were not referenced by any scalars.  This could happen
2949           if an array element were blessed (e.g., "bless \$a[0]") or if a
2950           closure referenced a blessed variable ("bless \my @a; sub foo { @a
2951           }").
2952
2953           Now there is an extra pass during global destruction to fire
2954           destructors on any objects that might be left after the usual
2955           passes that check for objects referenced by scalars [perl #36347].
2956
2957       ·   Fixed a case where it was possible that a freed buffer may have
2958           been read from when parsing a here document [perl #90128]. (5.14.1)
2959
2960       ·   "each(ARRAY)" is now wrapped in "defined(...)", like "each(HASH)",
2961           inside a "while" condition [perl #90888].
2962
2963       ·   A problem with context propagation when a "do" block is an argument
2964           to "return" has been fixed.  It used to cause "undef" to be
2965           returned in certain cases of a "return" inside an "if" block which
2966           itself is followed by another "return".
2967
2968       ·   Calling "index" with a tainted constant no longer causes constants
2969           in subsequently compiled code to become tainted [perl #64804].
2970
2971       ·   Infinite loops like "1 while 1" used to stop "strict 'subs'" mode
2972           from working for the rest of the block.
2973
2974       ·   For list assignments like "($a,$b) = ($b,$a)", Perl has to make a
2975           copy of the items on the right-hand side before assignment them to
2976           the left.  For efficiency's sake, it assigns the values on the
2977           right straight to the items on the left if no one variable is
2978           mentioned on both sides, as in "($a,$b) = ($c,$d)".  The logic for
2979           determining when it can cheat was faulty, in that "&&" and "||" on
2980           the right-hand side could fool it.  So "($a,$b) = $some_true_value
2981           && ($b,$a)" would end up assigning the value of $b to both scalars.
2982
2983       ·   Perl no longer tries to apply lvalue context to the string in
2984           "("string", $variable) ||= 1" (which used to be an error).  Since
2985           the left-hand side of "||=" is evaluated in scalar context, that's
2986           a scalar comma operator, which gives all but the last item void
2987           context.  There is no such thing as void lvalue context, so it was
2988           a mistake for Perl to try to force it [perl #96942].
2989
2990       ·   "caller" no longer leaks memory when called from the DB package if
2991           @DB::args was assigned to after the first call to "caller".  Carp
2992           was triggering this bug [perl #97010]. (5.14.2)
2993
2994       ·   "close" and similar filehandle functions, when called on built-in
2995           global variables (like $+), used to die if the variable happened to
2996           hold the undefined value, instead of producing the usual "Use of
2997           uninitialized value" warning.
2998
2999       ·   When autovivified file handles were introduced in Perl 5.6.0,
3000           "readline" was inadvertently made to autovivify when called as
3001           "readline($foo)" (but not as "<$foo>").  It has now been fixed
3002           never to autovivify.
3003
3004       ·   Calling an undefined anonymous subroutine (e.g., what $x holds
3005           after "undef &{$x = sub{}}") used to cause a "Not a CODE reference"
3006           error, which has been corrected to "Undefined subroutine called"
3007           [perl #71154].
3008
3009       ·   Causing @DB::args to be freed between uses of "caller" no longer
3010           results in a crash [perl #93320].
3011
3012       ·   "setpgrp($foo)" used to be equivalent to "($foo, setpgrp)", because
3013           "setpgrp" was ignoring its argument if there was just one.  Now it
3014           is equivalent to "setpgrp($foo,0)".
3015
3016       ·   "shmread" was not setting the scalar flags correctly when reading
3017           from shared memory, causing the existing cached numeric
3018           representation in the scalar to persist [perl #98480].
3019
3020       ·   "++" and "--" now work on copies of globs, instead of dying.
3021
3022       ·   "splice()" doesn't warn when truncating
3023
3024           You can now limit the size of an array using "splice(@a,MAX_LEN)"
3025           without worrying about warnings.
3026
3027       ·   $$ is no longer tainted.  Since this value comes directly from
3028           "getpid()", it is always safe.
3029
3030       ·   The parser no longer leaks a filehandle if STDIN was closed before
3031           parsing started [perl #37033].
3032
3033       ·   "die;" with a non-reference, non-string, or magical (e.g., tainted)
3034           value in $@ now properly propagates that value [perl #111654].
3035

Known Problems

3037       ·   On Solaris, we have two kinds of failure.
3038
3039           If make is Sun's make, we get an error about a badly formed macro
3040           assignment in the Makefile.  That happens when ./Configure tries to
3041           make depends.  Configure then exits 0, but further make-ing fails.
3042
3043           If make is gmake, Configure completes, then we get errors related
3044           to /usr/include/stdbool.h
3045
3046       ·   On Win32, a number of tests hang unless STDERR is redirected.  The
3047           cause of this is still under investigation.
3048
3049       ·   When building as root with a umask that prevents files from being
3050           other-readable, t/op/filetest.t will fail.  This is a test bug, not
3051           a bug in perl's behavior.
3052
3053       ·   Configuring with a recent gcc and link-time-optimization, such as
3054           "Configure -Doptimize='-O2 -flto'" fails because the optimizer
3055           optimizes away some of Configure's tests.  A workaround is to omit
3056           the "-flto" flag when running Configure, but add it back in while
3057           actually building, something like
3058
3059               sh Configure -Doptimize=-O2
3060               make OPTIMIZE='-O2 -flto'
3061
3062       ·   The following CPAN modules have test failures with perl 5.16.
3063           Patches have been submitted for all of these, so hopefully there
3064           will be new releases soon:
3065
3066           ·   Date::Pcalc version 6.1
3067
3068           ·   Module::CPANTS::Analyse version 0.85
3069
3070               This fails due to problems in Module::Find 0.10 and
3071               File::MMagic 1.27.
3072
3073           ·   PerlIO::Util version 0.72
3074

Acknowledgements

3076       Perl 5.16.0 represents approximately 12 months of development since
3077       Perl 5.14.0 and contains approximately 590,000 lines of changes across
3078       2,500 files from 139 authors.
3079
3080       Perl continues to flourish into its third decade thanks to a vibrant
3081       community of users and developers.  The following people are known to
3082       have contributed the improvements that became Perl 5.16.0:
3083
3084       Aaron Crane, Abhijit Menon-Sen, Abigail, Alan Haggai Alavi, Alberto
3085       Simo~es, Alexandr Ciornii, Andreas Koenig, Andy Dougherty, Aristotle
3086       Pagaltzis, Bo Johansson, Bo Lindbergh, Breno G. de Oliveira, brian d
3087       foy, Brian Fraser, Brian Greenfield, Carl Hayter, Chas. Owens, Chia-
3088       liang Kao, Chip Salzenberg, Chris 'BinGOs' Williams, Christian Hansen,
3089       Christopher J. Madsen, chromatic, Claes Jacobsson, Claudio Ramirez,
3090       Craig A. Berry, Damian Conway, Daniel Kahn Gillmor, Darin McBride, Dave
3091       Rolsky, David Cantrell, David Golden, David Leadbeater, David Mitchell,
3092       Dee Newcum, Dennis Kaarsemaker, Dominic Hargreaves, Douglas Christopher
3093       Wilson, Eric Brine, Father Chrysostomos, Florian Ragwitz, Frederic
3094       Briere, George Greer, Gerard Goossen, Gisle Aas, H.Merijn Brand, Hojung
3095       Youn, Ian Goodacre, James E Keenan, Jan Dubois, Jerry D. Hedden, Jesse
3096       Luehrs, Jesse Vincent, Jilles Tjoelker, Jim Cromie, Jim Meyering, Joel
3097       Berger, Johan Vromans, Johannes Plunien, John Hawkinson, John P.
3098       Linderman, John Peacock, Joshua ben Jore, Juerd Waalboer, Karl
3099       Williamson, Karthik Rajagopalan, Keith Thompson, Kevin J.  Woolley,
3100       Kevin Ryde, Laurent Dami, Leo Lapworth, Leon Brocard, Leon Timmermans,
3101       Louis Strous, Lukas Mai, Marc Green, Marcel Gruenauer, Mark A.
3102       Stratman, Mark Dootson, Mark Jason Dominus, Martin Hasch, Matthew
3103       Horsfall, Max Maischein, Michael G Schwern, Michael Witten, Mike
3104       Sheldrake, Moritz Lenz, Nicholas Clark, Niko Tyni, Nuno Carvalho, Pau
3105       Amma, Paul Evans, Paul Green, Paul Johnson, Perlover, Peter John
3106       Acklam, Peter Martini, Peter Scott, Phil Monsen, Pino Toscano, Rafael
3107       Garcia-Suarez, Rainer Tammer, Reini Urban, Ricardo Signes, Robin
3108       Barker, Rodolfo Carvalho, Salvador Fandin~o, Sam Kimbrel, Samuel
3109       Thibault, Shawn M Moore, Shigeya Suzuki, Shirakata Kentaro, Shlomi
3110       Fish, Sisyphus, Slaven Rezic, Spiros Denaxas, Steffen Mueller, Steffen
3111       Schwigon, Stephen Bennett, Stephen Oberholtzer, Stevan Little, Steve
3112       Hay, Steve Peters, Thomas Sibley, Thorsten Glaser, Timothe Litt, Todd
3113       Rinaldo, Tom Christiansen, Tom Hukins, Tony Cook, Vadim Konovalov,
3114       Vincent Pit, Vladimir Timofeev, Walt Mankowski, Yves Orton, Zefram,
3115       Zsban Ambrus, AEvar Arnfjoerd` Bjarmason.
3116
3117       The list above is almost certainly incomplete as it is automatically
3118       generated from version control history.  In particular, it does not
3119       include the names of the (very much appreciated) contributors who
3120       reported issues to the Perl bug tracker.
3121
3122       Many of the changes included in this version originated in the CPAN
3123       modules included in Perl's core.  We're grateful to the entire CPAN
3124       community for helping Perl to flourish.
3125
3126       For a more complete list of all of Perl's historical contributors,
3127       please see the AUTHORS file in the Perl source distribution.
3128

Reporting Bugs

3130       If you find what you think is a bug, you might check the articles
3131       recently posted to the comp.lang.perl.misc newsgroup and the perl bug
3132       database at <http://rt.perl.org/perlbug/>.  There may also be
3133       information at <http://www.perl.org/>, the Perl Home Page.
3134
3135       If you believe you have an unreported bug, please run the perlbug
3136       program included with your release.  Be sure to trim your bug down to a
3137       tiny but sufficient test case.  Your bug report, along with the output
3138       of "perl -V", will be sent off to perlbug@perl.org to be analysed by
3139       the Perl porting team.
3140
3141       If the bug you are reporting has security implications, which make it
3142       inappropriate to send to a publicly archived mailing list, then please
3143       send it to perl5-security-report@perl.org.  This points to a closed
3144       subscription unarchived mailing list, which includes all core
3145       committers, who will be able to help assess the impact of issues,
3146       figure out a resolution, and help co-ordinate the release of patches to
3147       mitigate or fix the problem across all platforms on which Perl is
3148       supported.  Please use this address only for security issues in the
3149       Perl core, not for modules independently distributed on CPAN.
3150

SEE ALSO

3152       The Changes file for an explanation of how to view exhaustive details
3153       on what changed.
3154
3155       The INSTALL file for how to build Perl.
3156
3157       The README file for general stuff.
3158
3159       The Artistic and Copying files for copyright information.
3160
3161
3162
3163perl v5.26.3                      2018-03-01                  PERL5160DELTA(1)
Impressum