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