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