ddf362c739d6ca0529f85d2a8ec37d98e4980819
[perl.git] / Porting / perl5160delta.pod
1 =encoding utf8
2
3 =head1 NAME
4
5 perl5160delta - what is new for perl v5.16.0
6
7 =head1 DESCRIPTION
8
9 This document describes differences between the 5.14.0 release and
10 the 5.16.0 release.
11
12 If you are upgrading from an earlier release such as 5.12.0, first read
13 L<perl5140delta>, which describes differences between 5.12.0 and
14 5.14.0.
15
16 =head1 Notice
17
18 XXX Any important notices here
19
20 =head1 Core Enhancements
21
22 =head2 C<use I<VERSION>>
23
24 As of this release, version declarations like C<use v5.16> now disable
25 all features before enabling the new feature bundle.  This means that
26 the following holds true:
27
28     use 5.016;
29     # only 5.16 features enabled here
30     use 5.014;
31     # only 5.14 features enabled here (not 5.16)
32
33 C<use v5.12> and higher continue to enable strict, but explicit C<use
34 strict> and C<no strict> now override the version declaration, even
35 when they come first:
36
37     no strict;
38     use 5.012;
39     # no strict here
40
41 There is a new ":default" feature bundle that represents the set of
42 features enabled before any version declaration or C<use feature> has
43 been seen.  Version declarations below 5.10 now enable the ":default"
44 feature set.  This does not actually change the behaviour of C<use
45 v5.8>, because features added to the ":default" set are those that were
46 traditionally enabled by default, before they could be turned off.
47
48 C<< no feature >> now resets to the default feature set.  To disable all
49 features (which is likely to be a pretty special-purpose request, since
50 it presumably won't match any named set of semantics) you can now  
51 write C<< no feature ':all' >>.
52
53 C<$[> is now disabled under C<use v5.16>.  It is part of the default
54 feature set and can be turned on or off explicitly with C<use feature
55 'array_base'>.
56
57 =head2 C<__SUB__>
58
59 The new C<__SUB__> token, available under the C<current_sub> feature
60 (see L<feature>) or C<use v5.16>, returns a reference to the current
61 subroutine, making it easier to write recursive closures.
62
63 =head2 New and Improved Built-ins
64
65 =head3 More consistent C<eval>
66
67 The C<eval> operator sometimes treats a string argument as a sequence of
68 characters and sometimes as a sequence of bytes, depending on the
69 internal encoding.  The internal encoding is not supposed to make any
70 difference, but there is code that relies on this inconsistency.
71
72 The new C<unicode_eval> and C<evalbytes> features (enabled under C<use
73 5.16.0>) resolve this.  The C<unicode_eval> feature causes C<eval
74 $string> to treat the string always as Unicode.  The C<evalbytes>
75 features provides a function, itself called C<evalbytes>, which
76 evaluates its argument always as a string of bytes.
77
78 These features also fix oddities with source filters leaking to outer
79 dynamic scopes.
80
81 See L<feature> for more detail.
82
83 =head3 C<substr> lvalue revamp
84
85 =for comment Can this be compacted some? -- rjbs, 2012-02-20
86
87 When C<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 C<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 C<substr> itself, but only when the returned lvalue is
99 read or modified.
100
101 These changes result in several incompatible changes and bug fixes:
102
103 =over
104
105 =item *
106
107 If the original string changes length after the call to C<substr> but
108 before assignment to its return value, negative offsets will remember
109 their position from the end of the string, affecting code like this:
110
111     my $string = "string";
112     my $lvalue = \substr $string, -4, 2;
113     print $lvalue, "\n"; # prints "ri"
114     $string = "bailing twine";
115     print $lvalue, "\n"; # prints "wi"; used to print "il"
116
117 The same thing happens with an omitted third argument.  The returned
118 lvalue will always extend to the end of the string, even if the string
119 becomes longer.
120
121 =item *
122
123 Tied (and otherwise magical) variables are no longer exempt from the
124 "Attempt to use reference as lvalue in substr" warning.
125
126 =item *
127
128 That warning now occurs when the returned lvalue is assigned to, not
129 when C<substr> itself is called.  This only makes a difference if the
130 return value of C<substr> is referenced and assigned to later.
131
132 =item *
133
134 The order in which "uninitialized" warnings occur for arguments to
135 C<substr> has changed.
136
137 =item *
138
139 Passing a substring of a read-only value or a typeglob to a function
140 (potential lvalue context) no longer causes an immediate "Can't coerce"
141 or "Modification of a read-only value" error.  That error only occurs
142 if and when the value passed is assigned to.
143
144 The same thing happens with the "substr outside of string" error.  If
145 the lvalue is only read, not written to, it is now just a warning, as
146 with rvalue C<substr>.
147
148 =item *
149
150 C<substr> assignments no longer call FETCH twice if the first argument
151 is a tied variable, just once.
152
153 =back
154
155 It was impossible to fix all the bugs without an incompatible change,
156 and the behaviour of negative offsets was never specified, so the
157 change was deemed acceptable.
158
159 =head3 Return value of C<tied>
160
161 The value returned by C<tied> on a tied variable is now the actual
162 scalar that holds the object to which the variable is tied.  This
163 allows ties to be weakened with C<Scalar::Util::weaken(tied
164 $tied_variable)>.
165
166 =head2 Unicode Support
167
168 =head3 Supports (I<almost>) Unicode 6.1
169
170 Besides the addition of whole new scripts, and new characters in
171 existing scripts, this new version of Unicode, as always, makes some
172 changes to existing characters.  One change that may trip up some
173 applications is that the General Category of two characters in the
174 Latin-1 range, PILCROW SIGN and SECTION SIGN, has been changed from
175 Other_Symbol to Other_Punctuation.  The same change has been made for
176 a character in each of Tibetan, Ethiopic, and Aegean.
177 The code points U+3248..U+324F (CIRCLED NUMBER TEN ON BLACK SQUARE
178 through CIRCLED NUMBER EIGHTY ON BLACK SQUARE) have had their General
179 Category changed from Other_Symbol to Other_Numeric.  The Line Break
180 property has changes for Hebrew and Japanese; and as a consequence of
181 other changes in 6.1, the Perl regular expression construct C<\X> now
182 works differently for some characters in Thai and Lao.
183
184 New aliases (synonyms) have been defined for many property values;
185 these, along with the previously existing ones, are all cross-indexed in
186 L<perluniprops>.
187
188 The return value of C<charnames::viacode()> is affected by other
189 changes:
190
191  Code point      Old Name             New Name
192    U+000A    LINE FEED (LF)        LINE FEED
193    U+000C    FORM FEED (FF)        FORM FEED
194    U+000D    CARRIAGE RETURN (CR)  CARRIAGE RETURN
195    U+0085    NEXT LINE (NEL)       NEXT LINE
196    U+008E    SINGLE-SHIFT 2        SINGLE-SHIFT-2
197    U+008F    SINGLE-SHIFT 3        SINGLE-SHIFT-3
198    U+0091    PRIVATE USE 1         PRIVATE USE-1
199    U+0092    PRIVATE USE 2         PRIVATE USE-2
200    U+2118    SCRIPT CAPITAL P      WEIERSTRASS ELLIPTIC FUNCTION
201
202 Perl will accept any of these names as input, but
203 C<charnames::viacode()> now returns the new name of each pair.  The
204 change for U+2118 is considered by Unicode to be a correction, that is
205 the original name was a mistake (but again, it will remain forever valid
206 to use it to refer to U+2118).  But most of these changes are the
207 fallout of the mistake Unicode 6.0 made in naming a character used in
208 Japanese cell phones to be "BELL", which conflicts with the longstanding
209 industry use of (and Unicode's recommendation to use) that name
210 to mean the ASCII control character at U+0007.  As a result, that name
211 has been deprecated in Perl since v5.14; and any use of it will raise a
212 warning message (unless turned off).  The name "ALERT" is now the
213 preferred name for this code point, with "BEL" being an acceptable short
214 form.  The name for the new cell phone character, at code point U+1F514,
215 remains undefined in this version of Perl (hence we don't quite
216 implement all of Unicode 6.1), but starting in v5.18, BELL will mean
217 this character, and not U+0007.
218
219 Unicode has taken steps to make sure that this sort of mistake does not
220 happen again.  The Standard now includes all the generally accepted
221 names and abbreviations for control characters, whereas previously it
222 didn't (though there were recommended names for most of them, which Perl
223 used).  This means that most of those recommended names are now
224 officially in the Standard.  Unicode did not recommend names for the
225 four code points listed above between U+008E and U+008F, and in
226 standardizing them Unicode subtly changed the names that Perl had
227 previously given them, by replacing the final blank in each name by a
228 hyphen.  Unicode also officially accepts names that Perl had deprecated,
229 such as FILE SEPARATOR.  Now the only deprecated name is BELL.
230 Finally, Perl now uses the new official names instead of the old
231 (now considered obsolete) names for the first four code points in the
232 list above (the ones which have the parentheses in them).
233
234 Now that the names have been placed in the Unicode standard, these kinds
235 of changes should not happen again, though corrections, such as to
236 U+2118, are still possible.
237
238 Unicode also added some name abbreviations, which Perl now accepts:
239 SP for SPACE;
240 TAB for CHARACTER TABULATION;
241 NEW LINE, END OF LINE, NL, and EOL for LINE FEED;
242 LOCKING-SHIFT ONE for SHIFT OUT;
243 LOCKING-SHIFT ZERO for SHIFT IN;
244 and ZWNBSP for ZERO WIDTH NO-BREAK SPACE.
245
246 More details on this version of Unicode are provided in
247 L<http://www.unicode.org/versions/Unicode6.1.0/>.
248
249 =head3 C<use charnames> is no longer needed for C<\N{I<name>}>
250
251 When C<\N{I<name>}> is encountered, the C<charnames> module is now
252 automatically loaded when needed as if the C<:full> and C<:short>
253 options had been specified.  See L<charnames> for more information.
254
255 =head3 C<\N{...}> can now have Unicode loose name matching
256
257 This is described in the C<charnames> item in
258 L</Updated Modules and Pragmata> below.
259
260 =head3 Unicode Symbol Names
261
262 Perl now has proper support for Unicode in symbol names.  It used to be
263 that C<*{$foo}> would ignore the internal UTF8 flag and use the bytes of
264 the underlying representation to look up the symbol.  That meant that
265 C<*{"\x{100}"}> and C<*{"\xc4\x80"}> would return the same thing.  All
266 these parts of Perl have been fixed to account for Unicode:
267
268 =over
269
270 =item *
271
272 Method names (including those passed to C<use overload>)
273
274 =item *
275
276 Typeglob names (including names of variables, subroutines and filehandles)
277
278 =item *
279
280 Package names
281
282 =item *
283
284 C<goto>
285
286 =item *
287
288 Symbolic dereferencing
289
290 =item *
291
292 Second argument to C<bless()> and C<tie()>
293
294 =item *
295
296 Return value of C<ref()>
297
298 =item *
299
300 Subroutine prototypes
301
302 =item *
303
304 Attributes
305
306 =item *
307
308 Various warnings and error messages that mention variable names or values,
309 methods, etc.
310
311 =back
312
313 In addition, a parsing bug has been fixed that prevented C<*{é}> from
314 implicitly quoting the name, but instead interpreted it as C<*{+é}>, which
315 would cause a strict violation.
316
317 C<*{"*a::b"}> automatically strips off the * if it is followed by an ASCII
318 letter.  That has been extended to all Unicode identifier characters.
319
320 One-character non-ASCII non-punctuation variables (like C<$é>) are now
321 subject to "Used only once" warnings.  They used to be exempt, as they
322 was treated as punctuation variables.
323
324 Also, single-character Unicode punctuation variables (like $‰) are now
325 supported [perl #69032].
326
327 =head3 Improved ability to mix locales and Unicode, including UTF-8 locales
328
329 An optional parameter has been added to C<use locale>
330
331  use locale ':not_characters';
332
333 which tells Perl to use all but the C<LC_CTYPE> and C<LC_COLLATE>
334 portions of the current locale.  Instead, the character set is assumed
335 to be Unicode.  This allows locales and Unicode to be seamlessly mixed,
336 including the increasingly frequent UTF-8 locales.  When using this
337 hybrid form of locales, the C<:locale> layer to the L<open> pragma can
338 be used to interface with the file system, and there are CPAN modules
339 available for ARGV and environment variable conversions.
340
341 Full details are in L<perllocale>.
342
343 =head3 New function C<fc> and corresponding escape sequence C<\F> for Unicode foldcase
344
345 Unicode foldcase is an extension to lowercase that gives better results
346 when comparing two strings case-insensitively.  It has long been used
347 internally in regular expression C</i> matching.  Now it is available
348 explicitly through the new C<fc> function call (enabled by
349 S<C<"use feature 'fc'">>, or C<use v5.16>, or explicitly callable via
350 C<CORE::fc>) or through the new C<\F> sequence in double-quotish
351 strings.
352
353 Full details are in L<perlfunc/fc>.
354
355 =head3 The Unicode C<Script_Extensions> property is now supported.
356
357 New in Unicode 6.0, this is an improved C<Script> property.  Details
358 are in L<perlunicode/Scripts>.
359
360 =head2 XS Changes
361
362 =head3 Improved typemaps for Some Builtin Types
363
364 Most XS authors will be aware that there is a longstanding bug in the
365 OUTPUT typemap for T_AVREF (C<AV*>), T_HVREF (C<HV*>), T_CVREF (C<CV*>),
366 and T_SVREF (C<SVREF> or C<\$foo>) that requires manually decrementing
367 the reference count of the return value instead of the typemap taking
368 care of this.  For backwards-compatibility, this cannot be changed in the
369 default typemaps.  But we now provide additional typemaps
370 C<T_AVREF_REFCOUNT_FIXED>, etc. that do not exhibit this bug.  Using
371 them in your extension is as simple as having one line in your
372 C<TYPEMAP> section:
373
374   HV*   T_HVREF_REFCOUNT_FIXED
375
376 =head3 C<is_utf8_char()>
377
378 The XS-callable function C<is_utf8_char()>, when presented with
379 malformed UTF-8 input, can read up to 12 bytes beyond the end of the
380 string.  This cannot be fixed without changing its API.  It is not
381 called from CPAN.  The documentation now describes how to use it
382 safely.
383
384 =head3 Added C<is_utf8_char_buf()>
385
386 This function is designed to replace the deprecated L</is_utf8_char()>
387 function.  It includes an extra parameter to make sure it doesn't read
388 past the end of the input buffer.
389
390 =head3 Other C<is_utf8_foo()> functions, as well as C<utf8_to_foo()>, etc.
391
392 Most of the other XS-callable functions that take UTF-8 encoded input
393 implicitly assume that the UTF-8 is valid (not malformed) in regards to
394 buffer length.  Do not do things such as change a character's case or
395 see if it is alphanumeric without first being sure that it is valid
396 UTF-8.  This can be safely done for a whole string by using one of the
397 functions C<is_utf8_string()>, C<is_utf8_string_loc()>, and
398 C<is_utf8_string_loclen()>.
399
400 =head3 New Pad API
401
402 Many new functions have been added to the API for manipulating lexical
403 pads.  See L<perlapi/Pad Data Structures> for more information.
404
405 =head2 Changes to Special Variables
406
407 =head3 C<$$> can be assigned to
408
409 C<$$> was made read-only in Perl 5.8.0.  But only sometimes: C<local $$>
410 would make it writable again.  Some CPAN modules were using C<local $$> or
411 XS code to bypass the read-only check, so there is no reason to keep C<$$>
412 read-only.  (This change also allowed a bug to be fixed while maintaining
413 backward compatibility.)
414
415 =head3 C<$^X> converted to an absolute path on FreeBSD, OS X and Solaris
416
417 C<$^X> is now converted to an absolute path on OS X, FreeBSD (without
418 needing F</proc> mounted) and Solaris 10 and 11.  This augments the
419 previous approach of using F</proc> on Linux, FreeBSD and NetBSD
420 (in all cases, where mounted).
421
422 This makes relocatable perl installations more useful on these platforms.
423 (See "Relocatable @INC" in F<INSTALL>)
424
425 =head2 Debugger Changes
426
427 =head3 Features inside the debugger
428
429 The current Perl's L<feature> bundle is now enabled for commands entered
430 in the interactive debugger.
431
432 =head3 New option for the debugger's B<t> command
433
434 The B<t> command in the debugger, which toggles tracing mode, now
435 accepts a numeric argument that determines how many levels of subroutine
436 calls to trace.
437
438 =head3 C<enable> and C<disable>
439
440 The debugger now has C<disable> and C<enable> commands for disabling
441 existing breakpoints and re-enabling them.  See L<perldebug>.
442
443 =head3 Breakpoints with file names
444
445 The debugger's "b" command for setting breakpoints now allows a line
446 number to be prefixed with a file name.  See
447 L<perldebug/"b [file]:[line] [condition]">.
448
449 =head2 The C<CORE> Namespace
450
451 =head3 The C<CORE::> prefix
452
453 The C<CORE::> prefix can now be used on keywords enabled by
454 L<feature.pm|feature>, even outside the scope of C<use feature>.
455
456 =head3 Subroutines in the C<CORE> namespace
457
458 Many Perl keywords are now available as subroutines in the CORE namespace.
459 This allows them to be aliased:
460
461     BEGIN { *entangle = \&CORE::tie }
462     entangle $variable, $package, @args;
463
464 And for prototypes to be bypassed:
465
466     sub mytie(\[%$*@]$@) {
467         my ($ref, $pack, @args) = @_;
468         ... do something ...
469         goto &CORE::tie;
470     }
471
472 Some of these cannot be called through references or via C<&foo> syntax,
473 but must be called as barewords.
474
475 See L<CORE> for details.
476
477 =head2 Other Changes
478
479 =head3 Anonymous handles
480
481 Automatically generated file handles are now named __ANONIO__ when the
482 variable name cannot be determined, rather than $__ANONIO__.
483
484 =head3 Autoloaded sort Subroutines
485
486 Custom sort subroutines can now be autoloaded [perl #30661]:
487
488     sub AUTOLOAD { ... }
489     @sorted = sort foo @list; # uses AUTOLOAD
490
491 =head3 C<continue> no longer requires the "switch" feature
492
493 The C<continue> keyword has two meanings.  It can introduce a C<continue>
494 block after a loop, or it can exit the current C<when> block.  Up till now,
495 the latter meaning was only valid with the "switch" feature enabled, and
496 was a syntax error otherwise.  Since the main purpose of feature.pm is to
497 avoid conflicts with user-defined subroutines, there is no reason for
498 C<continue> to depend on it.
499
500 =head3 DTrace probes for interpreter phase change
501
502 The C<phase-change> probes will fire when the interpreter's phase
503 changes, which tracks the C<${^GLOBAL_PHASE}> variable.  C<arg0> is
504 the new phase name; C<arg1> is the old one.  This is useful mostly
505 for limiting your instrumentation to one or more of: compile time,
506 run time, destruct time.
507
508 =head3 C<__FILE__()> Syntax
509
510 The C<__FILE__>, C<__LINE__> and C<__PACKAGE__> tokens can now be written
511 with an empty pair of parentheses after them.  This makes them parse the
512 same way as C<time>, C<fork> and other built-in functions.
513
514 =head3 The C<\$> prototype accepts any scalar lvalue
515
516 The C<\$> and C<\[$]> subroutine prototypes now accept any scalar lvalue
517 argument.  Previously they only accepted scalars beginning with C<$> and
518 hash and array elements.  This change makes them consistent with the way
519 the built-in C<read> and C<recv> functions (among others) parse their
520 arguments.  This means that one can override the built-in functions with
521 custom subroutines that parse their arguments the same way.
522
523 =head3 C<_> in subroutine prototypes
524
525 The C<_> character in subroutine prototypes is now allowed before C<@> or
526 C<%>.
527
528 =head1 Security
529
530 =head2 Use C<is_utf8_char_buf()> and not C<is_utf8_char()>
531
532 The latter function is now deprecated because its API is insufficient to
533 guarantee that it doesn't read (up to 12 bytes in the worst case) beyond
534 the end of its input string.  See
535 L<is_utf8_char_buf()|/Added is_utf8_char_buf()>.
536
537 =head2 C<File::Glob::bsd_glob()> memory error with GLOB_ALTDIRFUNC (CVE-2011-2728).
538
539 Calling C<File::Glob::bsd_glob> with the unsupported flag
540 GLOB_ALTDIRFUNC would cause an access violation / segfault.  A Perl
541 program that accepts a flags value from an external source could expose
542 itself to denial of service or arbitrary code execution attacks.  There
543 are no known exploits in the wild.  The problem has been corrected by
544 explicitly disabling all unsupported flags and setting unused function
545 pointers to null.  Bug reported by Clément Lecigne.
546
547 =head2 Privileges are now set correctly when assigning to C<$(>
548
549 A hypothetical bug (probably non-exploitable in practice) due to the
550 incorrect setting of the effective group ID while setting C<$(> has been
551 fixed.  The bug would only have affected systems that have C<setresgid()>
552 but not C<setregid()>, but no such systems are known of.
553
554 =head1 Deprecations
555
556 =head2 Don't read the Unicode data base files in F<lib/unicore>
557
558 It is now deprecated to directly read the Unicode data base files.
559 These are stored in the F<lib/unicore> directory.  Instead, you should
560 use the new functions in L<Unicode::UCD>.  These provide a stable API,
561 and give complete information.
562
563 Perl may at some point in the future change or remove the files.  The
564 file most likely for applications to have used is
565 F<lib/unicore/ToDigit.pl>.  L<Unicode::UCD/prop_invmap()> can be used to
566 get at its data instead.
567
568 =head2 C<is_utf8_char()>
569
570 This function is deprecated because it could read beyond the end of the
571 input string.  Use the new L<is_utf8_char_buf()|/Added is_utf8_char_buf()>
572 instead.
573
574 =head1 Future Deprecations
575
576 This section serves as a notice of features that are I<likely> to be
577 removed or L<deprecated|perlpolicy/deprecated> in the next release of
578 perl (5.18.0).  If your code depends on these features, you should
579 contact the Perl 5 Porters via the L<mailing
580 list|http://lists.perl.org/list/perl5-porters.html> or L<perlbug> to
581 explain your use case and inform the deprecation process.
582
583 =head2 Core Modules
584
585 These modules may be marked as deprecated I<from the core>.  This only
586 means that they will no longer be installed by default with the core
587 distribution, but will remain available on the CPAN.
588
589 =over
590
591 =item *
592
593 CPANPLUS
594
595 =item *
596
597 Filter::Simple
598
599 =item *
600
601 PerlIO::mmap
602
603 =item *
604
605 Pod::Parser, Pod::LaTeX
606
607 =item *
608
609 SelfLoader
610
611 =item *
612
613 Text::Soundex
614
615 =item *
616
617 Thread.pm
618
619 =back
620
621 =head2 Platforms with no supporting programmers:
622
623 These platforms will probably have their
624 special build support removed during the
625 5.17.0 development series.
626
627 =over
628
629 =item *
630
631 BeOS
632
633 =item *
634
635 djgpp
636
637 =item *
638
639 dgux
640
641 =item *
642
643 EPOC
644
645 =item *
646
647 MPE/iX
648
649 =item *
650
651 Rhapsody
652
653 =item *
654
655 UTS
656
657 =item *
658
659 VM/ESA
660
661 =back
662
663 =head2 Other Future Deprecations
664
665 =over
666
667 =item *
668
669 Swapping of $< and $>
670
671 For more information about this future deprecation, see L<the relevant RT
672 ticket|https://rt.perl.org/rt3/Ticket/Display.html?id=96212>.
673
674 =item *
675
676 sfio, stdio
677
678 =item *
679
680 Unescaped literal C<< "{" >> in regular expressions.
681
682 It is planned starting in v5.20 to require a literal C<"{"> to be
683 escaped by, for example, preceding it with a backslash.  In v5.18, a
684 deprecated warning message will be emitted for all such uses.  Note that
685 this only affects patterns which are to match a literal C<"{">.  Other
686 uses of this character, such as part of a quantifier or sequence like in
687 the ones below are completely unaffected:
688
689     /foo{3,5}/
690     /\p{Alphabetic}/
691     /\N{DIGIT ZERO}
692
693 The removal of this will allow extensions to pattern syntax, and better
694 error checking of existing syntax.  See L<perlre/Quantifiers> for an
695 example.
696
697 =back
698
699 =head1 Incompatible Changes
700
701 =head2 Special blocks called in void context
702
703 Special blocks (C<BEGIN>, C<CHECK>, C<INIT>, C<UNITCHECK>, C<END>) are now
704 called in void context.  This avoids wasteful copying of the result of the
705 last statement [perl #108794].
706
707 =head2 The C<overloading> pragma and regexp objects
708
709 With C<no overloading>, regular expression objects returned by C<qr//> are
710 now stringified as "Regexp=REGEXP(0xbe600d)" instead of the regular
711 expression itself [perl #108780].
712
713 =head2 Two XS typemap Entries removed
714
715 Two presumably unused XS typemap entries have been removed from the
716 core typemap: T_DATAUNIT and T_CALLBACK.  If you are, against all odds,
717 a user of these, please see the instructions on how to regain them
718 in L<perlxstypemap>.
719
720 =head2 Unicode 6.1 has incompatibilities with Unicode 6.0
721
722 These are detailed in L</Supports (almost) Unicode 6.1> above.
723 You can compile this version of Perl to use Unicode 6.0.  See
724 L<perlunicode/Hacking Perl to work on earlier Unicode versions (for very serious hackers only)>.
725
726 =head2 Borland compiler
727
728 All support for the Borland compiler has been dropped.  The code had not
729 worked for a long time anyway.
730
731 =head2 Certain deprecated Unicode properties are no longer supported by default
732
733 Perl should never have exposed certain Unicode properties that are used
734 by Unicode internally and not meant to be publicly available.  Use of
735 these has generated deprecated warning messages since Perl 5.12.  The
736 removed properties are Other_Alphabetic,
737 Other_Default_Ignorable_Code_Point, Other_Grapheme_Extend,
738 Other_ID_Continue, Other_ID_Start, Other_Lowercase, Other_Math, and
739 Other_Uppercase.
740
741 Perl may be recompiled to include any or all of them; instructions are
742 given in
743 L<perluniprops/Unicode character properties that are NOT accepted by Perl>.
744
745 =head2 Dereferencing IO thingies as typeglobs
746
747 The C<*{...}> operator, when passed a reference to an IO thingy (as in
748 C<*{*STDIN{IO}}>), creates a new typeglob containing just that IO object.
749 Previously, it would stringify as an empty string, but some operators would
750 treat it as undefined, producing an "uninitialized" warning.
751 Now it stringifies as __ANONIO__ [perl #96326].
752
753 =head2 User-defined case changing operations.
754
755 This feature was deprecated in Perl 5.14, and has now been removed.
756 The CPAN module L<Unicode::Casing> provides better functionality without
757 the drawbacks that this feature had, as are detailed in the 5.14
758 documentation:
759 L<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
760
761 =head2 XSUBs are now 'static'
762
763 XSUB C functions are now 'static', that is, they are not visible from
764 outside the compilation unit.  Users can use the new C<XS_EXTERNAL(name)>
765 and C<XS_INTERNAL(name)> macros to pick the desired linking behaviour.
766 The ordinary C<XS(name)> declaration for XSUBs will continue to declare
767 non-'static' XSUBs for compatibility, but the XS compiler,
768 C<ExtUtils::ParseXS> (C<xsubpp>) will emit 'static' XSUBs by default.
769 C<ExtUtils::ParseXS>'s behaviour can be reconfigured from XS using the
770 C<EXPORT_XSUB_SYMBOLS> keyword.  See L<perlxs> for details.
771
772 =head2 Weakening read-only references
773
774 Weakening read-only references is no longer permitted.  It should never
775 have worked anyway, and in some cases could result in crashes.
776
777 =head2 Tying scalars that hold typeglobs
778
779 Attempting to tie a scalar after a typeglob was assigned to it would
780 instead tie the handle in the typeglob's IO slot.  This meant that it was
781 impossible to tie the scalar itself.  Similar problems affected C<tied> and
782 C<untie>: C<tied $scalar> would return false on a tied scalar if the last
783 thing returned was a typeglob, and C<untie $scalar> on such a tied scalar
784 would do nothing.
785
786 We fixed this problem before Perl 5.14.0, but it caused problems with some
787 CPAN modules, so we put in a deprecation cycle instead.
788
789 Now the deprecation has been removed and this bug has been fixed.  So
790 C<tie $scalar> will always tie the scalar, not the handle it holds.  To tie
791 the handle, use C<tie *$scalar> (with an explicit asterisk).  The same
792 applies to C<tied *$scalar> and C<untie *$scalar>.
793
794 =head2 IPC::Open3 no longer provides C<xfork()>, C<xclose_on_exec()>
795 and C<xpipe_anon()>
796
797 All three functions were private, undocumented and unexported.  They do
798 not appear to be used by any code on CPAN.  Two have been inlined and one
799 deleted entirely.
800
801 =head2 C<$$> no longer caches PID
802
803 Previously, if one called fork(3) from C, Perl's
804 notion of C<$$> could go out of sync with what getpid() returns.  By always
805 fetching the value of C<$$> via getpid(), this potential bug is eliminated.
806 Code that depends on the caching behavior will break.  As described in
807 L<Core Enhancements|/C<$$> can be assigned to>,
808 C<$$> is now writable, but it will be reset during a
809 fork.
810
811 =head2 C<$$> and C<getppid()> no longer emulate POSIX semantics under LinuxThreads
812
813 The POSIX emulation of C<$$> and C<getppid()> under the obsolete
814 LinuxThreads implementation has been removed.
815 This only impacts users of Linux 2.4 and
816 users of Debian GNU/kFreeBSD up to and including 6.0, not the vast
817 majority of Linux installations that use NPTL threads.
818
819 This means that C<getppid()>, like C<$$>, is now always guaranteed to
820 return the OS's idea of the current state of the process, not perl's
821 cached version of it.
822
823 See the documentation for L<$$|perlvar/$$> for details.
824
825 =head2 C<< $< >>, C<< $> >>, C<$(> and C<$)> are no longer cached
826
827 Similarly to the changes to C<$$> and C<getppid()>, the internal
828 caching of C<< $< >>, C<< $> >>, C<$(> and C<$)> has been removed.
829
830 When we cached these values our idea of what they were would drift out
831 of sync with reality if someone (e.g., someone embedding perl) called
832 C<sete?[ug]id()> without updating C<PL_e?[ug]id>.  Having to deal with
833 this complexity wasn't worth it given how cheap the C<gete?[ug]id()>
834 system call is.
835
836 This change will break a handful of CPAN modules that use the XS-level
837 C<PL_uid>, C<PL_gid>, C<PL_euid> or C<PL_egid> variables.
838
839 The fix for those breakages is to use C<PerlProc_gete?[ug]id()> to
840 retrieve them (e.g. C<PerlProc_getuid()>), and not to assign to
841 C<PL_e?[ug]id> if you change the UID/GID/EUID/EGID.  There is no longer
842 any need to do so since perl will always retrieve the up-to-date
843 version of those values from the OS.
844
845 =head2 Which Non-ASCII characters get quoted by C<quotemeta> and C<\Q> has changed
846
847 This is unlikely to result in a real problem, as Perl does not attach
848 special meaning to any non-ASCII character, so it is currently
849 irrelevant which are quoted or not.  This change fixes bug [perl #77654] and
850 bring Perl's behavior more into line with Unicode's recommendations.
851 See L<perlfunc/quotemeta>.
852
853 =head1 Performance Enhancements
854
855 =over
856
857 =item *
858
859 Improved performance for Unicode properties in regular expressions
860
861 =for comment Can this be compacted some? -- rjbs, 2012-02-20
862
863 Matching a code point against a Unicode property is now done via a
864 binary search instead of linear.  This means for example that the worst
865 case for a 1000 item property is 10 probes instead of 1000.  This
866 inefficiency has been compensated for in the past by permanently storing
867 in a hash the results of a given probe plus the results for the adjacent
868 64 code points, under the theory that near-by code points are likely to
869 be searched for.  A separate hash was used for each mention of a Unicode
870 property in each regular expression.  Thus, C<qr/\p{foo}abc\p{foo}/>
871 would generate two hashes.  Any probes in one instance would be unknown
872 to the other, and the hashes could expand separately to be quite large
873 if the regular expression were used on many different widely-separated
874 code points.  This can lead to running out of memory in extreme cases.
875 Now, however, there is just one hash shared by all instances of a given
876 property.  This means that if C<\p{foo}> is matched against "A" in one
877 regular expression in a thread, the result will be known immediately to
878 all regular expressions, and the relentless march of using up memory is
879 slowed considerably.
880
881 =item *
882
883 Version declarations with the C<use> keyword (e.g., C<use 5.012>) are now
884 faster, as they enable features without loading F<feature.pm>.
885
886 =item *
887
888 C<local $_> is faster now, as it no longer iterates through magic that it
889 is not going to copy anyway.
890
891 =item *
892
893 Perl 5.12.0 sped up the destruction of objects whose classes define
894 empty C<DESTROY> methods (to prevent autoloading), by simply not
895 calling such empty methods.  This release takes this optimisation a
896 step further, by not calling any C<DESTROY> method that begins with a
897 C<return> statement.  This can be useful for destructors that are only
898 used for debugging:
899
900     use constant DEBUG => 1;
901     sub DESTROY { return unless DEBUG; ... }
902
903 Constant-folding will reduce the first statement to C<return;> if DEBUG
904 is set to 0, triggering this optimisation.
905
906 =item *
907
908 Assigning to a variable that holds a typeglob or copy-on-write scalar
909 is now much faster.  Previously the typeglob would be stringified or
910 the copy-on-write scalar would be copied before being clobbered.
911
912 =item *
913
914 Assignment to C<substr> in void context is now more than twice its
915 previous speed.  Instead of creating and returning a special lvalue
916 scalar that is then assigned to, C<substr> modifies the original string
917 itself.
918
919 =item *
920
921 C<substr> no longer calculates a value to return when called in void
922 context.
923
924 =item *
925
926 Due to changes in L<File::Glob>, Perl's C<glob> function and its C<<
927 <...> >> equivalent are now much faster.  The splitting of the pattern
928 into words has been rewritten in C, resulting in speed-ups of 20% in
929 some cases.
930
931 This does not affect C<glob> on VMS, as it does not use File::Glob.
932
933 =item *
934
935 The short-circuiting operators C<&&>, C<||>, and C<//>, when chained
936 (such as C<$a || $b || $c>), are now considerably faster to short-circuit,
937 due to reduced optree traversal.
938
939 =item *
940
941 The implementation of C<s///r> makes one fewer copy of the scalar's value.
942
943 =item *
944
945 C<study> is now a no-op.
946
947 =item *
948
949 Recursive calls to lvalue subroutines in lvalue scalar context use less
950 memory.
951
952 =back
953
954 =head1 Modules and Pragmata
955
956 XXX All changes to installed files in F<cpan/>, F<dist/>, F<ext/> and F<lib/>
957 go here.  If Module::CoreList is updated, generate an initial draft of the
958 following sections using F<Porting/corelist-perldelta.pl>, which prints stub
959 entries to STDOUT.  Results can be pasted in place of the '=head2' entries
960 below.  A paragraph summary for important changes should then be added by hand.
961 In an ideal world, dual-life modules would have a F<Changes> file that could be
962 cribbed.
963
964 [ Within each section, list entries as a =item entry ]
965
966 =head2 Deprecated Modules
967
968 =over
969
970 =item L<Version::Requirements>
971
972 Version::Requirements is now DEPRECATED, use L<CPAN::Meta::Requirements>,
973 which is a drop-in replacement.  It will be deleted from perl.git blead
974 in v5.17.0.
975
976 =back
977
978 =head2 New Modules and Pragmata
979
980 =over 4
981
982 =item *
983
984 L<arybase> -- this new module implements the C<$[> variable.
985
986 =item *
987
988 C<PerlIO::mmap> 0.010 has been added to the Perl core.
989
990 The C<mmap> PerlIO layer is no longer implemented by perl itself, but has
991 been moved out into the new L<PerlIO::mmap> module.
992
993 =back
994
995 =head2 Updated Modules and Pragmata
996
997 =over 4
998
999 =item *
1000
1001 L<XXX> has been upgraded from version 0.69 to version 0.70.
1002
1003 =back
1004
1005 =head2 Removed Modules and Pragmata
1006
1007 As promised in Perl 5.14.0's release notes, the following modules have
1008 been removed from the core distribution, and if needed should be installed
1009 from CPAN instead.
1010
1011 =over
1012
1013 =item *
1014
1015 C<Devel::DProf> has been removed from the Perl core.  Prior version was
1016 20110228.00.
1017
1018 =item *
1019
1020 C<Shell> has been removed from the Perl core.  Prior version was 0.72_01.
1021
1022 =back
1023
1024 =head1 Documentation
1025
1026 =head2 New Documentation
1027
1028 =head3 L<perldtrace>
1029
1030 L<perldtrace> describes Perl's DTrace support, listing the provided probes
1031 and gives examples of their use.
1032
1033 =head3 L<perlexperiment>
1034
1035 This document is intended to provide a list of experimental features in
1036 Perl.  It is still a work in progress.
1037
1038 =head3 L<perlootut>
1039
1040 This a new OO tutorial.  It focuses on basic OO concepts, and then recommends
1041 that readers choose an OO framework from CPAN.
1042
1043 =head3 L<perlxstypemap>
1044
1045 The new manual describes the XS typemapping mechanism in unprecedented
1046 detail and combines new documentation with information extracted from
1047 L<perlxs> and the previously unofficial list of all core typemaps.
1048
1049 =head2 Changes to Existing Documentation
1050
1051 =head3 L<perlapi>
1052
1053 =over 4
1054
1055 =item *
1056
1057 The HV API has long accepted negative lengths to indicate that the key is
1058 in UTF8.  Now this is documented.
1059
1060 =item *
1061
1062 The C<boolSV()> macro is now documented.
1063
1064 =back
1065
1066 =head3 L<perlfunc>
1067
1068 =over 4
1069
1070 =item *
1071
1072 C<dbmopen> treats a 0 mode as a special case, that prevents a nonexistent
1073 file from being created.  This has been the case since Perl 5.000, but was
1074 never documented anywhere.  Now the perlfunc entry mentions it
1075 [perl #90064].
1076
1077 =item *
1078
1079 As an accident of history, C<open $fh, "<:", ...> applies the default
1080 layers for the platform (C<:raw> on Unix, C<:crlf> on Windows), ignoring
1081 whatever is declared by L<open.pm|open>.  This seems such a useful feature
1082 it has been documented in L<perlfunc|perlfunc/open> and L<open>.
1083
1084 =item *
1085
1086 The entry for C<split> has been rewritten.  It is now far clearer than
1087 before.
1088
1089 =back
1090
1091 =head3 L<perlguts>
1092
1093 =over 4
1094
1095 =item *
1096
1097 A new section, L<Autoloading with XSUBs|perlguts/Autoloading with XSUBs>,
1098 has been added, which explains the two APIs for accessing the name of the
1099 autoloaded sub.
1100
1101 =item *
1102
1103 Some of the function descriptions in L<perlguts> were confusing, as it was
1104 not clear whether they referred to the function above or below the
1105 description.  This has been clarified [perl #91790].
1106
1107 =back
1108
1109 =head3 L<perlobj>
1110
1111 =over 4
1112
1113 =item *
1114
1115 This document has been rewritten from scratch, and its coverage of various OO
1116 concepts has been expanded.
1117
1118 =back
1119
1120 =head3 L<perlop>
1121
1122 =over 4
1123
1124 =item *
1125
1126 Documentation of the smartmatch operator has been reworked and moved from
1127 perlsyn to perlop where it belongs.
1128
1129 It has also been corrected for the case of C<undef> on the left-hand
1130 side.  The list of different smart match behaviours had an item in the
1131 wrong place.
1132
1133 =item *
1134
1135 Documentation of the ellipsis statement (C<...>) has been reworked and
1136 moved from perlop to perlsyn.
1137
1138 =item *
1139
1140 The explanation of bitwise operators has been expanded to explain how they
1141 work on Unicode strings (5.14.1).
1142
1143 =item *
1144
1145 More examples for C<m//g> have been added (5.14.1).
1146
1147 =item *
1148
1149 The C<<< <<\FOO >>> here-doc syntax has been documented (5.14.1).
1150
1151 =back
1152
1153 =head3 L<perlpragma>
1154
1155 =over 4
1156
1157 =item *
1158
1159 There is now a standard convention for naming keys in the C<%^H>,
1160 documented under L<Key naming|perlpragma/Key naming>.
1161
1162 =back
1163
1164 =head3 L<perlsec/Laundering and Detecting Tainted Data>
1165
1166 =over 4
1167
1168 =item *
1169
1170 The example function for checking for taintedness contained a subtle
1171 error.  C<$@> needs to be localized to prevent its changing this
1172 global's value outside the function.  The preferred method to check for
1173 this remains L<Scalar::Util/tainted>.
1174
1175 =back
1176
1177 =head3 L<perllol>
1178
1179 =over
1180
1181 =item *
1182
1183 L<perllol> has been expanded with examples using the new C<push $scalar>
1184 syntax introduced in Perl 5.14.0 (5.14.1).
1185
1186 =back
1187
1188 =head3 L<perlmod>
1189
1190 =over
1191
1192 =item *
1193
1194 L<perlmod> now states explicitly that some types of explicit symbol table
1195 manipulation are not supported.  This codifies what was effectively already
1196 the case [perl #78074].
1197
1198 =back
1199
1200 =head3 L<perlpodstyle>
1201
1202 =over 4
1203
1204 =item *
1205
1206 The tips on which formatting codes to use have been corrected and greatly
1207 expanded.
1208
1209 =item *
1210
1211 There are now a couple of example one-liners for previewing POD files after
1212 they have been edited.
1213
1214 =back
1215
1216 =head3 L<perlre>
1217
1218 =over
1219
1220 =item *
1221
1222 The C<(*COMMIT)> directive is now listed in the right section
1223 (L<Verbs without an argument|perlre/Verbs without an argument>).
1224
1225 =back
1226
1227 =head3 L<perlrun>
1228
1229 =over
1230
1231 =item *
1232
1233 L<perlrun> has undergone a significant clean-up.  Most notably, the
1234 B<-0x...> form of the B<-0> flag has been clarified, and the final section
1235 on environment variables has been corrected and expanded (5.14.1).
1236
1237 =back
1238
1239 =head3 L<perlsub>
1240
1241 =over
1242
1243 =item *
1244
1245 The ($;) prototype syntax, which has existed for rather a long time, is now
1246 documented in L<perlsub>.  It allows a unary function to have the same
1247 precedence as a list operator.
1248
1249 =back
1250
1251 =head3 L<perltie>
1252
1253 =over
1254
1255 =item *
1256
1257 The required syntax for tying handles has been documented.
1258
1259 =back
1260
1261 =head3 L<perlvar>
1262
1263 =over
1264
1265 =item *
1266
1267 The documentation for L<$!|perlvar/$!> has been corrected and clarified.
1268 It used to state that $! could be C<undef>, which is not the case.  It was
1269 also unclear as to whether system calls set C's C<errno> or Perl's C<$!>
1270 [perl #91614].
1271
1272 =item *
1273
1274 Documentation for L<$$|perlvar/$$> has been amended with additional
1275 cautions regarding changing the process ID.
1276
1277 =back
1278
1279 =head3 Other Changes
1280
1281 =over 4
1282
1283 =item *
1284
1285 L<perlxs> was extended with documentation on inline typemaps.
1286
1287 =item *
1288
1289 L<perlref> has a new L<Circular References|perlref/Circular References>
1290 section explaining how circularities may not be freed and how to solve that
1291 with weak references.
1292
1293 =item *
1294
1295 Parts of L<perlapi> were clarified, and Perl equivalents of some C
1296 functions have been added as an additional mode of exposition.
1297
1298 =item *
1299
1300 A few parts of L<perlre> and L<perlrecharclass> were clarified.
1301
1302 =back
1303
1304 =head2 Removed Documentation
1305
1306 =head3 Old OO Documentation
1307
1308 All the old OO tutorials, perltoot, perltooc, and perlboot, have been
1309 removed.  The perlbot (bag of object tricks) document has been removed
1310 as well.
1311
1312 =head3 Development Deltas
1313
1314 The perldelta files for development releases are no longer packaged with
1315 perl.  These can still be found in the perl source code repository.
1316
1317 =head1 Diagnostics
1318
1319 The following additions or changes have been made to diagnostic output,
1320 including warnings and fatal error messages.  For the complete list of
1321 diagnostic messages, see L<perldiag>.
1322
1323 =head2 New Diagnostics
1324
1325 =head3 New Errors
1326
1327 =over 4
1328
1329 =item *
1330
1331 L<Cannot set tied @DB::args|perldiag/"Cannot set tied @DB::args">
1332
1333 This error occurs when C<caller> tries to set C<@DB::args> but finds it
1334 tied.  Before this error was added, it used to crash instead.
1335
1336 =item *
1337
1338 L<Cannot tie unreifiable array|perldiag/"Cannot tie unreifiable array">
1339
1340 This error is part of a safety check that the C<tie> operator does before
1341 tying a special array like C<@_>.  You should never see this message.
1342
1343 =item *
1344
1345 L<&CORE::%s cannot be called directly|perldiag/"&CORE::%s cannot be called directly">
1346
1347 This occurs when a subroutine in the C<CORE::> namespace is called
1348 with C<&foo> syntax or through a reference.  Some subroutines
1349 in this package cannot yet be called that way, but must be
1350 called as barewords.  See L</Subroutines in the C<CORE> namespace>, above.
1351
1352 =item *
1353
1354 L<Source filters apply only to byte streams|perldiag/"Source filters apply only to byte streams">
1355
1356 This new error occurs when you try to activate a source filter (usually by
1357 loading a source filter module) within a string passed to C<eval> under the
1358 C<unicode_eval> feature.
1359
1360 =back
1361
1362 =head3 New Warnings
1363
1364 =over 4
1365
1366 =item *
1367
1368 L<defined(@array) is deprecated|perldiag/"defined(@array) is deprecated">
1369
1370 The long-deprecated C<defined(@array)> now also warns for package variables.
1371 Previously it only issued a warning for lexical variables.
1372
1373 =item *
1374
1375 L<length() used on %s|perldiag/length() used on %s>
1376
1377 This new warning occurs when C<length> is used on an array or hash, instead
1378 of C<scalar(@array)> or C<scalar(keys %hash)>.
1379
1380 =item *
1381
1382 L<lvalue attribute %s already-defined subroutine|perldiag/"lvalue attribute %s already-defined subroutine">
1383
1384 L<attributes.pm|attributes> now emits this warning when the :lvalue
1385 attribute is applied to a Perl subroutine that has already been defined, as
1386 doing so can have unexpected side-effects.
1387
1388 =item *
1389
1390 L<overload arg '%s' is invalid|perldiag/"overload arg '%s' is invalid">
1391
1392 This warning, in the "overload" category, is produced when the overload
1393 pragma is given an argument it doesn't recognize, presumably a mistyped
1394 operator.
1395
1396 =item *
1397
1398 L<$[ used in %s (did you mean $] ?)|perldiag/"$[ used in %s (did you mean $] ?)">
1399
1400 This new warning exists to catch the mistaken use of C<$[> in version
1401 checks.  C<$]>, not C<$[>, contains the version number.
1402
1403 =item *
1404
1405 L<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
1406
1407 Assigning to a temporary scalar returned
1408 from an lvalue subroutine now produces this
1409 warning [perl #31946].
1410
1411 =item *
1412
1413 L<Useless use of \E|perldiag/"Useless use of \E">
1414
1415 C<\E> does nothing unless preceded by C<\Q>, C<\L> or C<\U>.
1416
1417 =back
1418
1419 =head2 Removed Errors
1420
1421 =over
1422
1423 =item *
1424
1425 "sort is now a reserved word"
1426
1427 This error used to occur when C<sort> was called without arguments,
1428 followed by C<;> or C<)>.  (E.g., C<sort;> would die, but C<{sort}> was
1429 OK.)  This error message was added in Perl 3 to catch code like
1430 C<close(sort)> which would no longer work.  More than two decades later,
1431 this message is no longer appropriate.  Now C<sort> without arguments is
1432 always allowed, and returns an empty list, as it did in those cases
1433 where it was already allowed [perl #90030].
1434
1435 =back
1436
1437 =head2 Changes to Existing Diagnostics
1438
1439 =over 4
1440
1441 =item *
1442
1443 The "Applying pattern match..." or similar warning produced when an
1444 array or hash is on the left-hand side of the C<=~> operator now
1445 mentions the name of the variable.
1446
1447 =item *
1448
1449 The "Attempt to free non-existent shared string" has had the spelling
1450 of "non-existent" corrected to "nonexistent".  It was already listed
1451 with the correct spelling in L<perldiag>.
1452
1453 =item *
1454
1455 The error messages for using C<default> and C<when> outside of a
1456 topicalizer have been standardised to match the messages for C<continue>
1457 and loop controls.  They now read 'Can't "default" outside a
1458 topicalizer' and 'Can't "when" outside a topicalizer'.  They both used
1459 to be 'Can't use when() outside a topicalizer' [perl #91514].
1460
1461 =item *
1462
1463 The message, "Code point 0x%X is not Unicode, no properties match it;
1464 all inverse properties do" has been changed to "Code point 0x%X is not
1465 Unicode, all \p{} matches fail; all \P{} matches succeed".
1466
1467 =item *
1468
1469 Redefinition warnings for constant subroutines used to be mandatory,
1470 even occurring under C<no warnings>.  Now they respect the L<warnings>
1471 pragma.
1472
1473 =item *
1474
1475 The "glob failed" warning message is now suppressible via C<no warnings>
1476 [perl #111656].
1477
1478 =item *
1479
1480 The L<Invalid version format|perldiag/"Invalid version format (%s)">
1481 error message now says "negative version number" within the parentheses,
1482 rather than "non-numeric data", for negative numbers.
1483
1484 =item *
1485
1486 The two warnings
1487 L<Possible attempt to put comments in qw() list|perldiag/"Possible attempt to put comments in qw() list">
1488 and
1489 L<Possible attempt to separate words with commas|perldiag/"Possible attempt to separate words with commas">
1490 are no longer mutually exclusive: the same C<qw> construct may produce
1491 both.
1492
1493 =item *
1494
1495 The uninitialized warning for C<y///r> when C<$_> is implicit and
1496 undefined now mentions the variable name, just like the non-/r variation
1497 of the operator.
1498
1499 =item *
1500
1501 The 'Use of "foo" without parentheses is ambiguous' warning has been
1502 extended to apply also to user-defined subroutines with a (;$)
1503 prototype, and not just to built-in functions.
1504
1505 =item *
1506
1507 Warnings that mention the names of lexical (C<my>) variables with
1508 Unicode characters in them now respect the presence or absence of the
1509 C<:utf8> layer on the output handle, instead of outputting UTF8
1510 regardless.  Also, the correct names are included in the strings passed
1511 to C<$SIG{__WARN__}> handlers, rather than the raw UTF8 bytes.
1512
1513 =back
1514
1515 =head1 Utility Changes
1516
1517 =head3 L<h2ph>
1518
1519 =over 4
1520
1521 =item *
1522
1523 L<h2ph> used to generate code of the form
1524
1525   unless(defined(&FOO)) {
1526     sub FOO () {42;}
1527   }
1528
1529 But the subroutine is a compile-time declaration, and is hence unaffected
1530 by the condition.  It has now been corrected to emit a string C<eval>
1531 around the subroutine [perl #99368].
1532
1533 =back
1534
1535 =head3 L<splain>
1536
1537 =over 4
1538
1539 =item *
1540
1541 F<splain> no longer emits backtraces with the first line number repeated.
1542
1543 This:
1544
1545     Uncaught exception from user code:
1546             Cannot fwiddle the fwuddle at -e line 1.
1547      at -e line 1
1548             main::baz() called at -e line 1
1549             main::bar() called at -e line 1
1550             main::foo() called at -e line 1
1551
1552 has become this:
1553
1554     Uncaught exception from user code:
1555             Cannot fwiddle the fwuddle at -e line 1.
1556             main::baz() called at -e line 1
1557             main::bar() called at -e line 1
1558             main::foo() called at -e line 1
1559
1560 =item *
1561
1562 Some error messages consist of multiple lines that are listed as separate
1563 entries in L<perldiag>.  splain has been taught to find the separate
1564 entries in these cases, instead of simply failing to find the message.
1565
1566 =back
1567
1568 =head3 L<zipdetails>
1569
1570 =over 4
1571
1572 =item *
1573
1574 This is a new utility, included as part of an
1575 L<IO::Compress::Base> upgrade.
1576
1577 L<zipdetails> displays information about the internal record structure
1578 of the zip file.  It is not concerned with displaying any details of
1579 the compressed data stored in the zip file.
1580
1581 =back
1582
1583 =head1 Configuration and Compilation
1584
1585 =over 4
1586
1587 =item *
1588
1589 The C<-Dusesitecustomize> and C<-Duserelocatableinc> options now work
1590 together properly.
1591
1592 =item *
1593
1594 F<regexp.h> has been modified for compatibility with GCC's B<-Werror>
1595 option, as used by some projects that include perl's header files (5.14.1).
1596
1597 =item *
1598
1599 C<USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}> have been added the output of perl -V
1600 as they have affect the behaviour of the interpreter binary (albeit only
1601 in a small area).
1602
1603 =item *
1604
1605 The code and tests for L<IPC::Open2> have been moved from F<ext/IPC-Open2>
1606 into F<ext/IPC-Open3>, as C<IPC::Open2::open2()> is implemented as a thin
1607 wrapper around C<IPC::Open3::_open3()>, and hence is very tightly coupled to
1608 it.
1609
1610 =item *
1611
1612 The magic types and magic vtables are now generated from data in a new script
1613 F<regen/mg_vtable.pl>, instead of being
1614 maintained by hand.  As different EBCDIC
1615 variants can't agree on the code point for '~', the character to code point
1616 conversion is done at build time by F<generate_uudmap> to a new generated header
1617 F<mg_data.h>.  C<PL_vtbl_bm> and C<PL_vtbl_fm> are now defined by the
1618 pre-processor as C<PL_vtbl_regexp>, instead of being distinct C variables.
1619 C<PL_vtbl_sig> has been removed.
1620
1621 =item *
1622
1623 Building with C<-DPERL_GLOBAL_STRUCT>
1624 works again.  This configuration is not
1625 generally used.
1626
1627 =item *
1628
1629 Perl configured with I<MAD> now correctly frees C<MADPROP> structures when
1630 OPs are freed.  C<MADPROP>s are now allocated with
1631 C<PerlMemShared_malloc()>
1632
1633 =back
1634
1635 =head1 Testing
1636
1637 XXX Any significant changes to the testing of a freshly built perl should be
1638 listed here.  Changes which create B<new> files in F<t/> go here as do any
1639 large changes to the testing harness (e.g. when parallel testing was added).
1640 Changes to existing files in F<t/> aren't worth summarising, although the bugs
1641 that they represent may be covered elsewhere.
1642
1643 [ List each test improvement as a =item entry ]
1644
1645 =over 4
1646
1647 =item *
1648
1649 XXX
1650
1651 =back
1652
1653 =head1 Platform Support
1654
1655 XXX Any changes to platform support should be listed in the sections below.
1656
1657 [ Within the sections, list each platform as a =item entry with specific
1658 changes as paragraphs below it. ]
1659
1660 =head2 New Platforms
1661
1662 XXX List any platforms that this version of perl compiles on, that previous
1663 versions did not. These will either be enabled by new files in the F<hints/>
1664 directories, or new subdirectories and F<README> files at the top level of the
1665 source tree.
1666
1667 =over 4
1668
1669 =item XXX-some-platform
1670
1671 XXX
1672
1673 =back
1674
1675 =head2 Discontinued Platforms
1676
1677 XXX List any platforms that this version of perl no longer compiles on.
1678
1679 =over 4
1680
1681 =item XXX-some-platform
1682
1683 XXX
1684
1685 =back
1686
1687 =head2 Platform-Specific Notes
1688
1689 =head3 Cygwin
1690
1691 =over 4
1692
1693 =item *
1694
1695 Since version 1.7, Cygwin supports native UTF-8 paths.  If Perl is built
1696 under that environment, directory and filenames will be UTF-8 encoded.
1697
1698 Cygwin does not initialize all original Win32 environment variables.  See
1699 F<README.cygwin> for a discussion of the newly-added
1700 C<Cygwin::sync_winenv()> function [perl #110190] and for
1701 further links.
1702
1703 =back
1704
1705 =head3 VMS
1706
1707 =over 4
1708
1709 =item *
1710
1711 Remove unnecessary includes, fix miscellaneous compiler warnings and
1712 close some unclosed comments on F<vms/vms.c>.
1713
1714 Remove sockadapt layer from the VMS build.
1715
1716 =item *
1717
1718 Explicit support for VMS versions prior to v7.0 and DEC C versions
1719 prior to v6.0 has been removed.
1720
1721 =item *
1722
1723 Since Perl 5.10.1, the home-grown C<stat> wrapper has been unable to
1724 distinguish between a directory name containing an underscore and an
1725 otherwise-identical filename containing a dot in the same position
1726 (e.g., t/test_pl as a directory and t/test.pl as a file).  This problem
1727 has been corrected.
1728
1729 =item *
1730
1731 The build on VMS now allows names of the resulting symbols in C code for
1732 Perl longer than 31 characters.  Symbols like
1733 C<Perl__it_was_the_best_of_times_it_was_the_worst_of_times> can now be
1734 created freely without causing the VMS linker to seize up.
1735
1736 =back
1737
1738 =head3 GNU/Hurd
1739
1740 Numerous build and test failures on GNU/Hurd have been resolved with hints
1741 for building DBM modules, detection of the library search path, and enabling
1742 of large file support.
1743
1744 =head3 OpenVOS
1745
1746 Perl is now built with dynamic linking on OpenVOS, the minimum supported
1747 version of which is now Release 17.1.0.
1748
1749 =head3 SunOS
1750
1751 The CC workshop C++ compiler is now detected and used on systems that ship
1752 without cc.
1753
1754 =head1 Internal Changes
1755
1756 =over 4
1757
1758 =item *
1759
1760 There are now feature bundle hints in C<PL_hints> (C<$^H>) that version
1761 declarations use, to avoid having to load F<feature.pm>.  One setting of
1762 the hint bits indicates a "custom" feature bundle, which means that the
1763 entries in C<%^H> still apply.  F<feature.pm> uses that.
1764
1765 The C<HINT_FEATURE_MASK> macro is defined in F<perl.h> along with other
1766 hints.  Other macros for setting and testing features and bundles are in
1767 the new F<feature.h>.  C<FEATURE_IS_ENABLED> (which has moved to
1768 F<feature.h>) is no longer used throughout the codebase, but more specific
1769 macros, e.g., C<FEATURE_SAY_IS_ENABLED>, that are defined in F<feature.h>.
1770
1771 =item *
1772
1773 F<lib/feature.pm> is now a generated file, created by the new
1774 F<regen/feature.pl> script, which also generates F<feature.h>.
1775
1776 =item *
1777
1778 Tied arrays are now always C<AvREAL>.  If C<@_> or C<DB::args> is tied, it
1779 is reified first, to make sure this is always the case.
1780
1781 =item *
1782
1783 The C<is_gv_magical_sv> function has been eliminated and merged with
1784 C<gv_fetchpvn_flags>.  It used to be called to determine whether a GV
1785 should be autovivified in rvalue context.  Now it has been replaced with a
1786 new C<GV_ADDMG> flag (not part of the API).
1787
1788 =item *
1789
1790 Padlists are now marked C<AvREAL>; i.e., reference-counted.  They have
1791 always been reference-counted, but were not marked real, because F<pad.c>
1792 did its own clean-up, instead of using the usual clean-up code in F<sv.c>.
1793 That caused problems in thread cloning, so now the C<AvREAL> flag is on,
1794 but is turned off in F<pad.c> right before the padlist is freed (after
1795 F<pad.c> has done its custom freeing of the pads).
1796
1797 =item *
1798
1799 All the C files that make up the Perl core have been converted to UTF-8.
1800
1801 =back
1802
1803 =head1 Selected Bug Fixes
1804
1805 =head2 Regular expressions and character classes
1806
1807 XXX Is it possible to merge some of these items?
1808
1809 =over 4
1810
1811 =item *
1812
1813 C</[[:ascii:]]/> and C</[[:blank:]]/> now use locale rules under
1814 C<use locale> when the platform supports that.  Previously, they used
1815 the platform's native character set.
1816
1817 =item *
1818
1819 C<m/[[:ascii:]]/i> and C</\p{ASCII}/i> now match identically (when not
1820 under a differing locale).  This fixes a regression introduced in 5.14
1821 in which the first expression could match characters outside of ASCII,
1822 such as the KELVIN SIGN.
1823
1824 =item *
1825
1826 C</.*/g> would sometimes refuse to match at the end of a string that ends
1827 with "\n".  This has been fixed [perl #109206].
1828
1829 =item *
1830
1831 Starting with 5.12.0, Perl used to get its internal bookkeeping muddled up
1832 after assigning C<${ qr// }> to a hash element and locking it with
1833 L<Hash::Util>.  This could result in double frees, crashes or erratic
1834 behaviour.
1835
1836 =item *
1837
1838 The new (in 5.14.0) regular expression modifier C</a> when repeated like
1839 C</aa> forbids the characters outside the ASCII range that match
1840 characters inside that range from matching under C</i>.  This did not
1841 work under some circumstances, all involving alternation, such as:
1842
1843  "\N{KELVIN SIGN}" =~ /k|foo/iaa;
1844
1845 succeeded inappropriately.  This is now fixed.
1846
1847 =item *
1848
1849 5.14.0 introduced some memory leaks in regular expression character
1850 classes such as C<[\w\s]>, which have now been fixed. (5.14.1)
1851
1852 =item *
1853
1854 An edge case in regular expression matching could potentially loop.
1855 This happened only under C</i> in bracketed character classes that have
1856 characters with multi-character folds, and the target string to match
1857 against includes the first portion of the fold, followed by another
1858 character that has a multi-character fold that begins with the remaining
1859 portion of the fold, plus some more.
1860
1861  "s\N{U+DF}" =~ /[\x{DF}foo]/i
1862
1863 is one such case.  C<\xDF> folds to C<"ss">. (5.14.1)
1864
1865 =item *
1866
1867 A few characters in regular expression pattern matches did not
1868 match correctly in some circumstances, all involving C</i>.  The
1869 affected characters are:
1870 COMBINING GREEK YPOGEGRAMMENI,
1871 GREEK CAPITAL LETTER IOTA,
1872 GREEK CAPITAL LETTER UPSILON,
1873 GREEK PROSGEGRAMMENI,
1874 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
1875 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
1876 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA,
1877 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
1878 LATIN SMALL LETTER LONG S,
1879 LATIN SMALL LIGATURE LONG S T,
1880 and
1881 LATIN SMALL LIGATURE ST.
1882
1883 =item *
1884
1885 A memory leak regression in regular expression compilation
1886 under threading has been fixed.
1887
1888 =item *
1889
1890 A regression introduced in 5.13.6 has
1891 been fixed.  This involved an inverted
1892 bracketed character class in a regular expression that consisted solely
1893 of a Unicode property.  That property wasn't getting inverted outside the
1894 Latin1 range.
1895
1896 =item *
1897
1898 Three problematic Unicode characters now work better in regex pattern matching under C</i>
1899
1900 In the past, three Unicode characters:
1901 LATIN SMALL LETTER SHARP S,
1902 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
1903 and
1904 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
1905 along with the sequences that they fold to
1906 (including "ss" in the case of LATIN SMALL LETTER SHARP S),
1907 did not properly match under C</i>.  5.14.0 fixed some of these cases,
1908 but introduced others, including a panic when one of the characters or
1909 sequences was used in the C<(?(DEFINE)> regular expression predicate.
1910 The known bugs that were introduced in 5.14 have now been fixed; as well
1911 as some other edge cases that have never worked until now.  All these
1912 involve using the characters and sequences outside bracketed character
1913 classes under C</i>.  This closes [perl #98546].
1914
1915 There remain known problems when using certain characters with
1916 multi-character folds inside bracketed character classes, including such
1917 constructs as C<qr/[\N{LATIN SMALL LETTER SHARP}a-z]/i>.  These
1918 remaining bugs are addressed in [perl #89774].
1919
1920 =item *
1921
1922 RT #78266: The regex engine has been leaking memory when accessing
1923 named captures that weren't matched as part of a regex ever since 5.10
1924 when they were introduced, e.g. this would consume over a hundred MB of
1925 memory:
1926
1927     for (1..10_000_000) {
1928         if ("foo" =~ /(foo|(?<capture>bar))?/) {
1929             my $capture = $+{capture}
1930         }
1931     }
1932     system "ps -o rss $$"'
1933
1934 =item *
1935
1936 In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
1937 opposite case.  This has been fixed [perl #101970].
1938
1939 =item *
1940
1941 A regular expression match with an overloaded object on the right-hand side
1942 would in some cases stringify the object too many times.
1943
1944 =item *
1945
1946 A regression has been fixed that was introduced in 5.14, in C</i>
1947 regular expression matching, in which a match improperly fails if the
1948 pattern is in UTF-8, the target string is not, and a Latin-1 character
1949 precedes a character in the string that should match the pattern.
1950 [perl #101710]
1951
1952 =item *
1953
1954 In case-insensitive regular expression pattern matching, no longer on
1955 UTF-8 encoded strings does the scan for the start of match only look at
1956 the first possible position.  This caused matches such as
1957 C<"f\x{FB00}" =~ /ff/i> to fail.
1958
1959 =item *
1960
1961 The regexp optimiser no longer crashes on debugging builds when merging
1962 fixed-string nodes with inconvenient contents.
1963
1964 =item *
1965
1966 A panic involving the combination of the regular expression modifiers
1967 C</aa> and the C<\b> escape sequence introduced in 5.14.0 has been
1968 fixed [perl #95964].
1969
1970 =item *
1971
1972 The combination of the regular expression modifiers C</aa> and the C<\b>
1973 and C<\B> escape sequences did not work properly on UTF-8 encoded
1974 strings.  All non-ASCII characters under C</aa> should be treated as
1975 non-word characters, but what was happening was that Unicode rules were
1976 used to determine wordness/non-wordness for non-ASCII characters.  This
1977 is now fixed [perl #95968].
1978
1979 =item *
1980
1981 C<< (?foo: ...) >> no longer loses passed in character set.
1982
1983 =item *
1984
1985 The trie optimisation used to have problems with alternations containing
1986 an empty C<(?:)>, causing C<< "x" =~ /\A(?>(?:(?:)A|B|C?x))\z/ >> not to
1987 match, whereas it should [perl #111842].
1988
1989 =back
1990
1991 =head2 Formats
1992
1993 =over
1994
1995 =item *
1996
1997 A number of edge cases have been fixed with formats and C<formline>;
1998 in particular, where the format itself is potentially variable (such as
1999 with ties and overloading), and where the format and data differ in their
2000 encoding.  In both these cases, it used to possible for the output to be
2001 corrupted [perl #91032].
2002
2003 =item *
2004
2005 C<formline> no longer converts its argument into a string in-place.  So
2006 passing a reference to C<formline> no longer destroys the reference
2007 [perl #79532].
2008
2009 =back
2010
2011 =head2 Copy-on-write scalars
2012
2013 Copy-on-write or shared hash key scalars
2014 were introduced in 5.8.0, but most Perl code
2015 did not encounter them (they were used mostly internally).  Perl
2016 5.10.0 extended them, such that assigning C<__PACKAGE__> or a
2017 hash key to a scalar would make it copy-on-write.  Several parts
2018 of Perl were not updated to account for them, but have now been fixed.
2019
2020 =over
2021
2022 =item *
2023
2024 C<utf8::decode> had a nasty bug that would modify copy-on-write scalars'
2025 string buffers in place (i.e., skipping the copy).  This could result in
2026 hashes having two elements with the same key [perl #91834].
2027
2028 =item *
2029
2030 Lvalue subroutines were not allowing COW scalars to be returned.  This was
2031 fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0, but list context
2032 was not fixed until this release.
2033
2034 =item *
2035
2036 Elements of restricted hashes (see the L<fields> pragma) containing
2037 copy-on-write values couldn't be deleted, nor could such hashes be cleared
2038 (C<%hash = ()>).
2039
2040 =item *
2041
2042 Localising a tied variable used to make it read-only if it contained a
2043 copy-on-write string.
2044
2045 =item *
2046
2047 Assigning a copy-on-write string to a stash
2048 element no longer causes a double free.  Regardless of this change, the
2049 results of such assignments are still undefined.
2050
2051 =item *
2052
2053 Assigning a copy-on-write string to a tied variable no longer stops that
2054 variable from being tied if it happens to be a PVMG or PVLV internally.
2055
2056 =item *
2057
2058 Doing a substitution on a tied variable returning a copy-on-write
2059 scalar used to cause an assertion failure or an "Attempt to free
2060 nonexistent shared string" warning.
2061
2062 =item *
2063
2064 This one is a regression from 5.12: In 5.14.0, the bitwise assignment
2065 operators C<|=>, C<^=> and C<&=> started leaving the left-hand side
2066 undefined if it happened to be a copy-on-write string [perl #108480].
2067
2068 =item *
2069
2070 L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
2071 See L</Updated Modules and Pragmata>, above.
2072
2073 XXX That section is empty.
2074
2075 =back
2076
2077 =head2 Lvalue subroutines
2078
2079 =over
2080
2081 =item *
2082
2083 Explicit return now returns the actual argument passed to return, instead
2084 of copying it [perl #72724, #72706].
2085
2086 =item *
2087
2088 Lvalue subroutines used to enforce lvalue syntax (i.e., whatever can go on
2089 the left-hand side of C<=>) for the last statement and the arguments to
2090 return.  Since lvalue subroutines are not always called in lvalue context,
2091 this restriction has been lifted.
2092
2093 =item *
2094
2095 Lvalue subroutines are less restrictive as to what values can be returned.
2096 It used to croak on values returned by C<shift> and C<delete> and from
2097 other subroutines, but no longer does so [perl #71172].
2098
2099 =item *
2100
2101 Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
2102 context.  In fact, all subroutines used to, but regular subs were fixed in
2103 Perl 5.8.2.  Now lvalue subroutines have been likewise fixed.
2104
2105 =item *
2106
2107 Autovivification now works on values returned from lvalue subroutines
2108 [perl #7946], as does returning C<keys> in lvalue context.
2109
2110 =item *
2111
2112 Lvalue subroutines used to copy their return values in rvalue context.  Not
2113 only was this a waste of CPU cycles, but it also caused bugs.  A C<($)>
2114 prototype would cause an lvalue sub to copy its return value [perl #51408],
2115 and C<while(lvalue_sub() =~ m/.../g) { ... }> would loop endlessly
2116 [perl #78680].
2117
2118 =item *
2119
2120 When called in potential lvalue context
2121 (e.g., subroutine arguments or a list
2122 passed to C<for>), lvalue subroutines used to copy
2123 any read-only value that was returned.  E.g., C< sub :lvalue { $] } >
2124 would not return C<$]>, but a copy of it.
2125
2126 =item *
2127
2128 When called in potential lvalue context, an lvalue subroutine returning
2129 arrays or hashes used to bind the arrays or hashes to scalar variables,
2130 resulting in bugs.  This was fixed in 5.14.0 if an array were the first
2131 thing returned from the subroutine (but not for C<$scalar, @array> or
2132 hashes being returned).  Now a more general fix has been applied
2133 [perl #23790].
2134
2135 =item *
2136
2137 Method calls whose arguments were all surrounded with C<my()> or C<our()>
2138 (as in C<< $object->method(my($a,$b)) >>) used to force lvalue context on
2139 the subroutine.  This would prevent lvalue methods from returning certain
2140 values.
2141
2142 =item *
2143
2144 Lvalue sub calls that are not determined to be such at compile time
2145 (C<&$name> or &{"name"}) are no longer exempt from strict refs if they
2146 occur in the last statement of an lvalue subroutine [perl #102486].
2147
2148 =item *
2149
2150 Sub calls whose subs are not visible at compile time, if
2151 they occurred in the last statement of an lvalue subroutine,
2152 would reject non-lvalue subroutines and die with "Can't modify non-lvalue
2153 subroutine call" [perl #102486].
2154
2155 Non-lvalue sub calls whose subs I<are> visible at compile time exhibited
2156 the opposite bug.  If the call occurred in the last statement of an lvalue
2157 subroutine, there would be no error when the lvalue sub was called in
2158 lvalue context.  Perl would blindly assign to the temporary value returned
2159 by the non-lvalue subroutine.
2160
2161 =item *
2162
2163 C<AUTOLOAD> routines used to take precedence over the actual sub being
2164 called (i.e., when autoloading wasn't needed), for sub calls in lvalue or
2165 potential lvalue context, if the subroutine was not visible at compile
2166 time.
2167
2168 =item *
2169
2170 Applying the C<:lvalue> attribute to an XSUB or to an aliased subroutine
2171 stub with C<< sub foo :lvalue; >> syntax stopped working in Perl 5.12.
2172 This has been fixed.
2173
2174 =item *
2175
2176 Applying the :lvalue attribute to subroutine that is already defined does
2177 not work properly, as the attribute changes the way the sub is compiled.
2178 Hence, Perl 5.12 began warning when an attempt is made to apply the
2179 attribute to an already defined sub.  In such cases, the attribute is
2180 discarded.
2181
2182 But the change in 5.12 missed the case where custom attributes are also
2183 present: that case still silently and ineffectively applied the attribute.
2184 That omission has now been corrected.  C<sub foo :lvalue :Whatever> (when
2185 C<foo> is already defined) now warns about the :lvalue attribute, and does
2186 not apply it.
2187
2188 =item *
2189
2190 A bug affecting lvalue context propagation through nested lvalue subroutine
2191 calls has been fixed.  Previously, returning a value in nested rvalue
2192 context would be treated as lvalue context by the inner subroutine call,
2193 resulting in some values (such as read-only values) being rejected.
2194
2195 =back
2196
2197 =head2 Compile-time hints
2198
2199 =over
2200
2201 =item *
2202
2203 Tying C<%^H> no longer causes perl to crash or ignore the contents of
2204 C<%^H> when entering a compilation scope [perl #106282].
2205
2206 =item *
2207
2208 C<eval $string> and C<require> used not to
2209 localise C<%^H> during compilation if it
2210 was empty at the time the C<eval> call itself was compiled.  This could
2211 lead to scary side effects, like C<use re "/m"> enabling other flags that
2212 the surrounding code was trying to enable for its caller [perl #68750].
2213
2214 =item *
2215
2216 C<eval $string> and C<require> no longer localise hints (C<$^H> and C<%^H>)
2217 at run time, but only during compilation of the $string or required file.
2218 This makes C<BEGIN { $^H{foo}=7 }> equivalent to
2219 C<BEGIN { eval '$^H{foo}=7' }> [perl #70151].
2220
2221 =item *
2222
2223 Creating a BEGIN block from XS code (via C<newXS> or C<newATTRSUB>) would,
2224 on completion, make the hints of the current compiling code the current
2225 hints.  This could cause warnings to occur in a non-warning scope.
2226
2227 =back
2228
2229 =head2 Fixes related to hashes and arrays
2230
2231 =over
2232
2233 =item *
2234
2235 A bug has been fixed that would cause a "Use of freed value in iteration"
2236 error if the next two hash elements that would be iterated over are
2237 deleted [perl #85026]. (5.14.1)
2238
2239 =item *
2240
2241 Deleting the current hash iterator (the hash element that would be returend
2242 by the next call to C<each>) in void context used not to free it
2243 [perl #85026].
2244
2245 =item *
2246
2247 Deletion of methods via C<delete $Class::{method}> syntax used to update
2248 method caches if called in void context, but not scalar or list context.
2249
2250 =item *
2251
2252 When hash elements are deleted in void context, the internal hash entry is
2253 now freed before the value is freed, to prevent destructors called by that
2254 latter freeing from seeing the hash in an inconsistent state.  It was
2255 possible to cause double-frees if the destructor freed the hash itself
2256 [perl #100340].
2257
2258 =item *
2259
2260 A C<keys> optimisation in Perl 5.12.0 to make it faster on empty hashes
2261 caused C<each> not to reset the iterator if called after the last element
2262 was deleted.
2263
2264 =item *
2265
2266 Freeing deeply nested hashes no longer crashes [perl #44225].
2267
2268 =item *
2269
2270 It is possible from XS code to create hashes with elements that have no
2271 values.  The hash element and slice operators used to crash
2272 when handling these in lvalue context.  They now
2273 produce a "Modification of non-creatable hash value attempted" error
2274 message.
2275
2276 =item *
2277
2278 If list assignment to a hash or array triggered destructors that freed the
2279 hash or array itself, a crash would ensue.  This is no longer the case
2280 [perl #107440].
2281
2282 =item *
2283
2284 It used to be possible to free the typeglob of a localised array or hash
2285 (e.g., C<local @{"x"}; delete $::{x}>), resulting in a crash on scope exit.
2286
2287 =back
2288
2289 =head2 Weak references
2290
2291 =over
2292
2293 =item *
2294
2295 Weakening the first argument to an automatically-invoked C<DESTROY> method
2296 could result in erroneous "DESTROY created new reference" errors or
2297 crashes.  Now it is an error to weaken a read-only reference.
2298
2299 =item *
2300
2301 Weak references to lexical hashes going out of scope were not going stale
2302 (becoming undefined), but continued to point to the hash.
2303
2304 =item *
2305
2306 Weak references to lexical variables going out of scope are now broken
2307 before any magical methods (e.g., DESTROY on a tie object) are called.
2308 This prevents such methods from modifying the variable that will be seen
2309 the next time the scope is entered.
2310
2311 =item *
2312
2313 Creating a weak reference to an @ISA array or accessing the array index
2314 (C<$#ISA>) could result in confused internal bookkeeping for elements
2315 subsequently added to the @ISA array.  For instance, creating a weak
2316 reference to the element itself could push that weak reference on to @ISA;
2317 and elements added after use of C<$#ISA> would be ignored by method lookup
2318 [perl #85670].
2319
2320 =back
2321
2322 =head2 Support for embedded nulls
2323
2324 Some parts of Perl did not work correctly with nulls (C<chr 0>) embedded in
2325 strings.  That meant that, for instance, C<< $m = "a\0b"; foo->$m >> would
2326 call the "a" method, instead of the actual method name contained in $m.
2327 These parts of perl have been fixed to support nulls:
2328
2329 =over
2330
2331 =item *
2332
2333 Method names
2334
2335 =item *
2336
2337 Typeglob names (including filehandle and subroutine names)
2338
2339 =item *
2340
2341 Package names, including the return value of C<ref()>
2342
2343 =item *
2344
2345 Typeglob elements (C<*foo{"THING\0stuff"}>)
2346
2347 =item *
2348
2349 Signal names
2350
2351 =item *
2352
2353 Various warnings and error messages that mention variable names or values,
2354 methods, etc.
2355
2356 =back
2357
2358 One side effect of these changes is that blessing into "\0" no longer
2359 causes C<ref()> to return false.
2360
2361 =head2 Filetests and C<stat>
2362
2363 The term "filetests" refers to the operators that consist of a hyphen
2364 followed by a single letter: C<-r>, C<-x>, C<-M>, etc.  The term "stacked"
2365 when applied to filetests means followed by another filetest operator
2366 sharing the same operand, as in C<-r -x -w $fooo>.
2367
2368 =over
2369
2370 =item *
2371
2372 C<stat> produces more consistent warnings.  It no longer warns for "_"
2373 [perl #71002] and no longer skips the warning at times for other unopened
2374 handles.  It no longer warns about an unopened handle when the operating
2375 system's C<fstat> function fails.
2376
2377 =item *
2378
2379 C<stat> would sometimes return negative numbers for large inode numbers,
2380 because it was using the wrong internal C type. [perl #84590]
2381
2382 =item *
2383
2384 C<lstat> is documented to fall back to C<stat> (with a warning) when given
2385 a filehandle.  When passed an IO reference, it was actually doing the
2386 equivalent of S<C<stat _>> and ignoring the handle.
2387
2388 =item *
2389
2390 C<-T _> with no preceding C<stat> used to produce a
2391 confusing "uninitialized" warning, even though there
2392 is no visible uninitialized value to speak of.
2393
2394 =item *
2395
2396 C<-T>, C<-B>, C<-l> and C<-t> now work
2397 when stacked with other filetest operators
2398 [perl #77388].
2399
2400 =item *
2401
2402 In 5.14.0, filetest ops (C<-r>, C<-x>, etc.) started calling FETCH on a
2403 tied argument belonging to the previous argument to a list operator, if
2404 called with a bareword argument or no argument at all.  This has been
2405 fixed, so C<push @foo, $tied, -r> no longer calls FETCH on C<$tied>.
2406
2407 =item *
2408
2409 In Perl 5.6, C<-l> followed by anything other than a bareword would treat
2410 its argument as a file name.  That was changed in 5.8 for glob references
2411 (C<\*foo>), but not for globs themselves (C<*foo>).  C<-l> started
2412 returning C<undef> for glob references without setting the last
2413 stat buffer that the "_" handle uses, but only if warnings
2414 were turned on.  With warnings off, it was the same as 5.6.
2415 In other words, it was simply buggy and inconsistent.  Now the 5.6
2416 behaviour has been restored.
2417
2418 =item *
2419
2420 C<-l> followed by a bareword no longer "eats" the previous argument to
2421 the list operator in whose argument list it resides.  Hence,
2422 C<print "bar", -l foo> now actually prints "bar", because C<-l>
2423 on longer eats it.
2424
2425 =item *
2426
2427 Perl keeps several internal variables to keep track of the last stat
2428 buffer, from which file(handle) it originated, what type it was, and
2429 whether the last stat succeeded.
2430
2431 There were various cases where these could get out of synch, resulting in
2432 inconsistent or erratic behaviour in edge cases (every mention of C<-T>
2433 applies to C<-B> as well):
2434
2435 =over
2436
2437 =item *
2438
2439 C<-T I<HANDLE>>, even though it does a C<stat>, was not resetting the last
2440 stat type, so an C<lstat _> following it would merrily return the wrong
2441 results.  Also, it was not setting the success status.
2442
2443 =item *
2444
2445 Freeing the handle last used by C<stat> or a filetest could result in
2446 S<C<-T _>> using an unrelated handle.
2447
2448 =item *
2449
2450 C<stat> with an IO reference would not reset the stat type or record the
2451 filehandle for S<C<-T _>> to use.
2452
2453 =item *
2454
2455 Fatal warnings could cause the stat buffer not to be reset
2456 for a filetest operator on an unopened filehandle or C<-l> on any handle.
2457 Fatal warnings also stopped C<-T> from setting C<$!>.
2458
2459 =item *
2460
2461 When the last stat was on an unreadable file, C<-T _> is supposed to
2462 return C<undef>, leaving the last stat buffer unchanged.  But it was
2463 setting the stat type, causing C<lstat _> to stop working.
2464
2465 =item *
2466
2467 C<-T I<FILENAME>> was not resetting the internal stat buffers for
2468 unreadable files.
2469
2470 =back
2471
2472 These have all been fixed.
2473
2474 =back
2475
2476 =head2 Version objects and vstrings
2477
2478 =over
2479
2480 =item *
2481
2482 The bitwise complement operator (and possibly other operators, too) when
2483 passed a vstring would leave vstring magic attached to the return value,
2484 even though the string had changed.  This meant that
2485 C<< version->new(~v1.2.3) >> would create a version looking like "v1.2.3"
2486 even though the string passed to C<< version->new >> was actually
2487 "\376\375\374".  This also caused L<B::Deparse> to deparse C<~v1.2.3>
2488 incorrectly, without the C<~> [perl #29070].
2489
2490 =item *
2491
2492 Assigning a vstring to a magic (e.g., tied, C<$!>) variable and then
2493 assigning something else used to blow away all the magic.  This meant that
2494 tied variables would come undone, C<$!> would stop getting updated on
2495 failed system calls, C<$|> would stop setting autoflush, and other
2496 mischief would take place.  This has been fixed.
2497
2498 =item *
2499
2500 C<< version->new("version") >> and C<printf "%vd", "version"> no longer
2501 crash [perl #102586].
2502
2503 =item *
2504
2505 Version comparisons, such as those that happen implicitly with C<use
2506 v5.43>, no longer cause locale settings to change [perl #105784].
2507
2508 =item *
2509
2510 Version objects no longer cause memory leaks in boolean context
2511 [perl #109762].
2512
2513 =back
2514
2515 =head2 Tied variables
2516
2517 =over
2518
2519 =item *
2520
2521 Various cases in which FETCH was being ignored or called too many times
2522 have been fixed:
2523
2524 =over
2525
2526 =item *
2527
2528 C<PerlIO::get_layers> [perl #97956]
2529
2530 =item *
2531
2532 C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> when $tied holds a
2533 reference.
2534
2535 =item *
2536
2537 Four-argument C<select>
2538
2539 =item *
2540
2541 A tied buffer passed to C<sysread>
2542
2543 =item *
2544
2545 C<< $tied .= <> >>
2546
2547 =item *
2548
2549 Three-argument C<open>, the third being a tied file handle
2550 (as in C<< open $fh, ">&", $tied >>)
2551
2552 =item *
2553
2554 C<sort> with a reference to a tied glob for the comparison routine.
2555
2556 =item *
2557
2558 C<..> and C<...> in list context [perl #53554].
2559
2560 =item *
2561
2562 C<${$tied}>, C<@{$tied}>, C<%{$tied}> and C<*{$tied}> where the tied
2563 variable returns a string (C<&{}> was unaffected)
2564
2565 =item *
2566
2567 C<defined ${ $tied_variable }>
2568
2569 =item *
2570
2571 Various functions that take a filehandle argument in rvalue context
2572 (C<close>, C<readline>, etc.) [perl #97482]
2573
2574 =item *
2575
2576 Some cases of dereferencing a complex expression, such as
2577 C<${ (), $tied } = 1>, used to call C<FETCH> multiple times, but now call
2578 it once.
2579
2580 =item *
2581
2582 C<$tied-E<gt>method> where $tied returns a package name--even resulting in
2583 a failure to call the method, due to memory corruption
2584
2585 =item *
2586
2587 Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied>
2588
2589 =item *
2590
2591 C<chdir>, C<chmod>, C<chown>, C<utime>, C<truncate>, C<stat>, C<lstat> and
2592 the filetest ops (C<-r>, C<-x>, etc.)
2593
2594 =back
2595
2596 =item *
2597
2598 C<caller> sets C<@DB::args> to the subroutine arguments when called from
2599 the DB package.  It used to crash when doing so if C<@DB::args> happened to
2600 be tied.  Now it croaks instead.
2601
2602 =item *
2603
2604 Tying an element of %ENV or C<%^H> and then deleting that element would
2605 result in a call to the tie object's DELETE method, even though tying the
2606 element itself is supposed to be equivalent to tying a scalar (the element
2607 is, of course, a scalar) [perl #67490].
2608
2609 =item *
2610
2611 When Perl autovivifies an element of a tied array or hash (which entails
2612 calling STORE with a new reference), it now calls FETCH immediately after
2613 the STORE, instead of assuming that FETCH would have returned the same
2614 reference.  This can make it easier to implement tied objects [perl #35865, #43011].
2615
2616 =item *
2617
2618 Four-argument C<select> no longer produces its "Non-string passed as
2619 bitmask" warning on tied or tainted variables that are strings.
2620
2621 =item *
2622
2623 Localising a tied scalar that returns a typeglob no longer stops it from
2624 being tied till the end of the scope.
2625
2626 =item *
2627
2628 Attempting to C<goto> out of a tied handle method used to cause memory
2629 corruption or crashes.  Now it produces an error message instead
2630 [perl #8611].
2631
2632 =item *
2633
2634 A bug has been fixed that occurs when a tied variable is used as a
2635 subroutine reference:  if the last thing assigned to or returned from the
2636 variable was a reference or typeglob, the C<\&$tied> could either crash or
2637 return the wrong subroutine.  The reference case is a regression introduced
2638 in Perl 5.10.0.  For typeglobs, it has probably never worked till now.
2639
2640 =back
2641
2642 =head2 "Uninitialized" warnings
2643
2644 =over
2645
2646 =item *
2647
2648 Various functions that take a filehandle argument in rvalue context
2649 (C<close>, C<readline>, etc.) used to warn twice for an undefined handle
2650 [perl #97482].
2651
2652 =item *
2653
2654 C<dbmopen> now only warns once, rather than three times, if the mode
2655 argument is C<undef> [perl #90064].
2656
2657 =item *
2658
2659 The C<+=> operator does not usually warn when the left-hand side is
2660 C<undef>, but it was doing so for tied variables.  This has been fixed
2661 [perl #44895].
2662
2663 =item *
2664
2665 A bug fix in Perl 5.14 introduced a new bug, causing "uninitialized"
2666 warnings to report the wrong variable if the operator in question had
2667 two operands and one was C<%{...}> or C<@{...}>.  This has been fixed
2668 [perl #103766].
2669
2670 =item *
2671
2672 C<..> and C<...> in list context now mention the name of the variable in
2673 "uninitialized" warnings for string (as opposed to numeric) ranges.
2674
2675 =back
2676
2677 =head2 Last-accessed filehandle
2678
2679 Perl has an internal variable that stores the last filehandle to be
2680 accessed.  It is used by C<$.> and by C<tell> and C<eof> without
2681 arguments.
2682
2683 =over
2684
2685 =item *
2686
2687 It used to be possible to set this internal variable to a glob copy and
2688 then modify that glob copy to be something other than a glob, and still
2689 have the last-accessed filehandle associated with the variable after
2690 assigning a glob to it again:
2691
2692     my $foo = *STDOUT;  # $foo is a glob copy
2693     <$foo>;             # $foo is now the last-accessed handle
2694     $foo = 3;           # no longer a glob
2695     $foo = *STDERR;     # still the last-accessed handle
2696
2697 Now the C<$foo = 3> assignment unsets that internal variable, so there
2698 is no last-accessed filehandle, just as if C<< <$foo> >> had never
2699 happened.
2700
2701 This also prevents some unrelated handle from becoming the last-accessed
2702 handle if $foo falls out of scope and the same internal SV gets used for
2703 another handle [perl #97988].
2704
2705 =item *
2706
2707 A regression in 5.14 caused these statements not to set that internal
2708 variable:
2709
2710     my $fh = *STDOUT;
2711     tell $fh;
2712     eof  $fh;
2713     seek $fh, 0,0;
2714     tell     *$fh;
2715     eof      *$fh;
2716     seek     *$fh, 0,0;
2717     readline *$fh;
2718
2719 This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
2720 is not clear how to fix it [perl #106536].
2721
2722 =back
2723
2724 =head2 Redefinition warnings
2725
2726 =over
2727
2728 =item *
2729
2730 Subroutines from the C<autouse> namespace are once more exempt from
2731 redefinition warnings.  This used to work in 5.005, but was broken in
2732 5.6 for most subroutines.  For subs created via XS that redefine
2733 subroutines from the C<autouse> package, this stopped working in 5.10.
2734
2735 =item *
2736
2737 New XSUBs now produce redefinition warnings if they overwrite existing
2738 subs, as they did in 5.8.x.  (The C<autouse> logic was reversed in
2739 5.10-14.  Only subroutines from the C<autouse> namespace would warn
2740 when clobbered.)
2741
2742 =item *
2743
2744 C<newCONSTSUB> used to use compile-time warning hints, instead of
2745 run-time hints.  The following code should never produce a redefinition
2746 warning, but it used to, if C<newCONSTSUB> redefined an existing
2747 subroutine:
2748
2749     use warnings;
2750     BEGIN {
2751         no warnings;
2752         some_XS_function_that_calls_new_CONSTSUB();
2753     }
2754
2755 =item *
2756
2757 Redefinition warnings for constant subroutines are on by default (what
2758 are known as severe warnings in L<perldiag>).  This was only the case
2759 when it was a glob assignment or declaration of a Perl subroutine that
2760 caused the warning.  If the creation of XSUBs triggered the warning, it
2761 was not a default warning.  This has been corrected.
2762
2763 =item *
2764
2765 The internal check to see whether a redefinition warning should occur
2766 used to emit "uninitialized" warnings in cases like this:
2767
2768     use warnings "uninitialized";
2769     use constant {u => undef, v => undef};
2770     sub foo(){u}
2771     sub foo(){v}
2772
2773 =back
2774
2775 =head2 Overloading
2776
2777 =over
2778
2779 =item *
2780
2781 Arithmetic assignment (C<$left += $right>) involving overloaded objects
2782 that rely on the 'nomethod' override no longer segfault when the left
2783 operand is not overloaded.
2784
2785 =item *
2786
2787 Errors that occur when methods cannot be found during overloading now
2788 mention the correct package name, as they did in 5.8.x, instead of
2789 erroneously mentioning the "overload" package, as they have since 5.10.0.
2790
2791 =item *
2792
2793 Undefining C<%overload::> no longer causes a crash.
2794
2795 =back
2796
2797 =head2 Fixes to the C<sort> operator
2798
2799 =over
2800
2801 =item *
2802
2803 C<sort> was not treating C<sub {}> and C<sub {()}> as equivalent when
2804 such a sub was provided as the comparison routine.  It used to croak on
2805 C<sub {()}>.
2806
2807 =item *
2808
2809 C<sort> now works once more with custom sort routines that are XSUBs.  It
2810 stopped working in 5.10.0.
2811
2812 =item *
2813
2814 C<sort> with a constant for a custom sort routine, although it produces
2815 unsorted results, no longer crashes.  It started crashing in 5.10.0.
2816
2817 =item *
2818
2819 Warnings emitted by C<sort> when a custom comparison routine returns a
2820 non-numeric value now contain "in sort" and show the line number of the
2821 C<sort> operator, rather than the last line of the comparison routine.  The
2822 warnings also occur now only if warnings are enabled in the scope where
2823 C<sort> occurs.  Previously the warnings would occur if enabled in the
2824 comparison routine's scope.
2825
2826 =item *
2827
2828 C<< sort { $a <=> $b } >>, which is optimised internally, now produces
2829 "uninitialized" warnings for NaNs (not-a-number values), since C<< <=> >>
2830 returns C<undef> for those.  This brings it in line with
2831 S<C<< sort { 1; $a <=> $b } >>> and other more complex cases, which are not
2832 optimised [perl #94390].
2833
2834 =back
2835
2836 =head2 Fixes affecting the debugger
2837
2838 =over
2839
2840 =item *
2841
2842 F<dumpvar.pl>, and consequently the C<x> command in the debugger, have been
2843 fixed to handle objects blessed into classes whose names contain "=".  The
2844 contents of such objects used not to be dumped [perl #101814].
2845
2846 =item *
2847
2848 The "R" command for restarting a debugger session has been fixed to work on
2849 Windows, or any other system lacking a C<POSIX::_SC_OPEN_MAX> constant
2850 [perl #87740].
2851
2852 =item *
2853
2854 The C<#line 42 foo> directive used not to update the arrays of lines used
2855 by the debugger if it occurred in a string eval.  This was partially fixed
2856 in 5.14, but it only worked for a single C<#line 42 foo> in each eval.  Now
2857 it works for multiple.
2858
2859 =item *
2860
2861 When subroutine calls are intercepted by the debugger, the name of the
2862 subroutine or a reference to it is stored in C<$DB::sub>, for the debugger
2863 to access.  In some cases (such as C<$foo = *bar; undef *bar; &$foo>)
2864 C<$DB::sub> would be set to a name that could not be used to find the
2865 subroutine, and so the debugger's attempt to call it would fail.  Now the
2866 check to see whether a reference is needed is more robust, so those
2867 problems should not happen anymore [rt.cpan.org #69862].
2868
2869 =item *
2870
2871 Every subroutine has a filename associated with it that the debugger uses.
2872 The one associated with constant subroutines used to be misallocated when
2873 cloned under threads.  Consequently, debugging threaded applications could
2874 result in memory corruption [perl #96126].
2875
2876 =back
2877
2878 =head2 Other notable fixes
2879
2880 =over
2881
2882 =item *
2883
2884 C<~~> now correctly handles the precedence of Any~~Object, and is not tricked
2885 by an overloaded object on the left-hand side.
2886
2887 =item *
2888
2889 C<quotemeta> now quotes consistently the same non-ASCII characters under
2890 C<use feature 'unicode_strings'>, regardless of whether the string is
2891 encoded in UTF-8 or not, hence fixing the last vestiges (we hope) of the
2892 infamous L<perlunicode/The "Unicode Bug">.  [perl #77654].
2893
2894 Which of these code points is quoted has changed, based on Unicode's
2895 recommendations.  See L<perlfunc/quotemeta> for details.
2896
2897 =item *
2898
2899 C<newHVhv> and tied hashes
2900
2901 The C<newHVhv> XS function now works on tied hashes, instead of crashing or
2902 returning an empty hash.
2903
2904 =item *
2905
2906 No warning for C<open(foo::bar)>
2907
2908 When one writes C<open foo || die>, which used to work in Perl 4, a
2909 "Precedence problem" warning is produced.  This warning used erroneously to
2910 apply to fully-qualified bareword handle names not followed by C<||>.  This
2911 has been corrected.
2912
2913 =item *
2914
2915 C<select> and package aliasing
2916
2917 After package aliasing (C<*foo:: = *bar::>), C<select> with 0 or 1 argument
2918 would sometimes return a name that could not be used to refer to the
2919 filehandle, or sometimes it would return C<undef> even when a filehandle
2920 was selected.  Now it returns a typeglob reference in such cases.
2921
2922 =item *
2923
2924 C<PerlIO::get_layers> and numbers
2925
2926 C<PerlIO::get_layers> no longer ignores some arguments that it thinks are
2927 numeric, while treating others as filehandle names.  It is now consistent
2928 for flat scalars (i.e., not references).
2929
2930 =item *
2931
2932 Unrecognised switches on C<#!> line
2933
2934 If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
2935 there, perl dies with "Can't emulate...".
2936
2937 It used to produce the same message for switches that perl did not
2938 recognise at all, whether on the command line or the C<#!> line.
2939
2940 Now it produces the "Unrecognized switch" error message [perl #104288].
2941
2942 =item *
2943
2944 C<system> and SIGCHLD
2945
2946 C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
2947 signal handler from stealing the exit status [perl #105700].
2948
2949 =item *
2950
2951 C<(s)printf>'s %n formatting code
2952
2953 The %n formatting code, which causes the number of characters to be
2954 assigned to the next argument to C<printf> or C<sprintf> now actually
2955 assigns the number of characters, instead of the number of bytes.
2956
2957 It also works now with special lvalue functions like C<substr> and with
2958 nonexistent hash and array elements [perl #3471, #103492].
2959
2960 =item *
2961
2962 Typeglobs and threads
2963
2964 Typeglobs returned from threads are no longer cloned if the parent thread
2965 already has a glob with the same name.  This means that returned
2966 subroutines will now assign to the right package variables [perl #107366].
2967
2968 =item *
2969
2970 C<local $_>
2971
2972 In Perl 5.14, C<local $_> was changed to create a new variable not tied to
2973 anything, even if $_ was tied before that.  But, due to an oversight, it
2974 would still call FETCH once on a tied $_ before replacing it with the new
2975 variable.  This has been fixed [perl #105912].
2976
2977 =item *
2978
2979 Returning tied variables
2980
2981 When returning a value from a non-lvalue subroutine, Perl copies the value.
2982 Sometimes it cheats for the sake of speed, and does not copy the value if
2983 it makes no observable difference.  This optimisation was erroneously
2984 allowing the copy to be skipped on tied variables, causing a difference in
2985 behaviour depending on the tied variable's reference count.  This has been
2986 fixed [perl #95548].
2987
2988 =item *
2989
2990 C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
2991
2992 =item *
2993
2994 Freeing $_ inside C<grep> or C<map>
2995
2996 Freeing $_ inside a C<grep> or C<map> block or a code block embedded in a
2997 regular expression used to result in double frees [perl #92254, #92256].
2998
2999 =item *
3000
3001 C<@&> and C<$&>
3002
3003 Mentioning a variable named "&" other than C<$&> (i.e., C<@&> or C<%&>) no
3004 longer stops C<$&> from working.  The same applies to variables named "'"
3005 and "`" [perl #24237].
3006
3007 =item *
3008
3009 Return value of C<eval>
3010
3011 C<eval> returns C<undef> in scalar context or an empty list in list
3012 context when there is a run-time error.  When C<eval> was passed a
3013 string in list context and a syntax error occurred, it used to return a
3014 list containing a single undefined element.  Now it returns an empty
3015 list in list context for all errors [perl #80630].
3016
3017 =item *
3018
3019 C<goto &func> no longer crashes, but produces an error message, when
3020 the unwinding of the current subroutine's scope fires a destructor that
3021 undefines the subroutine being "goneto" [perl #99850].
3022
3023 =item *
3024
3025 Creating a C<UNIVERSAL::AUTOLOAD> sub no longer stops C<%+>, C<%-> and
3026 C<%!> from working some of the time [perl #105024].
3027
3028 =item *
3029
3030 When presented with malformed UTF-8 input, the XS-callable functions
3031 C<is_utf8_string()>, C<is_utf8_string_loc()>, and
3032 C<is_utf8_string_loclen()> could read beyond the end of the input
3033 string by up to 12 bytes.  This no longer happens.  [perl #32080].
3034 However, currently, C<is_utf8_char()> still has this defect, see
3035 L</is_utf8_char()> above.
3036
3037 =item *
3038
3039 Perl now holds an extra reference count on the package that code is
3040 currently compiling in.  This means that the following code no longer crashes [perl #101486]:
3041
3042     package Foo;
3043     BEGIN {*Foo:: = *Bar::}
3044     sub foo;
3045
3046 =item *
3047
3048 The C<x> repetition operator no longer crashes on 64-bit builds with large
3049 repeat counts [perl #94560].
3050
3051 =item *
3052
3053 On OSes other than VMS, Perl's C<glob> operator (and the C<< <...> >> form)
3054 use L<File::Glob> underneath.  L<File::Glob> splits the pattern into words,
3055 before feeding each word to its C<bsd_glob> function.
3056
3057 There were several inconsistencies in the way the split was done.  Now
3058 quotation marks (' and ") are always treated as shell-style word delimiters
3059 (that allow whitespace as part of a word) and backslashes are always
3060 preserved, unless they exist to escape quotation marks.  Before, those
3061 would only sometimes be the case, depending on whether the pattern
3062 contained whitespace.  Also, escaped whitespace at the end of the pattern
3063 is no longer stripped [perl #40470].
3064
3065 =item *
3066
3067 C<CORE::glob> now works as a way to call the default globbing function.  It
3068 used to respect overrides, despite the C<CORE::> prefix.
3069
3070 =item *
3071
3072 The C-level C<pregcomp> function could become confused as to whether the
3073 pattern was in UTF8 if the pattern was an overloaded, tied, or otherwise
3074 magical scalar [perl #101940].
3075
3076 =item *
3077
3078 Calling C<require> on an implicit C<$_> when C<*CORE::GLOBAL::require> has
3079 been overridden does not segfault anymore, and C<$_> is now passed to the
3080 overriding subroutine [perl #78260].
3081
3082 =item *
3083
3084 In Perl 5.14.0, C<$tainted ~~ @array> stopped working properly.  Sometimes
3085 it would erroneously fail (when C<$tainted> contained a string that occurs
3086 in the array I<after> the first element) or erroneously succeed (when
3087 C<undef> occurred after the first element) [perl #93590].
3088
3089 =item *
3090
3091 C<use> and C<require> are no longer affected by the I/O layers active in
3092 the caller's scope (enabled by L<open.pm|open>) [perl #96008].
3093
3094 =item *
3095
3096 C<our $::é; $é> (which is invalid) no longer produces the "Compilation
3097 error at lib/utf8_heavy.pl..." error message, which it started emitting in
3098 5.10.0 [perl #99984].
3099
3100 =item *
3101
3102 On 64-bit systems, C<read()> now understands large string offsets beyond
3103 the 32-bit range.
3104
3105 =item *
3106
3107 Errors that occur when processing subroutine attributes no longer cause the
3108 subroutine's op tree to leak.
3109
3110 =item *
3111
3112 Passing the same constant subroutine to both C<index> and C<formline> no
3113 longer causes one or the other to fail [perl #89218]. (5.14.1)
3114
3115 =item *
3116
3117 List assignment to lexical variables declared with attributes in the same
3118 statement (C<my ($x,@y) : blimp = (72,94)>) stopped working in Perl 5.8.0.
3119 It has now been fixed.
3120
3121 =item *
3122
3123 Perl 5.10.0 introduced some faulty logic that made "U*" in the middle of
3124 a pack template equivalent to "U0" if the input string was empty.  This has
3125 been fixed [perl #90160].
3126
3127 =item *
3128
3129 Destructors on objects were not called during global destruction on objects
3130 that were not referenced by any scalars.  This could happen if an array
3131 element were blessed (e.g., C<bless \$a[0]>) or if a closure referenced a
3132 blessed variable (C<bless \my @a; sub foo { @a }>).
3133
3134 Now there is an extra pass during global destruction to fire destructors on
3135 any objects that might be left after the usual passes that check for
3136 objects referenced by scalars [perl #36347].
3137
3138 This bug fix was added in Perl 5.13.9, but caused problems with some CPAN
3139 modules that were relying on the bug.  Since it was so close to Perl
3140 5.14.0, the fix was reverted in 5.13.10, to allow more time for the modules
3141 to adapt.  Hopefully they will be fixed soon (see L</Known Problems>,
3142 below).
3143
3144 =item *
3145
3146 C<given> was not calling set-magic on the implicit lexical C<$_> that it
3147 uses.  This meant, for example, that C<pos> would be remembered from one
3148 execution of the same C<given> block to the next, even if the input were a
3149 different variable [perl #84526].
3150
3151 =item *
3152
3153 Fixed a case where it was possible that a freed buffer may have been read
3154 from when parsing a here document [perl #90128]. (5.14.1)
3155
3156 =item *
3157
3158 C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
3159 inside a C<while> condition [perl #90888].
3160
3161 =item *
3162
3163 In @INC filters (subroutines returned by subroutines in @INC), $_ used to
3164 misbehave: If returned from a subroutine, it would not be copied, but the
3165 variable itself would be returned; and freeing $_ (e.g., with C<undef *_>)
3166 would cause perl to crash.  This has been fixed [perl #91880].
3167
3168 =item *
3169
3170 An ASCII single quote (') in a symbol name is meant to be equivalent to a
3171 double colon (::) except at the end of the name.  It was not equivalent if
3172 followed by a null character, but now it is [perl #88138].
3173
3174 =item *
3175
3176 The abbreviations for four C1 control characters C<MW> C<PM>, C<RI>, and
3177 C<ST> were previously unrecognized by C<\N{}>, vianame(), and
3178 string_vianame().
3179
3180 =item *
3181
3182 Some cases of threads crashing due to memory allocation during cloning have
3183 been fixed [perl #90006].
3184
3185 =item *
3186
3187 Perl skips copying values returned from a subroutine if it thinks the value
3188 is not in use elsewhere.  Due to faulty logic, this would happen with the
3189 result of C<delete>, C<shift> or C<splice>, even if the result was
3190 referenced elsewhere.  So C<< \sub { delete $_[0] }->($x) >> would return a
3191 reference to C<$x>.  This has been fixed [perl #91844].
3192
3193 =item *
3194
3195 The C<prototype> function no longer dies for the C<__FILE__>, C<__LINE__>
3196 and C<__PACKAGE__> directives.  It now returns an empty-string prototype
3197 for them, because they are syntactically very similar to nullary functions
3198 like C<time>.
3199
3200 =item *
3201
3202 C<prototype> now returns C<undef> for all overridable infix operators,
3203 such as C<eq>, which are not callable in any way resembling functions.
3204 It used to return incorrect prototypes for some and die for others
3205 [perl #94984].
3206
3207 =item *
3208
3209 Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
3210 element that is a glob copy no longer causes subsequent assignment to it to
3211 corrupt the glob, and unlocking a hash element that holds a copy-on-write
3212 scalar no longer causes modifications to that scalar to modify other
3213 scalars that were sharing the same string buffer.
3214
3215 =item *
3216
3217 C<when> blocks are now capable of returning variables declared inside the
3218 enclosing C<given> block [perl #93548].
3219
3220 =item *
3221
3222 A problem with context propagation when a C<do> block is an argument to
3223 C<return> has been fixed.  It used to cause C<undef> to be returned in
3224 some cases of a C<return> inside an C<if> block which itself is followed by
3225 another C<return>.
3226
3227 =item *
3228
3229 Calling C<index> with a tainted constant no longer causes constants in
3230 subsequently compiled code to become tainted [perl #64804].
3231
3232 =item *
3233
3234 Use of lexical (C<my>) variables in code blocks embedded in regular
3235 expressions will no longer result in memory corruption or crashes.
3236
3237 Nevertheless, these code blocks are still experimental, as there are still
3238 problems with the wrong variables being closed over (in loops for instance)
3239 and with abnormal exiting (e.g., C<die>) causing memory corruption.
3240
3241 =item *
3242
3243 The C<SvIsCOW> C macro now returns false for read-only copies of typeglobs,
3244 such as those created by:
3245
3246   $hash{elem} = *foo;
3247   Hash::Util::lock_value %hash, 'elem';
3248
3249 It used to return true.
3250
3251 =item *
3252
3253 Assignment to C<$^A> (the format output accumulator) now recalculates
3254 the number of lines output.
3255
3256 =item *
3257
3258 Locking a subroutine (via C<lock &sub>) is no longer a compile-time error
3259 for regular subs.  For lvalue subroutines, it no longer tries to return the
3260 sub as a scalar, resulting in strange side effects like C<ref \$_>
3261 returning "CODE" in some instances.
3262
3263 C<lock &sub> is now a run-time error if L<threads::shared> is loaded (a
3264 no-op otherwise), but that may be rectified in a future version.
3265
3266 =item *
3267
3268 The prototypes of several built-in functions--C<getprotobynumber>, C<lock>,
3269 C<not> and C<select>--have been corrected, or at least are now closer to
3270 reality than before.
3271
3272 =item *
3273
3274 Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
3275 working for the rest of the block.t
3276
3277 =item *
3278
3279 The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
3280 cause a panic error message when attempting to match at the end of the
3281 string [perl #96354].
3282
3283 =item *
3284
3285 For list assignments like C<($a,$b) = ($b,$a)>, Perl has to make a copy of
3286 the items on the right-hand side before assignment them to the left.  For
3287 efficiency's sake, it assigns the values on the right straight to the items
3288 on the left no variable is mentioned on both sides, as in
3289 C<($a,$b) = ($c,$d)>.  The logic for determining when it can cheat was
3290 faulty, in that C<&&> and C<||> on the right-hand side could fool it.  So
3291 C<($a,$b) = $some_true_value && ($b,$a)> would end up assigning the value
3292 of C<$b> to both scalars.
3293
3294 =item *
3295
3296 Perl no longer tries to apply lvalue context to the string in
3297 C<("string", $variable) ||= 1> (which used to be an error).  Since the
3298 left-hand side of C<||=> is evaluated in scalar context, that's a scalar
3299 comma operator, which gives all but the last item void context.  There is
3300 no such thing as void lvalue context, so it was a mistake for Perl to try
3301 to force it [perl #96942].
3302
3303 =item *
3304
3305 C<caller> no longer leaks memory when called from the DB package if
3306 C<@DB::args> was assigned to after the first call to C<caller>.  L<Carp>
3307 was triggering this bug [perl #97010].
3308
3309 =item *
3310
3311 C<defined(${"..."})>, C<defined(*{"..."})>, etc., used to
3312 return true for most, but not all built-in variables, if
3313 they had not been used yet.  Many times that new built-in
3314 variables were added in past versions, this construct was
3315 not taken into account, so this affected C<${^GLOBAL_PHASE}> and
3316 C<${^UTF8CACHE}>, among others.  It also used to return false if the
3317 package name was given as well (C<${"::!"}>) [perl #97978, #97492].
3318
3319 =item *
3320
3321 Perl 5.10.0 introduced a similar bug: C<defined(*{"foo"})> where "foo"
3322 represents the name of a built-in global variable used to return false if
3323 the variable had never been used before, but only on the I<first> call.
3324 This, too, has been fixed.
3325
3326 =item *
3327
3328 C<close> and similar filehandle functions, when called on built-in global
3329 variables (like C<$+>), used to die if the variable happened to hold the
3330 undefined value, instead of producing the usual "Use of uninitialized
3331 value" warning.
3332
3333 =item *
3334
3335 When autovivified file handles were introduced in Perl 5.6.0, C<readline>
3336 was inadvertently made to autovivify when called as C<readline($foo)> (but
3337 not as C<E<lt>$fooE<gt>>).  It has now been fixed never to autovivify.
3338
3339 =item *
3340
3341 Calling an undefined anonymous subroutine (e.g., what $x holds after
3342 C<undef &{$x = sub{}}>) used to cause a "Not a CODE reference" error, which
3343 has been corrected to "Undefined subroutine called" [perl #71154].
3344
3345 =item *
3346
3347 Causing C<@DB::args> to be freed between uses of C<caller> no longer
3348 results in a crash [perl #93320].
3349
3350 =item *
3351
3352 Since 5.6.0, C<*{ ... }> has been inconsistent in how it treats undefined
3353 values.  It would die in strict mode or lvalue context for most undefined
3354 values, but would be treated as the empty string (with a warning) for the
3355 specific scalar return by C<undef()> (C<&PL_sv_undef> internally).  This
3356 has been corrected.  C<undef()> is now treated like other undefined
3357 scalars, as in Perl 5.005.
3358
3359 =item *
3360
3361 C<setpgrp($foo)> used to be equivalent to C<($foo, setpgrp)>, because
3362 C<setpgrp> was ignoring its argument if there was just one.  Now it is
3363 equivalent to C<setpgrp($foo,0)>.
3364
3365 =item *
3366
3367 If things were arranged in memory the right way, it was possible for
3368 thread joining to emit "Attempt to free unreferenced scalar" warnings if
3369 C<caller> had been used from the C<DB> package prior to thread creation,
3370 due to the way pads were reference-counted and cloned [perl #98092].
3371
3372 =item *
3373
3374 C<given> was not scoping its implicit $_ properly, resulting in memory
3375 leaks or "Variable is not available" warnings [perl #94682].
3376
3377 =item *
3378
3379 C<shmread> was not setting the scalar flags correctly when reading from
3380 shared memory, causing the existing cached numeric representation in the
3381 scalar to persist [perl #98480].
3382
3383 =item *
3384
3385 Under miniperl (used to configure modules when perl itself is built),
3386 C<glob> now clears %ENV before calling csh, since the latter croaks on some
3387 systems if it does not like the contents of the LS_COLORS enviroment
3388 variable [perl #98662].
3389
3390 =item *
3391
3392 C<++> and C<--> now work on copies of globs, instead of dying.
3393
3394 =item *
3395
3396 C<splice()> doesn't warn when truncating
3397
3398 You can now limit the size of an array using C<splice(@a,MAX_LEN)> without
3399 worrying about warnings.
3400
3401 =item *
3402
3403 The C<SvPVutf8> C function no longer tries to modify its argument,
3404 resulting in errors [perl #108994].
3405
3406 =item *
3407
3408 C<SvPVutf8> now works properly with magical variables.
3409
3410 =item *
3411
3412 C<SvPVbyte> now works properly non-PVs.
3413
3414 =item *
3415
3416 C<< $$ >> is no longer tainted.  Since this value comes directly from
3417 C<< getpid() >>, it is always safe.
3418
3419 =item *
3420
3421 The parser no longer leaks a filehandle if STDIN was closed before parsing
3422 started [perl #37033].
3423
3424 =item *
3425
3426 C<< die; >> with a non-reference, non-string, or magical (e.g., tainted)
3427 value in $@ now properly
3428 propagates that value [perl #111654].
3429
3430 =back
3431
3432 =head1 Known Problems
3433
3434 =over 4
3435
3436 =item *
3437
3438 On Solaris, we have two kinds of failure.
3439
3440 If F<make> is Sun's F<make≥>, we get an error about a badly formed macro
3441 assignment in the F<Makefile>.  That happens when F<./Configure> tries to
3442 make depends.  F<Configure> then exits  0, but further F<make>-ing fails.
3443
3444 If F<make> is F<gmake>, F<Configure> completes, then we get errors related
3445 to F</usr/include/stdbool.h>
3446
3447 =item *
3448
3449 The following CPAN modules have test failures with perl 5.16.  Patches have
3450 been submitted for all of these, so hopefully there will be new releases
3451 soon:
3452
3453 =over
3454
3455 =item *
3456
3457 L<Date::Pcalc> version 6.1
3458
3459 =item *
3460
3461 L<Encode::JP::Mobile> version 0.27
3462
3463 =item *
3464
3465 L<Module::CPANTS::Analyse> version 0.85
3466
3467 This fails due to problems in L<Module::Find> 0.10 and L<File::MMagic>
3468 1.27.
3469
3470 =item *
3471
3472 L<PerlIO::Util> version 0.72
3473
3474 =back
3475
3476 =back
3477
3478 =head1 Obituary
3479
3480 XXX If any significant core contributor has died, we've added a short obituary
3481 here.
3482
3483 =head1 Acknowledgements
3484
3485 XXX Generate this with:
3486
3487   perl Porting/acknowledgements.pl v5.14.0..HEAD
3488
3489 =head1 Reporting Bugs
3490
3491 If you find what you think is a bug, you might check the articles
3492 recently posted to the comp.lang.perl.misc newsgroup and the perl
3493 bug database at L<http://rt.perl.org/perlbug/>.  There may also be
3494 information at L<http://www.perl.org/>, the Perl Home Page.
3495
3496 If you believe you have an unreported bug, please run the L<perlbug>
3497 program included with your release.  Be sure to trim your bug down
3498 to a tiny but sufficient test case.  Your bug report, along with the
3499 output of C<perl -V>, will be sent off to perlbug@perl.org to be
3500 analysed by the Perl porting team.
3501
3502 If the bug you are reporting has security implications, which make it
3503 inappropriate to send to a publicly archived mailing list, then please
3504 send it to perl5-security-report@perl.org.  This points to a closed
3505 subscription unarchived mailing list, which includes all the core
3506 committers, who will be able to help assess the impact of issues, figure
3507 out a resolution, and help co-ordinate the release of patches to
3508 mitigate or fix the problem across all platforms on which Perl is
3509 supported.  Please only use this address for security issues in the Perl
3510 core, not for modules independently distributed on CPAN.
3511
3512 =head1 SEE ALSO
3513
3514 The F<Changes> file for an explanation of how to view exhaustive details
3515 on what changed.
3516
3517 The F<INSTALL> file for how to build Perl.
3518
3519 The F<README> file for general stuff.
3520
3521 The F<Artistic> and F<Copying> files for copyright information.
3522
3523 =cut