This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
eaab5180976ad1678854b4029eef0ddeff57cdf0
[perl5.git] / pod / perldelta.pod
1 =encoding utf8
2
3 =head1 NAME
4
5 perldelta - 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 were treated as punctuation variables.
288
289 Also, single-character Unicode punctuation variables (like C<$‰>) 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 Malformed UTF-8 input could cause attempts to read beyond the end of the buffer
503
504 Two new XS-accessible functions, C<utf8_to_uvchr_buf()> and
505 C<utf8_to_uvuni_buf()> are now available to prevent this, and the Perl
506 core has been converted to use them.
507 See L</Internal Changes>.
508
509 =head2 C<File::Glob::bsd_glob()> memory error with GLOB_ALTDIRFUNC (CVE-2011-2728).
510
511 Calling C<File::Glob::bsd_glob> with the unsupported flag
512 GLOB_ALTDIRFUNC would cause an access violation / segfault.  A Perl
513 program that accepts a flags value from an external source could expose
514 itself to denial of service or arbitrary code execution attacks.  There
515 are no known exploits in the wild.  The problem has been corrected by
516 explicitly disabling all unsupported flags and setting unused function
517 pointers to null.  Bug reported by Clément Lecigne.
518
519 =head2 Privileges are now set correctly when assigning to C<$(>
520
521 A hypothetical bug (probably non-exploitable in practice) due to the
522 incorrect setting of the effective group ID while setting C<$(> has been
523 fixed.  The bug would only have affected systems that have C<setresgid()>
524 but not C<setregid()>, but no such systems are known to exist.
525
526 =head1 Deprecations
527
528 =head2 Don't read the Unicode data base files in F<lib/unicore>
529
530 It is now deprecated to directly read the Unicode data base files.
531 These are stored in the F<lib/unicore> directory.  Instead, you should
532 use the new functions in L<Unicode::UCD>.  These provide a stable API,
533 and give complete information.
534
535 Perl may at some point in the future change or remove the files.  The
536 file which applications were most likely to have used is
537 F<lib/unicore/ToDigit.pl>.  L<Unicode::UCD/prop_invmap()> can be used to
538 get at its data instead.
539
540 =head2 XS functions C<is_utf8_char()>, C<utf8_to_uvchr()> and
541 C<utf8_to_uvuni()>
542
543 This function is deprecated because it could read beyond the end of the
544 input string.  Use the new L<is_utf8_char_buf()|/Added is_utf8_char_buf()>,
545 C<utf8_to_uvchr_buf()> and C<utf8_to_uvuni_buf()> instead.
546
547 =head1 Future Deprecations
548
549 This section serves as a notice of features that are I<likely> to be
550 removed or L<deprecated|perlpolicy/deprecated> in the next release of
551 perl (5.18.0).  If your code depends on these features, you should
552 contact the Perl 5 Porters via the L<mailing
553 list|http://lists.perl.org/list/perl5-porters.html> or L<perlbug> to
554 explain your use case and inform the deprecation process.
555
556 =head2 Core Modules
557
558 These modules may be marked as deprecated I<from the core>.  This only
559 means that they will no longer be installed by default with the core
560 distribution, but will remain available on the CPAN.
561
562 =over
563
564 =item *
565
566 CPANPLUS
567
568 =item *
569
570 Filter::Simple
571
572 =item *
573
574 PerlIO::mmap
575
576 =item *
577
578 Pod::Parser, Pod::LaTeX
579
580 =item *
581
582 SelfLoader
583
584 =item *
585
586 Text::Soundex
587
588 =item *
589
590 Thread.pm
591
592 =back
593
594 =head2 Platforms with no supporting programmers:
595
596 These platforms will probably have their
597 special build support removed during the
598 5.17.0 development series.
599
600 =over
601
602 =item *
603
604 BeOS
605
606 =item *
607
608 djgpp
609
610 =item *
611
612 dgux
613
614 =item *
615
616 EPOC
617
618 =item *
619
620 MPE/iX
621
622 =item *
623
624 Rhapsody
625
626 =item *
627
628 UTS
629
630 =item *
631
632 VM/ESA
633
634 =back
635
636 =head2 Other Future Deprecations
637
638 =over
639
640 =item *
641
642 Swapping of $< and $>
643
644 For more information about this future deprecation, see L<the relevant RT
645 ticket|https://rt.perl.org/rt3/Ticket/Display.html?id=96212>.
646
647 =item *
648
649 sfio, stdio
650
651 Perl supports being built without PerlIO proper, using a stdio or sfio
652 wrapper instead.  A perl build like this will not support IO layers and
653 thus Unicode IO, making it rather handicapped.
654
655 PerlIO supports a C<stdio> layer if stdio use is desired, and similarly a
656 sfio layer could be produced.
657
658 =item *
659
660 Unescaped literal C<< "{" >> in regular expressions.
661
662 It is planned starting in v5.20 to require a literal C<"{"> to be
663 escaped by, for example, preceding it with a backslash.  In v5.18, a
664 deprecated warning message will be emitted for all such uses.  Note that
665 this only affects patterns which are to match a literal C<"{">.  Other
666 uses of this character, such as part of a quantifier or sequence like in
667 the ones below are completely unaffected:
668
669     /foo{3,5}/
670     /\p{Alphabetic}/
671     /\N{DIGIT ZERO}
672
673 The removal of this will allow extensions to pattern syntax, and better
674 error checking of existing syntax.  See L<perlre/Quantifiers> for an
675 example.
676
677 =back
678
679 =head1 Incompatible Changes
680
681 =head2 Special blocks called in void context
682
683 Special blocks (C<BEGIN>, C<CHECK>, C<INIT>, C<UNITCHECK>, C<END>) are now
684 called in void context.  This avoids wasteful copying of the result of the
685 last statement [perl #108794].
686
687 =head2 The C<overloading> pragma and regexp objects
688
689 With C<no overloading>, regular expression objects returned by C<qr//> are
690 now stringified as "Regexp=REGEXP(0xbe600d)" instead of the regular
691 expression itself [perl #108780].
692
693 =head2 Two XS typemap Entries removed
694
695 Two presumably unused XS typemap entries have been removed from the
696 core typemap: T_DATAUNIT and T_CALLBACK.  If you are, against all odds,
697 a user of these, please see the instructions on how to restore them
698 in L<perlxstypemap>.
699
700 =head2 Unicode 6.1 has incompatibilities with Unicode 6.0
701
702 These are detailed in L</Supports (almost) Unicode 6.1> above.
703 You can compile this version of Perl to use Unicode 6.0.  See
704 L<perlunicode/Hacking Perl to work on earlier Unicode versions (for very serious hackers only)>.
705
706 =head2 Borland compiler
707
708 All support for the Borland compiler has been dropped.  The code had not
709 worked for a long time anyway.
710
711 =head2 Certain deprecated Unicode properties are no longer supported by default
712
713 Perl should never have exposed certain Unicode properties that are used
714 by Unicode internally and not meant to be publicly available.  Use of
715 these has generated deprecated warning messages since Perl 5.12.  The
716 removed properties are Other_Alphabetic,
717 Other_Default_Ignorable_Code_Point, Other_Grapheme_Extend,
718 Other_ID_Continue, Other_ID_Start, Other_Lowercase, Other_Math, and
719 Other_Uppercase.
720
721 Perl may be recompiled to include any or all of them; instructions are
722 given in
723 L<perluniprops/Unicode character properties that are NOT accepted by Perl>.
724
725 =head2 Dereferencing IO thingies as typeglobs
726
727 The C<*{...}> operator, when passed a reference to an IO thingy (as in
728 C<*{*STDIN{IO}}>), creates a new typeglob containing just that IO object.
729 Previously, it would stringify as an empty string, but some operators would
730 treat it as undefined, producing an "uninitialized" warning.
731 Now it stringifies as __ANONIO__ [perl #96326].
732
733 =head2 User-defined case-changing operations
734
735 This feature was deprecated in Perl 5.14, and has now been removed.
736 The CPAN module L<Unicode::Casing> provides better functionality without
737 the drawbacks that this feature had, as are detailed in the 5.14
738 documentation:
739 L<http://perldoc.perl.org/5.14.0/perlunicode.html#User-Defined-Case-Mappings-%28for-serious-hackers-only%29>
740
741 =head2 XSUBs are now 'static'
742
743 XSUB C functions are now 'static', that is, they are not visible from
744 outside the compilation unit.  Users can use the new C<XS_EXTERNAL(name)>
745 and C<XS_INTERNAL(name)> macros to pick the desired linking behaviour.
746 The ordinary C<XS(name)> declaration for XSUBs will continue to declare
747 non-'static' XSUBs for compatibility, but the XS compiler,
748 C<ExtUtils::ParseXS> (C<xsubpp>) will emit 'static' XSUBs by default.
749 C<ExtUtils::ParseXS>'s behaviour can be reconfigured from XS using the
750 C<EXPORT_XSUB_SYMBOLS> keyword.  See L<perlxs> for details.
751
752 =head2 Weakening read-only references
753
754 Weakening read-only references is no longer permitted.  It should never
755 have worked anyway, and in some cases could result in crashes.
756
757 =head2 Tying scalars that hold typeglobs
758
759 Attempting to tie a scalar after a typeglob was assigned to it would
760 instead tie the handle in the typeglob's IO slot.  This meant that it was
761 impossible to tie the scalar itself.  Similar problems affected C<tied> and
762 C<untie>: C<tied $scalar> would return false on a tied scalar if the last
763 thing returned was a typeglob, and C<untie $scalar> on such a tied scalar
764 would do nothing.
765
766 We fixed this problem before Perl 5.14.0, but it caused problems with some
767 CPAN modules, so we put in a deprecation cycle instead.
768
769 Now the deprecation has been removed and this bug has been fixed.  So
770 C<tie $scalar> will always tie the scalar, not the handle it holds.  To tie
771 the handle, use C<tie *$scalar> (with an explicit asterisk).  The same
772 applies to C<tied *$scalar> and C<untie *$scalar>.
773
774 =head2 IPC::Open3 no longer provides C<xfork()>, C<xclose_on_exec()>
775 and C<xpipe_anon()>
776
777 All three functions were private, undocumented and unexported.  They do
778 not appear to be used by any code on CPAN.  Two have been inlined and one
779 deleted entirely.
780
781 =head2 C<$$> no longer caches PID
782
783 Previously, if one called fork(3) from C, Perl's
784 notion of C<$$> could go out of sync with what getpid() returns.  By always
785 fetching the value of C<$$> via getpid(), this potential bug is eliminated.
786 Code that depends on the caching behavior will break.  As described in
787 L<Core Enhancements|/C<$$> can be assigned to>,
788 C<$$> is now writable, but it will be reset during a
789 fork.
790
791 =head2 C<$$> and C<getppid()> no longer emulate POSIX semantics under LinuxThreads
792
793 The POSIX emulation of C<$$> and C<getppid()> under the obsolete
794 LinuxThreads implementation has been removed.
795 This only impacts users of Linux 2.4 and
796 users of Debian GNU/kFreeBSD up to and including 6.0, not the vast
797 majority of Linux installations that use NPTL threads.
798
799 This means that C<getppid()>, like C<$$>, is now always guaranteed to
800 return the OS's idea of the current state of the process, not perl's
801 cached version of it.
802
803 See the documentation for L<$$|perlvar/$$> for details.
804
805 =head2 C<< $< >>, C<< $> >>, C<$(> and C<$)> are no longer cached
806
807 Similarly to the changes to C<$$> and C<getppid()>, the internal
808 caching of C<< $< >>, C<< $> >>, C<$(> and C<$)> has been removed.
809
810 When we cached these values our idea of what they were would drift out
811 of sync with reality if someone (e.g., someone embedding perl) called
812 C<sete?[ug]id()> without updating C<PL_e?[ug]id>.  Having to deal with
813 this complexity wasn't worth it given how cheap the C<gete?[ug]id()>
814 system call is.
815
816 This change will break a handful of CPAN modules that use the XS-level
817 C<PL_uid>, C<PL_gid>, C<PL_euid> or C<PL_egid> variables.
818
819 The fix for those breakages is to use C<PerlProc_gete?[ug]id()> to
820 retrieve them (e.g. C<PerlProc_getuid()>), and not to assign to
821 C<PL_e?[ug]id> if you change the UID/GID/EUID/EGID.  There is no longer
822 any need to do so since perl will always retrieve the up-to-date
823 version of those values from the OS.
824
825 =head2 Which Non-ASCII characters get quoted by C<quotemeta> and C<\Q> has changed
826
827 This is unlikely to result in a real problem, as Perl does not attach
828 special meaning to any non-ASCII character, so it is currently
829 irrelevant which are quoted or not.  This change fixes bug [perl #77654] and
830 bring Perl's behavior more into line with Unicode's recommendations.
831 See L<perlfunc/quotemeta>.
832
833 =head1 Performance Enhancements
834
835 =over
836
837 =item *
838
839 Improved performance for Unicode properties in regular expressions
840
841 =for comment Can this be compacted some? -- rjbs, 2012-02-20
842
843 Matching a code point against a Unicode property is now done via a
844 binary search instead of linear.  This means for example that the worst
845 case for a 1000 item property is 10 probes instead of 1000.  This
846 inefficiency has been compensated for in the past by permanently storing
847 in a hash the results of a given probe plus the results for the adjacent
848 64 code points, under the theory that near-by code points are likely to
849 be searched for.  A separate hash was used for each mention of a Unicode
850 property in each regular expression.  Thus, C<qr/\p{foo}abc\p{foo}/>
851 would generate two hashes.  Any probes in one instance would be unknown
852 to the other, and the hashes could expand separately to be quite large
853 if the regular expression were used on many different widely-separated
854 code points.  This can lead to running out of memory in extreme cases.
855 Now, however, there is just one hash shared by all instances of a given
856 property.  This means that if C<\p{foo}> is matched against "A" in one
857 regular expression in a thread, the result will be known immediately to
858 all regular expressions, and the relentless march of using up memory is
859 slowed considerably.
860
861 =item *
862
863 Version declarations with the C<use> keyword (e.g., C<use 5.012>) are now
864 faster, as they enable features without loading F<feature.pm>.
865
866 =item *
867
868 C<local $_> is faster now, as it no longer iterates through magic that it
869 is not going to copy anyway.
870
871 =item *
872
873 Perl 5.12.0 sped up the destruction of objects whose classes define
874 empty C<DESTROY> methods (to prevent autoloading), by simply not
875 calling such empty methods.  This release takes this optimisation a
876 step further, by not calling any C<DESTROY> method that begins with a
877 C<return> statement.  This can be useful for destructors that are only
878 used for debugging:
879
880     use constant DEBUG => 1;
881     sub DESTROY { return unless DEBUG; ... }
882
883 Constant-folding will reduce the first statement to C<return;> if DEBUG
884 is set to 0, triggering this optimisation.
885
886 =item *
887
888 Assigning to a variable that holds a typeglob or copy-on-write scalar
889 is now much faster.  Previously the typeglob would be stringified or
890 the copy-on-write scalar would be copied before being clobbered.
891
892 =item *
893
894 Assignment to C<substr> in void context is now more than twice its
895 previous speed.  Instead of creating and returning a special lvalue
896 scalar that is then assigned to, C<substr> modifies the original string
897 itself.
898
899 =item *
900
901 C<substr> no longer calculates a value to return when called in void
902 context.
903
904 =item *
905
906 Due to changes in L<File::Glob>, Perl's C<glob> function and its C<<
907 <...> >> equivalent are now much faster.  The splitting of the pattern
908 into words has been rewritten in C, resulting in speed-ups of 20% in
909 some cases.
910
911 This does not affect C<glob> on VMS, as it does not use File::Glob.
912
913 =item *
914
915 The short-circuiting operators C<&&>, C<||>, and C<//>, when chained
916 (such as C<$a || $b || $c>), are now considerably faster to short-circuit,
917 due to reduced optree traversal.
918
919 =item *
920
921 The implementation of C<s///r> makes one fewer copy of the scalar's value.
922
923 =item *
924
925 C<study> is now a no-op.
926
927 =item *
928
929 Recursive calls to lvalue subroutines in lvalue scalar context use less
930 memory.
931
932 =back
933
934 =head1 Modules and Pragmata
935
936 =head2 Deprecated Modules
937
938 =over
939
940 =item L<Version::Requirements>
941
942 Version::Requirements is now DEPRECATED, use L<CPAN::Meta::Requirements>,
943 which is a drop-in replacement.  It will be deleted from perl.git blead
944 in v5.17.0.
945
946 =back
947
948 =head2 New Modules and Pragmata
949
950 =over 4
951
952 =item *
953
954 L<arybase> -- this new module implements the C<$[> variable.
955
956 =item *
957
958 C<PerlIO::mmap> 0.010 has been added to the Perl core.
959
960 The C<mmap> PerlIO layer is no longer implemented by perl itself, but has
961 been moved out into the new L<PerlIO::mmap> module.
962
963 =back
964
965 =head2 Updated Modules and Pragmata
966
967 This is only an overview of selected module updates.  For a complete list of
968 updates, run:
969
970     $ corelist --diff 5.14.0 5.16.0
971
972 You can substitute your favorite version in place of 5.14.0, too.
973
974 =over 4
975
976 =item *
977
978 L<Archive::Extract> has been upgraded from version 0.48 to version 0.58
979
980 Includes a fix for FreeBSD to only use C<unzip> if it is located in
981 C</usr/local/bin>, as FreeBSD 9.0 will ship with a limited C<unzip> in
982 C</usr/bin>.
983
984 =item *
985
986 L<Archive::Tar> has been upgraded from version 1.76 to version 1.82.
987
988 Adjustments to handle files >8gb (>0777777777777 octal) and a feature
989 to return the MD5SUM of files in the archive.
990
991 =item *
992
993 L<base> has been upgraded from version 2.16 to version 2.18.
994
995 C<base> no longer sets a module's C<$VERSION> to "-1" when a module it
996 loads does not define a C<$VERSION>.  This change has been made because
997 "-1" is not a valid version number under the new "lax" criteria used
998 internally by C<UNIVERSAL::VERSION>.  (See L<version> for more on "lax"
999 version criteria.)
1000
1001 C<base> no longer internally skips loading modules it has already loaded
1002 and instead relies on C<require> to inspect C<%INC>.  This fixes a bug
1003 when C<base> is used with code that clear C<%INC> to force a module to
1004 be reloaded.
1005
1006 =item *
1007
1008 L<Carp> has been upgraded from version 1.20 to version 1.26.
1009
1010 It now includes last read filehandle info and puts a dot after the file
1011 and line number, just like errors from C<die> [perl #106538].
1012
1013 =item *
1014
1015 L<charnames> has been updated from version 1.18 to version 1.30
1016
1017 L<charnames> can now be invoked with a new option, C<:loose>,
1018 which is like the existing C<:full> option, but enables Unicode loose
1019 name matching.  Details are in L<charnames/LOOSE MATCHES>.
1020
1021 =item *
1022
1023 L<B::Deparse> has been upgraded from version 1.03 to 1.14.  This fixes
1024 numerous deparsing bugs.
1025
1026 =item *
1027
1028 L<CGI> has been upgraded from version 3.52 to version 3.59
1029
1030 The DELETE HTTP verb is now supported.
1031
1032 It uses the public and documented FCGI.pm API in CGI::Fast.  CGI::Fast was
1033 using an FCGI API that was deprecated and removed from documentation
1034 more than ten years ago.  Usage of this deprecated API with FCGI E<gt>=
1035 0.70 or FCGI E<lt>= 0.73 introduces a security issue.
1036 L<https://rt.cpan.org/Public/Bug/Display.html?id=68380>
1037 L<http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2011-2766>
1038
1039 Things that may break your code:
1040
1041 C<url()> was fixed to return C<PATH_INFO> when it is explicitly requested
1042 with either the C<path=E<gt>1> or C<path_info=E<gt>1> flag.
1043
1044 If your code is running under mod_rewrite (or compatible) and you are
1045 calling C<self_url()> or you are calling C<url()> and passing
1046 C<path_info=E<gt>1>, These methods will actually be returning
1047 C<PATH_INFO> now, as you have explicitly requested, or has C<self_url()>
1048 has requested on your behalf.
1049
1050 The C<PATH_INFO> has been omitted in such URLs since the issue was
1051 introduced in the 3.12 release in December, 2005.
1052
1053 This bug is so old your application may have come to depend on it or
1054 workaround it. Check for application before upgrading to this release.
1055
1056 Examples of affected method calls:
1057
1058   $q->url(-absolute => 1, -query => 1, -path_info => 1 )
1059   $q->url(-path=>1)
1060   $q->url(-full=>1,-path=>1)
1061   $q->url(-rewrite=>1,-path=>1)
1062   $q->self_url();
1063
1064 We no longer read from STDIN when the Content-Length is not set,
1065 preventing requests with no Content-Length from freezing in some cases.
1066 This is consistent with the CGI RFC 3875, and is also consistent with
1067 CGI::Simple. However, the old behavior may have been expected by some
1068 command-line uses of CGI.pm.
1069
1070 =item *
1071
1072 L<Compress::Zlib> has been upgraded from version 2.035 to version 2.048
1073
1074 IO::Compress::Zip and IO::Uncompress::Unzip now have support for LZMA
1075 (method 14).  There is a fix for a CRC issue in IO::Compress::Unzip and
1076 it supports Streamed Stored context now. And fixed a Zip64 issue in
1077 IO::Compress::Zip when the content size was exactly 0xFFFFFFFF.
1078
1079 =item *
1080
1081 L<Digest::SHA> has been upgraded from version 5.61 to version 5.71.
1082
1083 Added BITS mode to the addfile method and shasum.  This makes
1084 partial-byte inputs possible via files/STDIN and allows shasum to check
1085 all 8074 NIST Msg vectors, where previously special programming was
1086 required to do this.
1087
1088 =item *
1089
1090 L<Encode> has been upgraded from version 2.42 to version 2.44
1091
1092 Missing aliases added, a deep recursion error fixed and various
1093 documentation updates.
1094
1095 Addressed 'decode_xs n-byte heap-overflow' security bug in Unicode.xs
1096
1097 =item *
1098
1099 L<ExtUtils::CBuilder> updated from version 0.280203 to 0.280206.
1100
1101 The new version appends CFLAGS and LDFLAGS to their Config.pm
1102 counterparts.
1103
1104 =item *
1105
1106 L<ExtUtils::ParseXS> has been upgraded from version 2.2210 to 3.16.
1107
1108 Much of L<ExtUtils::ParseXS>, the module behind the XS compiler C<xsubpp>,
1109 was rewritten and cleaned up. It has been made somewhat more extensible
1110 and now finally uses strictures.
1111
1112 The typemap logic has been moved into a separate module,
1113 L<ExtUtils::Typemaps>.  See L</New Modules and Pragmata>, above.
1114
1115 For a complete set of changes, please see the ExtUtils::ParseXS
1116 changelog, available on the CPAN.
1117
1118 =item *
1119
1120 L<File::Glob> has been upgraded from version 1.12 to version 1.17.
1121
1122 On Windows, tilde (~) expansion now checks the C<USERPROFILE> environment
1123 variable, after checking C<HOME>.
1124
1125 It has a new C<:bsd_glob> export tag, intended to replace C<:glob>.  Like
1126 C<:glob> it overrides C<glob> with a function that does not split the glob
1127 pattern into words, but, unlike C<:glob>, it iterates properly in scalar
1128 context, instead of returning the last file.
1129
1130 There are other changes affecting Perl's own C<glob> operator (which uses
1131 File::Glob internally, except on VMS).  See L</Performance Enhancements>
1132 and L</Selected Bug Fixes>.
1133
1134 =item *
1135
1136 L<FindBin> updated from version 1.50 to 1.51.
1137
1138 It no longer returns a wrong result if a script of the same name as the
1139 current one exists in the path and is executable.
1140
1141 =item *
1142
1143 L<HTTP::Tiny> has been upgraded from version 0.012 to version 0.017.
1144
1145 Added support for using C<$ENV{http_proxy}> to set the default proxy host.
1146
1147 Adds additional shorthand methods for all common HTTP verbs,
1148 a C<post_form()> method for POST-ing x-www-form-urlencoded data and
1149 a C<www_form_urlencode()> utility method.
1150
1151 =item *
1152
1153 L<IO> has been upgraded from version 1.25_04 to 1.25_06, and L<IO::Handle>
1154 from version 1.31 to 1.33.
1155
1156 Together, these upgrades fix a problem with IO::Handle's C<getline> and
1157 C<getlines> methods.  When these methods are called on the special ARGV
1158 handle, the next file is automatically opened, as happens with the built-in
1159 C<E<lt>E<gt>> and C<readline> functions.  But, unlike the built-ins, these
1160 methods were not respecting the caller's use of the L<open> pragma and
1161 applying the approprate I/O layers to the newly-opened file
1162 [rt.cpan.org #66474].
1163
1164 =item *
1165
1166 L<IPC::Cmd> has been upgraded from version 0.70 to version 0.76
1167
1168 Capturing of command output (both C<STDOUT> and C<STDERR>) is now supported
1169 using L<IPC::Open3> on MSWin32 without requiring L<IPC::Run>.
1170
1171 =item *
1172
1173 L<IPC::Open3> has been upgraded from version 1.09 to version 1.12.
1174
1175 =over 4
1176
1177 =item *
1178
1179 Fixes a bug which prevented use of C<open3> on Windows when C<*STDIN>,
1180 C<*STDOUT> or C<*STDERR> had been localized.
1181
1182 =item *
1183
1184 Fixes a bug which prevented duplicating numeric file descriptors on Windows.
1185
1186 =item *
1187
1188 C<open3> with "-" for the program name works once more.  This was broken in
1189 version 1.06 (and hence in Perl 5.14.0) [perl #95748].
1190
1191 =back
1192
1193 =item *
1194
1195 L<Locale::Codes> has been upgraded from version 3.16 to version 3.21
1196
1197 Added Language Extension codes (langext) and Language Variation codes (langvar)
1198 as defined in the IANA language registry.
1199
1200 Added language codes from ISO 639-5
1201
1202 Added language/script codes from the IANA language subtag registry
1203
1204 Fixed an uninitialized value warning.  RT 67438
1205
1206 Fixed the return value for the all_XXX_codes and all_XXX_names functions.  RT
1207 69100
1208
1209 Reorganized modules to move Locale::MODULE to Locale::Codes::MODULE to allow
1210 for cleaner future additions.  The original four modules (Locale::Language,
1211 Locale::Currency, Locale::Country, Locale::Script) will continue to work, but
1212 all new sets of codes will be added in the Locale::Codes namespace.
1213
1214 The code2XXX, XXX2code, all_XXX_codes, and all_XXX_names functions now
1215 support retired codes.  All codesets may be specified by a constant or
1216 by their name now.  Previously, they were specified only by a constant.
1217
1218 The alias_code function exists for backward compatibility.  It has been
1219 replaced by rename_country_code.  The alias_code function will be
1220 removed some time after September, 2013.
1221
1222 All work is now done in the central module (Locale::Codes).  Previously,
1223 some was still done in the wrapper modules (Locale::Codes::*).  Added
1224 Language Family codes (langfam) as defined in ISO 639-5.
1225
1226 =item *
1227
1228 L<Math::BigFloat> has been upgraded from version 1.993 to 1.997.
1229
1230 The C<numify> method has been corrected to return a normalised Perl number
1231 (the result of C<0 + $thing>), instead of a string [rt.cpan.org #66732].
1232
1233 =item *
1234
1235 L<Math::BigInt> has been upgraded from version 1.994 to 1.998.
1236
1237 It provides a new C<bsgn> method that complements the C<babs> method.
1238
1239 It fixes the internal C<objectify> function's handling of "foreign objects"
1240 so they are converted to the appropriate class (Math::BigInt or
1241 Math::BigFloat).
1242
1243 =item *
1244
1245 L<Math::BigRat> has been upgraded from version 0.2602 to version 0.2603.
1246
1247 C<int()> on a Math::BigRat object containing -1/2 now creates a
1248 Math::BigInt containing 0, rather than -0.  L<Math::BigInt> does not even
1249 support negative zero, so the resulting object was actually malformed
1250 [perl #95530].
1251
1252 =item *
1253
1254 L<Math::Complex> has been upgraded from version 1.56 to version 1.59
1255 and L<Math::Trig> has been upgraded from version 1.2 to version 1.22.
1256
1257 Fixes include: correct copy constructor usage; fix polarwise formatting with
1258 numeric format specifier; and more stable C<great_circle_direction> algorithm.
1259
1260 =item *
1261
1262 L<Module::CoreList> has been upgraded from version 2.51 to 2.66.
1263
1264 The C<corelist> utility now understands the C<-r> option for displaying
1265 Perl release dates and the C<--diff> option to print the set of modlib
1266 changes between two perl distributions.
1267
1268 =item *
1269
1270 C<Module::Metadata> has been upgraded from version 1.000004 to 1.000009.
1271
1272 Adds C<provides> method to generate a CPAN META provides data structure
1273 correctly; use of C<package_versions_from_directory> is discouraged.
1274
1275 =item *
1276
1277 L<ODBM_File> has been upgraded from version 1.10 to version 1.12.
1278
1279 The XS code is now compiled with C<PERL_NO_GET_CONTEXT>, which will aid
1280 performance under ithreads.
1281
1282 =item *
1283
1284 L<open> has been upgraded from version 1.08 to 1.10.
1285
1286 It no longer turns of layers on standard handles when invoked without the
1287 ":std" directive.  Similarly, when invoked I<with> the ":std" directive, it
1288 now clears layers on STDERR before applying the new ones, and not just on
1289 STDIN and STDOUT [perl #92728].
1290
1291 =item *
1292
1293 L<overload> has been upgraded from version 1.13 to version 1.18.
1294
1295 C<overload::Overloaded> no longer calls C<can> on the class, but uses
1296 another means to determine whether the object has overloading.  It was
1297 never correct for it to call C<can>, as overloading does not respect
1298 AUTOLOAD.  So classes that autoload methods and implement C<can> no longer
1299 have to account for overloading [perl #40333].
1300
1301 A warning is now produced for invalid arguments.  See L</New Diagnostics>.
1302
1303 =item *
1304
1305 L<PerlIO::scalar> has been upgraded from version 0.11 to 0.14.
1306
1307 (This is the module that implements C<< open $fh, '>', \$scalar >>.)
1308
1309 It fixes a problem with C<< open my $fh, ">", \$scalar >> not working if
1310 C<$scalar> is a copy-on-write scalar.
1311
1312 It also fixes a hang that occurs with C<readline> or C<< <$fh> >> if a
1313 typeglob has been assigned to $scalar [perl #92258].
1314
1315 It no longer assumes during C<seek> that $scalar is a string internally.
1316 If it didn't crash, it was close to doing so [perl #92706].  Also, the
1317 internal print routine no longer assumes that the position set by C<seek>
1318 is valid, but extends the string to that position, filling the intervening
1319 bytes (between the old length and the seek position) with nulls
1320 [perl #78980].
1321
1322 Printing to an in-memory handle now works if the $scalar holds a reference,
1323 stringifying the reference before modifying it.  References used to be
1324 treated as empty strings.
1325
1326 Printing to an in-memory handle no longer crashes if the $scalar happens to
1327 hold a number internally, but no string buffer.
1328
1329 Printing to an in-memory handle no longer creates scalars that confuse
1330 the regular expression engine [perl #108398].
1331
1332 =item *
1333
1334 C<Pod::Functions> has been upgraded from version 1.04 to 1.05.
1335
1336 F<Functions.pm> is now generated at perl build time from annotations in
1337 F<perlfunc.pod>. This will ensure that L<Pod::Functions> and L<perlfunc>
1338 remain in synchronisation.
1339
1340 =item *
1341
1342 L<Pod::Html> has been upgraded from version 1.11 to 1.1502.
1343
1344 This is an extensive rewrite of Pod::Html to use L<Pod::Simple> under
1345 the hood.  The output has changed significantly.
1346
1347 =item *
1348
1349 L<Pod::Perldoc> has been upgraded from version 3.15_03 to 3.17.
1350
1351 It corrects the search paths on VMS [perl #90640]. (5.14.1)
1352
1353 The B<-v> option now fetches the right section for C<$0>.
1354
1355 This upgrade has numerous significant fixes.  Consult its changelog on
1356 the CPAN for more information.
1357
1358 =item *
1359
1360 L<POSIX> has been upgraded from version 1.24 to version 1.30.
1361
1362 L<POSIX> no longer uses L<AutoLoader>. Any code which was relying on this
1363 implementation detail was buggy, and may fail as a result of this change.
1364 The module's Perl code has been considerably simplified, roughly halving
1365 the number of lines, with no change in functionality. The XS code has
1366 been refactored to reduce the size of the shared object by about 12%,
1367 with no change in functionality. More POSIX functions now have tests.
1368
1369 C<sigsuspend> and C<pause> now run signals handle before returning, as the
1370 whole point of these two functions is to wait until a signal has
1371 arrived, and then return I<after> it has been triggered.  Delayed, or
1372 "safe", signals were preventing that from happening, possibly resulting in
1373 race conditions [perl #107216].
1374
1375 C<POSIX::sleep> is now a direct call into the underlying OS C<sleep>
1376 function, instead of being a Perl wrapper on C<CORE::sleep>. C<POSIX::dup2>
1377 now returns the correct value on Win32 (I<i.e.> the file descriptor).
1378 C<POSIX::SigSet> C<sigsuspend> and C<sigpending> and C<POSIX::pause> now
1379 dispatch safe signals immediately before returning to their caller.
1380
1381 C<POSIX::Termios::setattr> now defaults the third argument to C<TCSANOW>,
1382 instead of 0. On most platforms C<TCSANOW> is defined as 0, but on some
1383 0 is not a valid parameter, which caused a call with defaults to fail.
1384
1385 =item *
1386
1387 L<Socket> as been upgraded from version 1.94 to 2.000
1388
1389 It has new functions and constants for handling IPv6 sockets:
1390
1391     pack_ipv6_mreq
1392     unpack_ipv6_mreq
1393     IPV6_ADD_MEMBERSHIP
1394     IPV6_DROP_MEMBERSHIP
1395     IPV6_MTU
1396     IPV6_MTU_DISCOVER
1397     IPV6_MULTICAST_HOPS
1398     IPV6_MULTICAST_IF
1399     IPV6_MULTICAST_LOOP
1400     IPV6_UNICAST_HOPS
1401     IPV6_V6ONLY
1402
1403 =item *
1404
1405 L<Storable> has been upgraded from version 2.27 to version 2.34.
1406
1407 It no longer turns copy-on-write scalars into read-only scalars when
1408 freezing and thawing.
1409
1410 =item *
1411
1412 L<Sys::Syslog> has been upgraded from version 0.27 to version 0.29
1413
1414 This upgrade closes many outstanding bugs.
1415
1416 =item *
1417
1418 L<Term::ANSIColor> has been upgraded from version 3.00 to version 3.01
1419
1420 Only interpret an initial array reference as a list of colors, not any initial
1421 reference, allowing the colored function to work properly on objects with
1422 stringification defined.
1423
1424 =item *
1425
1426 C<Term::ReadLine> has been upgraded from version 1.07 to 1.09.
1427
1428 Term::ReadLine now supports any event loop, including unpublished ones and
1429 simple L<IO::Select> loops without the need to rewrite existing code for
1430 any particular framework [perl #108470].
1431
1432 =item *
1433
1434 L<threads::shared> has been upgraded from version 1.37 to 1.40.
1435
1436 Destructors on shared objects used to be ignored sometimes if the objects
1437 were referenced only by shared data structures.  This has been mostly
1438 fixed, but destructors may still be ignored if the objects still exist at
1439 global destruction time [perl #98204].
1440
1441 =item *
1442
1443 L<Unicode::Collate> has been upgraded from version 0.73 to version 0.89
1444
1445 Updated to CLDR 1.9.1
1446
1447 Locales updated to CLDR 2.0: mk, mt, nb, nn, ro, ru, sk, sr, sv, uk,
1448 zh__pinyin, zh__stroke
1449
1450 Newly supported locales: bn, fa, ml, mr, or, pa, sa, si, si__dictionary,
1451 sr_Latn, sv__reformed, ta, te, th, ur, wae.
1452
1453 Tailored compatibility ideographs as well as unified ideographs for the
1454 locales: ja, ko, zh__big5han, zh__gb2312han, zh__pinyin, zh__stroke.
1455
1456 Locale/*.pl files are now searched for in @INC.
1457
1458 =item *
1459
1460 L<Unicode::Normalize> has been upgraded from version 1.10 to version 1.14
1461
1462 Fixes for the removal of F<unicore/CompositionExclusions.txt> from core.
1463
1464 =item *
1465
1466 L<Unicode::UCD> has been upgraded from version 0.32 to version 0.43.
1467
1468 This adds four new functions:  C<prop_aliases()>, and
1469 C<prop_value_aliases()> which are used to find all the Unicode-approved
1470 synonyms for property names, or to convert from one name to another;
1471 C<prop_invlist> which returns all the code points matching a given
1472 Unicode binary property; and C<prop_invmap> which returns the complete
1473 specification of a given Unicode property.
1474
1475 =item *
1476
1477 L<Win32API::File> has been upgraded from version 0.1101 to version 0.1200
1478
1479 Added SetStdHandle and GetStdHandle functions
1480
1481 =back
1482
1483 =head2 Removed Modules and Pragmata
1484
1485 As promised in Perl 5.14.0's release notes, the following modules have
1486 been removed from the core distribution, and if needed should be installed
1487 from CPAN instead.
1488
1489 =over
1490
1491 =item *
1492
1493 C<Devel::DProf> has been removed from the Perl core.  Prior version was
1494 20110228.00.
1495
1496 =item *
1497
1498 C<Shell> has been removed from the Perl core.  Prior version was 0.72_01.
1499
1500 =back
1501
1502 =head1 Documentation
1503
1504 =head2 New Documentation
1505
1506 =head3 L<perldtrace>
1507
1508 L<perldtrace> describes Perl's DTrace support, listing the provided probes
1509 and gives examples of their use.
1510
1511 =head3 L<perlexperiment>
1512
1513 This document is intended to provide a list of experimental features in
1514 Perl.  It is still a work in progress.
1515
1516 =head3 L<perlootut>
1517
1518 This a new OO tutorial.  It focuses on basic OO concepts, and then recommends
1519 that readers choose an OO framework from CPAN.
1520
1521 =head3 L<perlxstypemap>
1522
1523 The new manual describes the XS typemapping mechanism in unprecedented
1524 detail and combines new documentation with information extracted from
1525 L<perlxs> and the previously unofficial list of all core typemaps.
1526
1527 =head2 Changes to Existing Documentation
1528
1529 =head3 L<perlapi>
1530
1531 =over 4
1532
1533 =item *
1534
1535 The HV API has long accepted negative lengths to indicate that the key is
1536 in UTF8.  Now this is documented.
1537
1538 =item *
1539
1540 The C<boolSV()> macro is now documented.
1541
1542 =back
1543
1544 =head3 L<perlfunc>
1545
1546 =over 4
1547
1548 =item *
1549
1550 C<dbmopen> treats a 0 mode as a special case, that prevents a nonexistent
1551 file from being created.  This has been the case since Perl 5.000, but was
1552 never documented anywhere.  Now the perlfunc entry mentions it
1553 [perl #90064].
1554
1555 =item *
1556
1557 As an accident of history, C<open $fh, "<:", ...> applies the default
1558 layers for the platform (C<:raw> on Unix, C<:crlf> on Windows), ignoring
1559 whatever is declared by L<open.pm|open>.  This seems such a useful feature
1560 it has been documented in L<perlfunc|perlfunc/open> and L<open>.
1561
1562 =item *
1563
1564 The entry for C<split> has been rewritten.  It is now far clearer than
1565 before.
1566
1567 =back
1568
1569 =head3 L<perlguts>
1570
1571 =over 4
1572
1573 =item *
1574
1575 A new section, L<Autoloading with XSUBs|perlguts/Autoloading with XSUBs>,
1576 has been added, which explains the two APIs for accessing the name of the
1577 autoloaded sub.
1578
1579 =item *
1580
1581 Some of the function descriptions in L<perlguts> were confusing, as it was
1582 not clear whether they referred to the function above or below the
1583 description.  This has been clarified [perl #91790].
1584
1585 =back
1586
1587 =head3 L<perlobj>
1588
1589 =over 4
1590
1591 =item *
1592
1593 This document has been rewritten from scratch, and its coverage of various OO
1594 concepts has been expanded.
1595
1596 =back
1597
1598 =head3 L<perlop>
1599
1600 =over 4
1601
1602 =item *
1603
1604 Documentation of the smartmatch operator has been reworked and moved from
1605 perlsyn to perlop where it belongs.
1606
1607 It has also been corrected for the case of C<undef> on the left-hand
1608 side.  The list of different smart match behaviours had an item in the
1609 wrong place.
1610
1611 =item *
1612
1613 Documentation of the ellipsis statement (C<...>) has been reworked and
1614 moved from perlop to perlsyn.
1615
1616 =item *
1617
1618 The explanation of bitwise operators has been expanded to explain how they
1619 work on Unicode strings (5.14.1).
1620
1621 =item *
1622
1623 More examples for C<m//g> have been added (5.14.1).
1624
1625 =item *
1626
1627 The C<<< <<\FOO >>> here-doc syntax has been documented (5.14.1).
1628
1629 =back
1630
1631 =head3 L<perlpragma>
1632
1633 =over 4
1634
1635 =item *
1636
1637 There is now a standard convention for naming keys in the C<%^H>,
1638 documented under L<Key naming|perlpragma/Key naming>.
1639
1640 =back
1641
1642 =head3 L<perlsec/Laundering and Detecting Tainted Data>
1643
1644 =over 4
1645
1646 =item *
1647
1648 The example function for checking for taintedness contained a subtle
1649 error.  C<$@> needs to be localized to prevent its changing this
1650 global's value outside the function.  The preferred method to check for
1651 this remains L<Scalar::Util/tainted>.
1652
1653 =back
1654
1655 =head3 L<perllol>
1656
1657 =over
1658
1659 =item *
1660
1661 L<perllol> has been expanded with examples using the new C<push $scalar>
1662 syntax introduced in Perl 5.14.0 (5.14.1).
1663
1664 =back
1665
1666 =head3 L<perlmod>
1667
1668 =over
1669
1670 =item *
1671
1672 L<perlmod> now states explicitly that some types of explicit symbol table
1673 manipulation are not supported.  This codifies what was effectively already
1674 the case [perl #78074].
1675
1676 =back
1677
1678 =head3 L<perlpodstyle>
1679
1680 =over 4
1681
1682 =item *
1683
1684 The tips on which formatting codes to use have been corrected and greatly
1685 expanded.
1686
1687 =item *
1688
1689 There are now a couple of example one-liners for previewing POD files after
1690 they have been edited.
1691
1692 =back
1693
1694 =head3 L<perlre>
1695
1696 =over
1697
1698 =item *
1699
1700 The C<(*COMMIT)> directive is now listed in the right section
1701 (L<Verbs without an argument|perlre/Verbs without an argument>).
1702
1703 =back
1704
1705 =head3 L<perlrun>
1706
1707 =over
1708
1709 =item *
1710
1711 L<perlrun> has undergone a significant clean-up.  Most notably, the
1712 B<-0x...> form of the B<-0> flag has been clarified, and the final section
1713 on environment variables has been corrected and expanded (5.14.1).
1714
1715 =back
1716
1717 =head3 L<perlsub>
1718
1719 =over
1720
1721 =item *
1722
1723 The ($;) prototype syntax, which has existed for rather a long time, is now
1724 documented in L<perlsub>.  It allows a unary function to have the same
1725 precedence as a list operator.
1726
1727 =back
1728
1729 =head3 L<perltie>
1730
1731 =over
1732
1733 =item *
1734
1735 The required syntax for tying handles has been documented.
1736
1737 =back
1738
1739 =head3 L<perlvar>
1740
1741 =over
1742
1743 =item *
1744
1745 The documentation for L<$!|perlvar/$!> has been corrected and clarified.
1746 It used to state that $! could be C<undef>, which is not the case.  It was
1747 also unclear as to whether system calls set C's C<errno> or Perl's C<$!>
1748 [perl #91614].
1749
1750 =item *
1751
1752 Documentation for L<$$|perlvar/$$> has been amended with additional
1753 cautions regarding changing the process ID.
1754
1755 =back
1756
1757 =head3 Other Changes
1758
1759 =over 4
1760
1761 =item *
1762
1763 L<perlxs> was extended with documentation on inline typemaps.
1764
1765 =item *
1766
1767 L<perlref> has a new L<Circular References|perlref/Circular References>
1768 section explaining how circularities may not be freed and how to solve that
1769 with weak references.
1770
1771 =item *
1772
1773 Parts of L<perlapi> were clarified, and Perl equivalents of some C
1774 functions have been added as an additional mode of exposition.
1775
1776 =item *
1777
1778 A few parts of L<perlre> and L<perlrecharclass> were clarified.
1779
1780 =back
1781
1782 =head2 Removed Documentation
1783
1784 =head3 Old OO Documentation
1785
1786 All the old OO tutorials, perltoot, perltooc, and perlboot, have been
1787 removed.  The perlbot (bag of object tricks) document has been removed
1788 as well.
1789
1790 =head3 Development Deltas
1791
1792 The perldelta files for development releases are no longer packaged with
1793 perl.  These can still be found in the perl source code repository.
1794
1795 =head1 Diagnostics
1796
1797 The following additions or changes have been made to diagnostic output,
1798 including warnings and fatal error messages.  For the complete list of
1799 diagnostic messages, see L<perldiag>.
1800
1801 =head2 New Diagnostics
1802
1803 =head3 New Errors
1804
1805 =over 4
1806
1807 =item *
1808
1809 L<Cannot set tied @DB::args|perldiag/"Cannot set tied @DB::args">
1810
1811 This error occurs when C<caller> tries to set C<@DB::args> but finds it
1812 tied.  Before this error was added, it used to crash instead.
1813
1814 =item *
1815
1816 L<Cannot tie unreifiable array|perldiag/"Cannot tie unreifiable array">
1817
1818 This error is part of a safety check that the C<tie> operator does before
1819 tying a special array like C<@_>.  You should never see this message.
1820
1821 =item *
1822
1823 L<&CORE::%s cannot be called directly|perldiag/"&CORE::%s cannot be called directly">
1824
1825 This occurs when a subroutine in the C<CORE::> namespace is called
1826 with C<&foo> syntax or through a reference.  Some subroutines
1827 in this package cannot yet be called that way, but must be
1828 called as barewords.  See L</Subroutines in the C<CORE> namespace>, above.
1829
1830 =item *
1831
1832 L<Source filters apply only to byte streams|perldiag/"Source filters apply only to byte streams">
1833
1834 This new error occurs when you try to activate a source filter (usually by
1835 loading a source filter module) within a string passed to C<eval> under the
1836 C<unicode_eval> feature.
1837
1838 =back
1839
1840 =head3 New Warnings
1841
1842 =over 4
1843
1844 =item *
1845
1846 L<defined(@array) is deprecated|perldiag/"defined(@array) is deprecated">
1847
1848 The long-deprecated C<defined(@array)> now also warns for package variables.
1849 Previously it only issued a warning for lexical variables.
1850
1851 =item *
1852
1853 L<length() used on %s|perldiag/length() used on %s>
1854
1855 This new warning occurs when C<length> is used on an array or hash, instead
1856 of C<scalar(@array)> or C<scalar(keys %hash)>.
1857
1858 =item *
1859
1860 L<lvalue attribute %s already-defined subroutine|perldiag/"lvalue attribute %s already-defined subroutine">
1861
1862 L<attributes.pm|attributes> now emits this warning when the :lvalue
1863 attribute is applied to a Perl subroutine that has already been defined, as
1864 doing so can have unexpected side-effects.
1865
1866 =item *
1867
1868 L<overload arg '%s' is invalid|perldiag/"overload arg '%s' is invalid">
1869
1870 This warning, in the "overload" category, is produced when the overload
1871 pragma is given an argument it doesn't recognize, presumably a mistyped
1872 operator.
1873
1874 =item *
1875
1876 L<$[ used in %s (did you mean $] ?)|perldiag/"$[ used in %s (did you mean $] ?)">
1877
1878 This new warning exists to catch the mistaken use of C<$[> in version
1879 checks.  C<$]>, not C<$[>, contains the version number.
1880
1881 =item *
1882
1883 L<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
1884
1885 Assigning to a temporary scalar returned
1886 from an lvalue subroutine now produces this
1887 warning [perl #31946].
1888
1889 =item *
1890
1891 L<Useless use of \E|perldiag/"Useless use of \E">
1892
1893 C<\E> does nothing unless preceded by C<\Q>, C<\L> or C<\U>.
1894
1895 =back
1896
1897 =head2 Removed Errors
1898
1899 =over
1900
1901 =item *
1902
1903 "sort is now a reserved word"
1904
1905 This error used to occur when C<sort> was called without arguments,
1906 followed by C<;> or C<)>.  (E.g., C<sort;> would die, but C<{sort}> was
1907 OK.)  This error message was added in Perl 3 to catch code like
1908 C<close(sort)> which would no longer work.  More than two decades later,
1909 this message is no longer appropriate.  Now C<sort> without arguments is
1910 always allowed, and returns an empty list, as it did in those cases
1911 where it was already allowed [perl #90030].
1912
1913 =back
1914
1915 =head2 Changes to Existing Diagnostics
1916
1917 =over 4
1918
1919 =item *
1920
1921 The "Applying pattern match..." or similar warning produced when an
1922 array or hash is on the left-hand side of the C<=~> operator now
1923 mentions the name of the variable.
1924
1925 =item *
1926
1927 The "Attempt to free non-existent shared string" has had the spelling
1928 of "non-existent" corrected to "nonexistent".  It was already listed
1929 with the correct spelling in L<perldiag>.
1930
1931 =item *
1932
1933 The error messages for using C<default> and C<when> outside of a
1934 topicalizer have been standardised to match the messages for C<continue>
1935 and loop controls.  They now read 'Can't "default" outside a
1936 topicalizer' and 'Can't "when" outside a topicalizer'.  They both used
1937 to be 'Can't use when() outside a topicalizer' [perl #91514].
1938
1939 =item *
1940
1941 The message, "Code point 0x%X is not Unicode, no properties match it;
1942 all inverse properties do" has been changed to "Code point 0x%X is not
1943 Unicode, all \p{} matches fail; all \P{} matches succeed".
1944
1945 =item *
1946
1947 Redefinition warnings for constant subroutines used to be mandatory,
1948 even occurring under C<no warnings>.  Now they respect the L<warnings>
1949 pragma.
1950
1951 =item *
1952
1953 The "glob failed" warning message is now suppressible via C<no warnings>
1954 [perl #111656].
1955
1956 =item *
1957
1958 The L<Invalid version format|perldiag/"Invalid version format (%s)">
1959 error message now says "negative version number" within the parentheses,
1960 rather than "non-numeric data", for negative numbers.
1961
1962 =item *
1963
1964 The two warnings
1965 L<Possible attempt to put comments in qw() list|perldiag/"Possible attempt to put comments in qw() list">
1966 and
1967 L<Possible attempt to separate words with commas|perldiag/"Possible attempt to separate words with commas">
1968 are no longer mutually exclusive: the same C<qw> construct may produce
1969 both.
1970
1971 =item *
1972
1973 The uninitialized warning for C<y///r> when C<$_> is implicit and
1974 undefined now mentions the variable name, just like the non-/r variation
1975 of the operator.
1976
1977 =item *
1978
1979 The 'Use of "foo" without parentheses is ambiguous' warning has been
1980 extended to apply also to user-defined subroutines with a (;$)
1981 prototype, and not just to built-in functions.
1982
1983 =item *
1984
1985 Warnings that mention the names of lexical (C<my>) variables with
1986 Unicode characters in them now respect the presence or absence of the
1987 C<:utf8> layer on the output handle, instead of outputting UTF8
1988 regardless.  Also, the correct names are included in the strings passed
1989 to C<$SIG{__WARN__}> handlers, rather than the raw UTF8 bytes.
1990
1991 =back
1992
1993 =head1 Utility Changes
1994
1995 =head3 L<h2ph>
1996
1997 =over 4
1998
1999 =item *
2000
2001 L<h2ph> used to generate code of the form
2002
2003   unless(defined(&FOO)) {
2004     sub FOO () {42;}
2005   }
2006
2007 But the subroutine is a compile-time declaration, and is hence unaffected
2008 by the condition.  It has now been corrected to emit a string C<eval>
2009 around the subroutine [perl #99368].
2010
2011 =back
2012
2013 =head3 L<splain>
2014
2015 =over 4
2016
2017 =item *
2018
2019 F<splain> no longer emits backtraces with the first line number repeated.
2020
2021 This:
2022
2023     Uncaught exception from user code:
2024             Cannot fwiddle the fwuddle at -e line 1.
2025      at -e line 1
2026             main::baz() called at -e line 1
2027             main::bar() called at -e line 1
2028             main::foo() called at -e line 1
2029
2030 has become this:
2031
2032     Uncaught exception from user code:
2033             Cannot fwiddle the fwuddle at -e line 1.
2034             main::baz() called at -e line 1
2035             main::bar() called at -e line 1
2036             main::foo() called at -e line 1
2037
2038 =item *
2039
2040 Some error messages consist of multiple lines that are listed as separate
2041 entries in L<perldiag>.  splain has been taught to find the separate
2042 entries in these cases, instead of simply failing to find the message.
2043
2044 =back
2045
2046 =head3 L<zipdetails>
2047
2048 =over 4
2049
2050 =item *
2051
2052 This is a new utility, included as part of an
2053 L<IO::Compress::Base> upgrade.
2054
2055 L<zipdetails> displays information about the internal record structure
2056 of the zip file.  It is not concerned with displaying any details of
2057 the compressed data stored in the zip file.
2058
2059 =back
2060
2061 =head1 Configuration and Compilation
2062
2063 =over 4
2064
2065 =item *
2066
2067 F<regexp.h> has been modified for compatibility with GCC's B<-Werror>
2068 option, as used by some projects that include perl's header files (5.14.1).
2069
2070 =item *
2071
2072 C<USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}> have been added the output of perl -V
2073 as they have affect the behaviour of the interpreter binary (albeit only
2074 in a small area).
2075
2076 =item *
2077
2078 The code and tests for L<IPC::Open2> have been moved from F<ext/IPC-Open2>
2079 into F<ext/IPC-Open3>, as C<IPC::Open2::open2()> is implemented as a thin
2080 wrapper around C<IPC::Open3::_open3()>, and hence is very tightly coupled to
2081 it.
2082
2083 =item *
2084
2085 The magic types and magic vtables are now generated from data in a new script
2086 F<regen/mg_vtable.pl>, instead of being maintained by hand.  As different
2087 EBCDIC variants can't agree on the code point for '~', the character to code
2088 point conversion is done at build time by F<generate_uudmap> to a new generated
2089 header F<mg_data.h>.  C<PL_vtbl_bm> and C<PL_vtbl_fm> are now defined by the
2090 pre-processor as C<PL_vtbl_regexp>, instead of being distinct C variables.
2091 C<PL_vtbl_sig> has been removed.
2092
2093 =item *
2094
2095 Building with C<-DPERL_GLOBAL_STRUCT> works again.  This configuration is not
2096 generally used.
2097
2098 =item *
2099
2100 Perl configured with I<MAD> now correctly frees C<MADPROP> structures when
2101 OPs are freed.  C<MADPROP>s are now allocated with C<PerlMemShared_malloc()>
2102
2103 =item *
2104
2105 F<makedef.pl> has been refactored.  This should have no noticeable affect on
2106 any of the platforms that use it as part of their build (AIX, VMS, Win32).
2107
2108 =item *
2109
2110 C<useperlio> can no longer be disabled.
2111
2112 =item *
2113
2114 The file F<global.sym> is no longer needed, and has been removed.  It
2115 contained a list of all exported functions, one of the files generated by
2116 F<regen/embed.pl> from data in F<embed.fnc> and F<regen/opcodes>.  The code
2117 has been refactored so that the only user of F<global.sym>, F<makedef.pl>,
2118 now reads F<embed.fnc> and F<regen/opcodes> directly, removing the need to
2119 store the list of exported functions in an intermediate file.
2120
2121 As F<global.sym> was never installed, this change should not be visible
2122 outside the build process.
2123
2124 =item *
2125
2126 F<pod/buildtoc>, used by the build process to build L<perltoc>, has been
2127 refactored and simplified.  It now only contains code to build L<perltoc>;
2128 the code to regenerate Makefiles has been moved to F<Porting/pod_rules.pl>.
2129 It's a bug if this change has any material effect on the build process.
2130
2131 =item *
2132
2133 F<pod/roffitall> is now built by F<pod/buildtoc>, instead of being
2134 shipped with the distribution.  Its list of manpages is now generated
2135 (and therefore current).  See also RT #103202 for an unresolved related
2136 issue.
2137
2138 =item *
2139
2140 The man page for C<XS::Typemap> is no longer installed.  C<XS::Typemap>
2141 is a test module which is not installed, hence installing its
2142 documentation makes no sense.
2143
2144 =item *
2145
2146 The -Dusesitecustomize and -Duserelocatableinc options now work
2147 together properly.
2148
2149 =back
2150
2151 =head1 Platform Support
2152
2153 =head2 Platform-Specific Notes
2154
2155 =head3 Cygwin
2156
2157 =over 4
2158
2159 =item *
2160
2161 Since version 1.7, Cygwin supports native UTF-8 paths.  If Perl is built
2162 under that environment, directory and filenames will be UTF-8 encoded.
2163
2164 Cygwin does not initialize all original Win32 environment variables.  See
2165 F<README.cygwin> for a discussion of the newly-added
2166 C<Cygwin::sync_winenv()> function [perl #110190] and for
2167 further links.
2168
2169 =back
2170
2171 =head3 HP-UX
2172
2173 =over 4
2174
2175 =item *
2176
2177 HP-UX PA-RISC/64 now supports gcc-4.x
2178
2179 A fix to correct the socketsize now makes the test suite pass on HP-UX
2180 PA-RISC for 64bitall builds.
2181
2182 =back
2183
2184 =head3 VMS
2185
2186 =over 4
2187
2188 =item *
2189
2190 Remove unnecessary includes, fix miscellaneous compiler warnings and
2191 close some unclosed comments on F<vms/vms.c>.
2192
2193 Remove sockadapt layer from the VMS build.
2194
2195 =item *
2196
2197 Explicit support for VMS versions prior to v7.0 and DEC C versions
2198 prior to v6.0 has been removed.
2199
2200 =item *
2201
2202 Since Perl 5.10.1, the home-grown C<stat> wrapper has been unable to
2203 distinguish between a directory name containing an underscore and an
2204 otherwise-identical filename containing a dot in the same position
2205 (e.g., t/test_pl as a directory and t/test.pl as a file).  This problem
2206 has been corrected.
2207
2208 =item *
2209
2210 The build on VMS now allows names of the resulting symbols in C code for
2211 Perl longer than 31 characters.  Symbols like
2212 C<Perl__it_was_the_best_of_times_it_was_the_worst_of_times> can now be
2213 created freely without causing the VMS linker to seize up.
2214
2215 =back
2216
2217 =head3 GNU/Hurd
2218
2219 Numerous build and test failures on GNU/Hurd have been resolved with hints
2220 for building DBM modules, detection of the library search path, and enabling
2221 of large file support.
2222
2223 =head3 OpenVOS
2224
2225 Perl is now built with dynamic linking on OpenVOS, the minimum supported
2226 version of which is now Release 17.1.0.
2227
2228 =head3 SunOS
2229
2230 The CC workshop C++ compiler is now detected and used on systems that ship
2231 without cc.
2232
2233 =head1 Internal Changes
2234
2235 =over 4
2236
2237 =item *
2238
2239 The compiled representation of formats is now stored via the C<mg_ptr> of
2240 their C<PERL_MAGIC_fm>.  Previously it was stored in the string buffer,
2241 beyond C<SvLEN()>, the regular end of the string.  C<SvCOMPILED()> and
2242 C<SvCOMPILED_{on,off}()> now exist solely for compatibility for XS code.
2243 The first is always 0, the other two now no-ops. (5.14.1)
2244
2245 =item *
2246
2247 Some global variables have been marked C<const>, members in the interpreter
2248 structure have been re-ordered, and the opcodes have been re-ordered.  The
2249 op C<OP_AELEMFAST> has been split into C<OP_AELEMFAST> and C<OP_AELEMFAST_LEX>.
2250
2251 =item *
2252
2253 When empting a hash of its elements (e.g. via undef(%h), or %h=()), HvARRAY
2254 field is no longer temporarily zeroed.  Any destructors called on the freed
2255 elements see the remaining elements.  Thus, %h=() becomes more like
2256 C<delete $h{$_} for keys %h>.
2257
2258 =item *
2259
2260 Boyer-Moore compiled scalars are now PVMGs, and the Boyer-Moore tables are now
2261 stored via the mg_ptr of their C<PERL_MAGIC_bm>.
2262 Previously they were PVGVs, with the tables stored in
2263 the string buffer, beyond C<SvLEN()>.  This eliminates
2264 the last place where the core stores data beyond C<SvLEN()>.
2265
2266 =item *
2267
2268 Simplified logic in C<Perl_sv_magic()> introduces a small change of
2269 behaviour for error cases involving unknown magic types.  Previously, if
2270 C<Perl_sv_magic()> was passed a magic type unknown to it, it would
2271
2272 =over
2273
2274 =item 1.
2275
2276 Croak "Modification of a read-only value attempted" if read only
2277
2278 =item 2.
2279
2280 Return without error if the SV happened to already have this magic
2281
2282 =item 3.
2283
2284 otherwise croak "Don't know how to handle magic of type \\%o"
2285
2286 =back
2287
2288 Now it will always croak "Don't know how to handle magic of type \\%o", even
2289 on read only values, or SVs which already have the unknown magic type.
2290
2291 =item *
2292
2293 The experimental C<fetch_cop_label> function has been renamed to
2294 C<cop_fetch_label>.
2295
2296 =item *
2297
2298 The C<cop_store_label> function has been added to the API, but is
2299 experimental.
2300
2301 =item *
2302
2303 F<embedvar.h> has been simplified, and one level of macro indirection for
2304 PL_* variables has been removed for the default (non-multiplicity)
2305 configuration.  PERLVAR*() macros now directly expand their arguments to
2306 tokens such as C<PL_defgv>, instead of expanding to C<PL_Idefgv>, with
2307 F<embedvar.h> defining a macro to map C<PL_Idefgv> to C<PL_defgv>.  XS code
2308 which has unwarranted chumminess with the implementation may need updating.
2309
2310 =item *
2311
2312 A C<coreargs> opcode has been added, to be used by C<&CORE::foo> subs to sort
2313 out C<@_>.
2314
2315 =item *
2316
2317 An API has been added to explicitly choose whether or not to export XSUB
2318 symbols.  More detail can be found in the comments for commit e64345f8.
2319
2320 =item *
2321
2322 The C<is_gv_magical_sv> function has been eliminated and merged with
2323 C<gv_fetchpvn_flags>.  It used to be called to determine whether a GV
2324 should be autovivified in rvalue context.  Now it has been replaced with a
2325 new C<GV_ADDMG> flag (not part of the API).
2326
2327 =item *
2328
2329 The returned code point from the function C<utf8n_to_uvuni()>
2330 when the input is malformed UTF-8, malformations are allowed, and
2331 C<utf8> warnings are off is now the Unicode REPLACEMENT CHARACTER
2332 whenever the malformation is such that no well-defined code point can be
2333 computed.  Previously the returned value was essentially garbage.  The
2334 only malformations that have well-defined values are a zero-length
2335 string (0 is the return), and overlong UTF-8 sequences.
2336
2337 =item *
2338
2339 The returned code point from the function C<utf8n_to_uvuni()>
2340 when the input is malformed UTF-8, malformations are allowed, and
2341 C<utf8> warnings are off is now the Unicode REPLACEMENT CHARACTER
2342 whenever the malformation is such that no well-defined code point can be
2343 computed.  Previously the returned value was essentially garbage.  The
2344 only malformations that have well-defined values are a zero-length
2345 string (0 is the return), and overlong UTF-8 sequences.
2346
2347 =item *
2348
2349 Padlists are now marked C<AvREAL>; i.e., reference-counted.  They have
2350 always been reference-counted, but were not marked real, because F<pad.c>
2351 did its own clean-up, instead of using the usual clean-up code in F<sv.c>.
2352 That caused problems in thread cloning, so now the C<AvREAL> flag is on,
2353 but is turned off in F<pad.c> right before the padlist is freed (after
2354 F<pad.c> has done its custom freeing of the pads).
2355
2356 =item *
2357
2358 All the C files that make up the Perl core have been converted to UTF-8.
2359
2360 =item *
2361
2362 These new functions have been added as part of the work on Unicode symbols:
2363
2364     HvNAMELEN
2365     HvNAMEUTF8
2366     HvENAMELEN
2367     HvENAMEUTF8
2368     gv_init_pv
2369     gv_init_pvn
2370     gv_init_pvsv
2371     gv_fetchmeth_pv
2372     gv_fetchmeth_pvn
2373     gv_fetchmeth_sv
2374     gv_fetchmeth_pv_autoload
2375     gv_fetchmeth_pvn_autoload
2376     gv_fetchmeth_sv_autoload
2377     gv_fetchmethod_pv_flags
2378     gv_fetchmethod_pvn_flags
2379     gv_fetchmethod_sv_flags
2380     gv_autoload_pv
2381     gv_autoload_pvn
2382     gv_autoload_sv
2383     newGVgen_flags
2384     sv_derived_from_pv
2385     sv_derived_from_pvn
2386     sv_derived_from_sv
2387     sv_does_pv
2388     sv_does_pvn
2389     sv_does_sv
2390     whichsig_pv
2391     whichsig_pvn
2392     whichsig_sv
2393     newCONSTSUB_flags
2394
2395 The gv_fetchmethod_*_flags functions, like gv_fetchmethod_flags, are
2396 experimental and may change in a future release.
2397
2398 =item *
2399
2400 The following functions were added.  These are I<not> part of the API:
2401
2402     GvNAMEUTF8
2403     GvENAMELEN
2404     GvENAME_HEK
2405     CopSTASH_flags
2406     CopSTASH_flags_set
2407     PmopSTASH_flags
2408     PmopSTASH_flags_set
2409     sv_sethek
2410     HEKfARG
2411
2412 There is also a C<HEKf> macro corresponding to C<SVf>, for
2413 interpolating HEKs in formatted strings.
2414
2415 =item *
2416
2417 C<sv_catpvn_flags> takes a couple of new internal-only flags,
2418 C<SV_CATBYTES> and C<SV_CATUTF8>, which tell it whether the char array to
2419 be concatenated is UTF8.  This allows for more efficient concatenation than
2420 creating temporary SVs to pass to C<sv_catsv>.
2421
2422 =item *
2423
2424 For XS AUTOLOAD subs, $AUTOLOAD is set once more, as it was in 5.6.0.  This
2425 is in addition to setting C<SvPVX(cv)>, for compatibility with 5.8 to 5.14.
2426 See L<perlguts/Autoloading with XSUBs>.
2427
2428 =item *
2429
2430 Perl now checks whether the array (the linearised isa) returned by a MRO
2431 plugin begins with the name of the class itself, for which the array was
2432 created, instead of assuming that it does.  This prevents the first element
2433 from being skipped during method lookup.  It also means that
2434 C<mro::get_linear_isa> may return an array with one more element than the
2435 MRO plugin provided [perl #94306].
2436
2437 =item *
2438
2439 C<PL_curstash> is now reference-counted.
2440
2441 =item *
2442
2443 There are now feature bundle hints in C<PL_hints> (C<$^H>) that version
2444 declarations use, to avoid having to load F<feature.pm>.  One setting of
2445 the hint bits indicates a "custom" feature bundle, which means that the
2446 entries in C<%^H> still apply.  F<feature.pm> uses that.
2447
2448 The C<HINT_FEATURE_MASK> macro is defined in F<perl.h> along with other
2449 hints.  Other macros for setting and testing features and bundles are in
2450 the new F<feature.h>.  C<FEATURE_IS_ENABLED> (which has moved to
2451 F<feature.h>) is no longer used throughout the codebase, but more specific
2452 macros, e.g., C<FEATURE_SAY_IS_ENABLED>, that are defined in F<feature.h>.
2453
2454 =item *
2455
2456 F<lib/feature.pm> is now a generated file, created by the new
2457 F<regen/feature.pl> script, which also generates F<feature.h>.
2458
2459 =item *
2460
2461 Tied arrays are now always C<AvREAL>.  If C<@_> or C<DB::args> is tied, it
2462 is reified first, to make sure this is always the case.
2463
2464 =item *
2465
2466 Two new functions C<utf8_to_uvchr_buf()> and C<utf8_to_uvuni_buf()> have
2467 been added.  These are the same as C<utf8_to_uvchr> and
2468 C<utf8_to_uvuni> (which are now deprecated), but take an extra parameter
2469 that is used to guard against reading beyond the end of the input
2470 string.
2471 See L<perlapi/utf8_to_uvchr_buf> and L<perlapi/utf8_to_uvuni_buf>.
2472
2473 =item *
2474
2475 The regular expression engine now does TRIE case insensitive matches
2476 under Unicode. This may change the output of C<< use re 'debug'; >>,
2477 and will speed up various things.
2478
2479 =item *
2480
2481 There is a new C<wrap_op_checker()> function, which provides a thread-safe
2482 alternative to writing to C<PL_check> directly.
2483
2484 =back
2485
2486 =head1 Selected Bug Fixes
2487
2488 =head2 Array and hash
2489
2490 =over
2491
2492 =item *
2493
2494 A bug has been fixed that would cause a "Use of freed value in iteration"
2495 error if the next two hash elements that would be iterated over are
2496 deleted [perl #85026]. (5.14.1)
2497
2498 =item *
2499
2500 Deleting the current hash iterator (the hash element that would be returend
2501 by the next call to C<each>) in void context used not to free it
2502 [perl #85026].
2503
2504 =item *
2505
2506 Deletion of methods via C<delete $Class::{method}> syntax used to update
2507 method caches if called in void context, but not scalar or list context.
2508
2509 =item *
2510
2511 When hash elements are deleted in void context, the internal hash entry is
2512 now freed before the value is freed, to prevent destructors called by that
2513 latter freeing from seeing the hash in an inconsistent state.  It was
2514 possible to cause double-frees if the destructor freed the hash itself
2515 [perl #100340].
2516
2517 =item *
2518
2519 A C<keys> optimisation in Perl 5.12.0 to make it faster on empty hashes
2520 caused C<each> not to reset the iterator if called after the last element
2521 was deleted.
2522
2523 =item *
2524
2525 Freeing deeply nested hashes no longer crashes [perl #44225].
2526
2527 =item *
2528
2529 It is possible from XS code to create hashes with elements that have no
2530 values.  The hash element and slice operators used to crash
2531 when handling these in lvalue context.  They now
2532 produce a "Modification of non-creatable hash value attempted" error
2533 message.
2534
2535 =item *
2536
2537 If list assignment to a hash or array triggered destructors that freed the
2538 hash or array itself, a crash would ensue.  This is no longer the case
2539 [perl #107440].
2540
2541 =item *
2542
2543 It used to be possible to free the typeglob of a localised array or hash
2544 (e.g., C<local @{"x"}; delete $::{x}>), resulting in a crash on scope exit.
2545
2546 =item *
2547
2548 Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
2549 element that is a glob copy no longer causes subsequent assignment to it to
2550 corrupt the glob, and unlocking a hash element that holds a copy-on-write
2551 scalar no longer causes modifications to that scalar to modify other
2552 scalars that were sharing the same string buffer.
2553
2554 =back
2555
2556 =head2 C API fixes
2557
2558 =over
2559
2560 =item *
2561
2562 The C<newHVhv> XS function now works on tied hashes, instead of crashing or
2563 returning an empty hash.
2564
2565 =item *
2566
2567 The C<SvIsCOW> C macro now returns false for read-only copies of typeglobs,
2568 such as those created by:
2569
2570   $hash{elem} = *foo;
2571   Hash::Util::lock_value %hash, 'elem';
2572
2573 It used to return true.
2574
2575 =item *
2576
2577 The C<SvPVutf8> C function no longer tries to modify its argument,
2578 resulting in errors [perl #108994].
2579
2580 =item *
2581
2582 C<SvPVutf8> now works properly with magical variables.
2583
2584 =item *
2585
2586 C<SvPVbyte> now works properly non-PVs.
2587
2588 =item *
2589
2590 When presented with malformed UTF-8 input, the XS-callable functions
2591 C<is_utf8_string()>, C<is_utf8_string_loc()>, and
2592 C<is_utf8_string_loclen()> could read beyond the end of the input
2593 string by up to 12 bytes.  This no longer happens.  [perl #32080].
2594 However, currently, C<is_utf8_char()> still has this defect, see
2595 L</is_utf8_char()> above.
2596
2597 =item *
2598
2599 The C-level C<pregcomp> function could become confused as to whether the
2600 pattern was in UTF8 if the pattern was an overloaded, tied, or otherwise
2601 magical scalar [perl #101940].
2602
2603 =back
2604
2605 =head2 Compile-time hints
2606
2607 =over
2608
2609 =item *
2610
2611 Tying C<%^H> no longer causes perl to crash or ignore the contents of
2612 C<%^H> when entering a compilation scope [perl #106282].
2613
2614 =item *
2615
2616 C<eval $string> and C<require> used not to
2617 localise C<%^H> during compilation if it
2618 was empty at the time the C<eval> call itself was compiled.  This could
2619 lead to scary side effects, like C<use re "/m"> enabling other flags that
2620 the surrounding code was trying to enable for its caller [perl #68750].
2621
2622 =item *
2623
2624 C<eval $string> and C<require> no longer localise hints (C<$^H> and C<%^H>)
2625 at run time, but only during compilation of the $string or required file.
2626 This makes C<BEGIN { $^H{foo}=7 }> equivalent to
2627 C<BEGIN { eval '$^H{foo}=7' }> [perl #70151].
2628
2629 =item *
2630
2631 Creating a BEGIN block from XS code (via C<newXS> or C<newATTRSUB>) would,
2632 on completion, make the hints of the current compiling code the current
2633 hints.  This could cause warnings to occur in a non-warning scope.
2634
2635 =back
2636
2637 =head2 Copy-on-write scalars
2638
2639 Copy-on-write or shared hash key scalars
2640 were introduced in 5.8.0, but most Perl code
2641 did not encounter them (they were used mostly internally).  Perl
2642 5.10.0 extended them, such that assigning C<__PACKAGE__> or a
2643 hash key to a scalar would make it copy-on-write.  Several parts
2644 of Perl were not updated to account for them, but have now been fixed.
2645
2646 =over
2647
2648 =item *
2649
2650 C<utf8::decode> had a nasty bug that would modify copy-on-write scalars'
2651 string buffers in place (i.e., skipping the copy).  This could result in
2652 hashes having two elements with the same key [perl #91834].
2653
2654 =item *
2655
2656 Lvalue subroutines were not allowing COW scalars to be returned.  This was
2657 fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0, but list context
2658 was not fixed until this release.
2659
2660 =item *
2661
2662 Elements of restricted hashes (see the L<fields> pragma) containing
2663 copy-on-write values couldn't be deleted, nor could such hashes be cleared
2664 (C<%hash = ()>).
2665
2666 =item *
2667
2668 Localising a tied variable used to make it read-only if it contained a
2669 copy-on-write string.
2670
2671 =item *
2672
2673 Assigning a copy-on-write string to a stash
2674 element no longer causes a double free.  Regardless of this change, the
2675 results of such assignments are still undefined.
2676
2677 =item *
2678
2679 Assigning a copy-on-write string to a tied variable no longer stops that
2680 variable from being tied if it happens to be a PVMG or PVLV internally.
2681
2682 =item *
2683
2684 Doing a substitution on a tied variable returning a copy-on-write
2685 scalar used to cause an assertion failure or an "Attempt to free
2686 nonexistent shared string" warning.
2687
2688 =item *
2689
2690 This one is a regression from 5.12: In 5.14.0, the bitwise assignment
2691 operators C<|=>, C<^=> and C<&=> started leaving the left-hand side
2692 undefined if it happened to be a copy-on-write string [perl #108480].
2693
2694 =item *
2695
2696 L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
2697 See L</Updated Modules and Pragmata>, above.
2698
2699 =back
2700
2701 =head2 The debugger
2702
2703 =over
2704
2705 =item *
2706
2707 F<dumpvar.pl>, and consequently the C<x> command in the debugger, have been
2708 fixed to handle objects blessed into classes whose names contain "=".  The
2709 contents of such objects used not to be dumped [perl #101814].
2710
2711 =item *
2712
2713 The "R" command for restarting a debugger session has been fixed to work on
2714 Windows, or any other system lacking a C<POSIX::_SC_OPEN_MAX> constant
2715 [perl #87740].
2716
2717 =item *
2718
2719 The C<#line 42 foo> directive used not to update the arrays of lines used
2720 by the debugger if it occurred in a string eval.  This was partially fixed
2721 in 5.14, but it only worked for a single C<#line 42 foo> in each eval.  Now
2722 it works for multiple.
2723
2724 =item *
2725
2726 When subroutine calls are intercepted by the debugger, the name of the
2727 subroutine or a reference to it is stored in C<$DB::sub>, for the debugger
2728 to access.  In some cases (such as C<$foo = *bar; undef *bar; &$foo>)
2729 C<$DB::sub> would be set to a name that could not be used to find the
2730 subroutine, and so the debugger's attempt to call it would fail.  Now the
2731 check to see whether a reference is needed is more robust, so those
2732 problems should not happen anymore [rt.cpan.org #69862].
2733
2734 =item *
2735
2736 Every subroutine has a filename associated with it that the debugger uses.
2737 The one associated with constant subroutines used to be misallocated when
2738 cloned under threads.  Consequently, debugging threaded applications could
2739 result in memory corruption [perl #96126].
2740
2741 =back
2742
2743 =head2 Dereferencing operators
2744
2745 =over
2746
2747 =item *
2748
2749 C<defined(${"..."})>, C<defined(*{"..."})>, etc., used to
2750 return true for most, but not all built-in variables, if
2751 they had not been used yet.  This bug affected C<${^GLOBAL_PHASE}> and
2752 C<${^UTF8CACHE}>, among others.  It also used to return false if the
2753 package name was given as well (C<${"::!"}>) [perl #97978, #97492].
2754
2755 =item *
2756
2757 Perl 5.10.0 introduced a similar bug: C<defined(*{"foo"})> where "foo"
2758 represents the name of a built-in global variable used to return false if
2759 the variable had never been used before, but only on the I<first> call.
2760 This, too, has been fixed.
2761
2762 =item *
2763
2764 Since 5.6.0, C<*{ ... }> has been inconsistent in how it treats undefined
2765 values.  It would die in strict mode or lvalue context for most undefined
2766 values, but would be treated as the empty string (with a warning) for the
2767 specific scalar return by C<undef()> (C<&PL_sv_undef> internally).  This
2768 has been corrected.  C<undef()> is now treated like other undefined
2769 scalars, as in Perl 5.005.
2770
2771 =back
2772
2773 =head2 Filehandle, last-accessed
2774
2775 Perl has an internal variable that stores the last filehandle to be
2776 accessed.  It is used by C<$.> and by C<tell> and C<eof> without
2777 arguments.
2778
2779 =over
2780
2781 =item *
2782
2783 It used to be possible to set this internal variable to a glob copy and
2784 then modify that glob copy to be something other than a glob, and still
2785 have the last-accessed filehandle associated with the variable after
2786 assigning a glob to it again:
2787
2788     my $foo = *STDOUT;  # $foo is a glob copy
2789     <$foo>;             # $foo is now the last-accessed handle
2790     $foo = 3;           # no longer a glob
2791     $foo = *STDERR;     # still the last-accessed handle
2792
2793 Now the C<$foo = 3> assignment unsets that internal variable, so there
2794 is no last-accessed filehandle, just as if C<< <$foo> >> had never
2795 happened.
2796
2797 This also prevents some unrelated handle from becoming the last-accessed
2798 handle if $foo falls out of scope and the same internal SV gets used for
2799 another handle [perl #97988].
2800
2801 =item *
2802
2803 A regression in 5.14 caused these statements not to set that internal
2804 variable:
2805
2806     my $fh = *STDOUT;
2807     tell $fh;
2808     eof  $fh;
2809     seek $fh, 0,0;
2810     tell     *$fh;
2811     eof      *$fh;
2812     seek     *$fh, 0,0;
2813     readline *$fh;
2814
2815 This is now fixed, but C<tell *{ *$fh }> still has the problem, and it
2816 is not clear how to fix it [perl #106536].
2817
2818 =back
2819
2820 =head2 Filetests and C<stat>
2821
2822 The term "filetests" refers to the operators that consist of a hyphen
2823 followed by a single letter: C<-r>, C<-x>, C<-M>, etc.  The term "stacked"
2824 when applied to filetests means followed by another filetest operator
2825 sharing the same operand, as in C<-r -x -w $fooo>.
2826
2827 =over
2828
2829 =item *
2830
2831 C<stat> produces more consistent warnings.  It no longer warns for "_"
2832 [perl #71002] and no longer skips the warning at times for other unopened
2833 handles.  It no longer warns about an unopened handle when the operating
2834 system's C<fstat> function fails.
2835
2836 =item *
2837
2838 C<stat> would sometimes return negative numbers for large inode numbers,
2839 because it was using the wrong internal C type. [perl #84590]
2840
2841 =item *
2842
2843 C<lstat> is documented to fall back to C<stat> (with a warning) when given
2844 a filehandle.  When passed an IO reference, it was actually doing the
2845 equivalent of S<C<stat _>> and ignoring the handle.
2846
2847 =item *
2848
2849 C<-T _> with no preceding C<stat> used to produce a
2850 confusing "uninitialized" warning, even though there
2851 is no visible uninitialized value to speak of.
2852
2853 =item *
2854
2855 C<-T>, C<-B>, C<-l> and C<-t> now work
2856 when stacked with other filetest operators
2857 [perl #77388].
2858
2859 =item *
2860
2861 In 5.14.0, filetest ops (C<-r>, C<-x>, etc.) started calling FETCH on a
2862 tied argument belonging to the previous argument to a list operator, if
2863 called with a bareword argument or no argument at all.  This has been
2864 fixed, so C<push @foo, $tied, -r> no longer calls FETCH on C<$tied>.
2865
2866 =item *
2867
2868 In Perl 5.6, C<-l> followed by anything other than a bareword would treat
2869 its argument as a file name.  That was changed in 5.8 for glob references
2870 (C<\*foo>), but not for globs themselves (C<*foo>).  C<-l> started
2871 returning C<undef> for glob references without setting the last
2872 stat buffer that the "_" handle uses, but only if warnings
2873 were turned on.  With warnings off, it was the same as 5.6.
2874 In other words, it was simply buggy and inconsistent.  Now the 5.6
2875 behaviour has been restored.
2876
2877 =item *
2878
2879 C<-l> followed by a bareword no longer "eats" the previous argument to
2880 the list operator in whose argument list it resides.  Hence,
2881 C<print "bar", -l foo> now actually prints "bar", because C<-l>
2882 on longer eats it.
2883
2884 =item *
2885
2886 Perl keeps several internal variables to keep track of the last stat
2887 buffer, from which file(handle) it originated, what type it was, and
2888 whether the last stat succeeded.
2889
2890 There were various cases where these could get out of synch, resulting in
2891 inconsistent or erratic behaviour in edge cases (every mention of C<-T>
2892 applies to C<-B> as well):
2893
2894 =over
2895
2896 =item *
2897
2898 C<-T I<HANDLE>>, even though it does a C<stat>, was not resetting the last
2899 stat type, so an C<lstat _> following it would merrily return the wrong
2900 results.  Also, it was not setting the success status.
2901
2902 =item *
2903
2904 Freeing the handle last used by C<stat> or a filetest could result in
2905 S<C<-T _>> using an unrelated handle.
2906
2907 =item *
2908
2909 C<stat> with an IO reference would not reset the stat type or record the
2910 filehandle for S<C<-T _>> to use.
2911
2912 =item *
2913
2914 Fatal warnings could cause the stat buffer not to be reset
2915 for a filetest operator on an unopened filehandle or C<-l> on any handle.
2916 Fatal warnings also stopped C<-T> from setting C<$!>.
2917
2918 =item *
2919
2920 When the last stat was on an unreadable file, C<-T _> is supposed to
2921 return C<undef>, leaving the last stat buffer unchanged.  But it was
2922 setting the stat type, causing C<lstat _> to stop working.
2923
2924 =item *
2925
2926 C<-T I<FILENAME>> was not resetting the internal stat buffers for
2927 unreadable files.
2928
2929 =back
2930
2931 These have all been fixed.
2932
2933 =back
2934
2935 =head2 Formats
2936
2937 =over
2938
2939 =item *
2940
2941 A number of edge cases have been fixed with formats and C<formline>;
2942 in particular, where the format itself is potentially variable (such as
2943 with ties and overloading), and where the format and data differ in their
2944 encoding.  In both these cases, it used to possible for the output to be
2945 corrupted [perl #91032].
2946
2947 =item *
2948
2949 C<formline> no longer converts its argument into a string in-place.  So
2950 passing a reference to C<formline> no longer destroys the reference
2951 [perl #79532].
2952
2953 =item *
2954
2955 Assignment to C<$^A> (the format output accumulator) now recalculates
2956 the number of lines output.
2957
2958 =back
2959
2960 =head2 C<given> and C<when>
2961
2962 =over
2963
2964 =item *
2965
2966 C<given> was not scoping its implicit $_ properly, resulting in memory
2967 leaks or "Variable is not available" warnings [perl #94682].
2968
2969 =item *
2970
2971 C<given> was not calling set-magic on the implicit lexical C<$_> that it
2972 uses.  This meant, for example, that C<pos> would be remembered from one
2973 execution of the same C<given> block to the next, even if the input were a
2974 different variable [perl #84526].
2975
2976 =item *
2977
2978 C<when> blocks are now capable of returning variables declared inside the
2979 enclosing C<given> block [perl #93548].
2980
2981 =back
2982
2983 =head2 The C<glob> operator
2984
2985 =over
2986
2987 =item *
2988
2989 On OSes other than VMS, Perl's C<glob> operator (and the C<< <...> >> form)
2990 use L<File::Glob> underneath.  L<File::Glob> splits the pattern into words,
2991 before feeding each word to its C<bsd_glob> function.
2992
2993 There were several inconsistencies in the way the split was done.  Now
2994 quotation marks (' and ") are always treated as shell-style word delimiters
2995 (that allow whitespace as part of a word) and backslashes are always
2996 preserved, unless they exist to escape quotation marks.  Before, those
2997 would only sometimes be the case, depending on whether the pattern
2998 contained whitespace.  Also, escaped whitespace at the end of the pattern
2999 is no longer stripped [perl #40470].
3000
3001 =item *
3002
3003 C<CORE::glob> now works as a way to call the default globbing function.  It
3004 used to respect overrides, despite the C<CORE::> prefix.
3005
3006 =item *
3007
3008 Under miniperl (used to configure modules when perl itself is built),
3009 C<glob> now clears %ENV before calling csh, since the latter croaks on some
3010 systems if it does not like the contents of the LS_COLORS enviroment
3011 variable [perl #98662].
3012
3013 =back
3014
3015 =head2 Lvalue subroutines
3016
3017 =over
3018
3019 =item *
3020
3021 Explicit return now returns the actual argument passed to return, instead
3022 of copying it [perl #72724, #72706].
3023
3024 =item *
3025
3026 Lvalue subroutines used to enforce lvalue syntax (i.e., whatever can go on
3027 the left-hand side of C<=>) for the last statement and the arguments to
3028 return.  Since lvalue subroutines are not always called in lvalue context,
3029 this restriction has been lifted.
3030
3031 =item *
3032
3033 Lvalue subroutines are less restrictive as to what values can be returned.
3034 It used to croak on values returned by C<shift> and C<delete> and from
3035 other subroutines, but no longer does so [perl #71172].
3036
3037 =item *
3038
3039 Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
3040 context.  In fact, all subroutines used to, but regular subs were fixed in
3041 Perl 5.8.2.  Now lvalue subroutines have been likewise fixed.
3042
3043 =item *
3044
3045 Autovivification now works on values returned from lvalue subroutines
3046 [perl #7946], as does returning C<keys> in lvalue context.
3047
3048 =item *
3049
3050 Lvalue subroutines used to copy their return values in rvalue context.  Not
3051 only was this a waste of CPU cycles, but it also caused bugs.  A C<($)>
3052 prototype would cause an lvalue sub to copy its return value [perl #51408],
3053 and C<while(lvalue_sub() =~ m/.../g) { ... }> would loop endlessly
3054 [perl #78680].
3055
3056 =item *
3057
3058 When called in potential lvalue context
3059 (e.g., subroutine arguments or a list
3060 passed to C<for>), lvalue subroutines used to copy
3061 any read-only value that was returned.  E.g., C< sub :lvalue { $] } >
3062 would not return C<$]>, but a copy of it.
3063
3064 =item *
3065
3066 When called in potential lvalue context, an lvalue subroutine returning
3067 arrays or hashes used to bind the arrays or hashes to scalar variables,
3068 resulting in bugs.  This was fixed in 5.14.0 if an array were the first
3069 thing returned from the subroutine (but not for C<$scalar, @array> or
3070 hashes being returned).  Now a more general fix has been applied
3071 [perl #23790].
3072
3073 =item *
3074
3075 Method calls whose arguments were all surrounded with C<my()> or C<our()>
3076 (as in C<< $object->method(my($a,$b)) >>) used to force lvalue context on
3077 the subroutine.  This would prevent lvalue methods from returning certain
3078 values.
3079
3080 =item *
3081
3082 Lvalue sub calls that are not determined to be such at compile time
3083 (C<&$name> or &{"name"}) are no longer exempt from strict refs if they
3084 occur in the last statement of an lvalue subroutine [perl #102486].
3085
3086 =item *
3087
3088 Sub calls whose subs are not visible at compile time, if
3089 they occurred in the last statement of an lvalue subroutine,
3090 would reject non-lvalue subroutines and die with "Can't modify non-lvalue
3091 subroutine call" [perl #102486].
3092
3093 Non-lvalue sub calls whose subs I<are> visible at compile time exhibited
3094 the opposite bug.  If the call occurred in the last statement of an lvalue
3095 subroutine, there would be no error when the lvalue sub was called in
3096 lvalue context.  Perl would blindly assign to the temporary value returned
3097 by the non-lvalue subroutine.
3098
3099 =item *
3100
3101 C<AUTOLOAD> routines used to take precedence over the actual sub being
3102 called (i.e., when autoloading wasn't needed), for sub calls in lvalue or
3103 potential lvalue context, if the subroutine was not visible at compile
3104 time.
3105
3106 =item *
3107
3108 Applying the C<:lvalue> attribute to an XSUB or to an aliased subroutine
3109 stub with C<< sub foo :lvalue; >> syntax stopped working in Perl 5.12.
3110 This has been fixed.
3111
3112 =item *
3113
3114 Applying the :lvalue attribute to subroutine that is already defined does
3115 not work properly, as the attribute changes the way the sub is compiled.
3116 Hence, Perl 5.12 began warning when an attempt is made to apply the
3117 attribute to an already defined sub.  In such cases, the attribute is
3118 discarded.
3119
3120 But the change in 5.12 missed the case where custom attributes are also
3121 present: that case still silently and ineffectively applied the attribute.
3122 That omission has now been corrected.  C<sub foo :lvalue :Whatever> (when
3123 C<foo> is already defined) now warns about the :lvalue attribute, and does
3124 not apply it.
3125
3126 =item *
3127
3128 A bug affecting lvalue context propagation through nested lvalue subroutine
3129 calls has been fixed.  Previously, returning a value in nested rvalue
3130 context would be treated as lvalue context by the inner subroutine call,
3131 resulting in some values (such as read-only values) being rejected.
3132
3133 =back
3134
3135 =head2 Overloading
3136
3137 =over
3138
3139 =item *
3140
3141 Arithmetic assignment (C<$left += $right>) involving overloaded objects
3142 that rely on the 'nomethod' override no longer segfault when the left
3143 operand is not overloaded.
3144
3145 =item *
3146
3147 Errors that occur when methods cannot be found during overloading now
3148 mention the correct package name, as they did in 5.8.x, instead of
3149 erroneously mentioning the "overload" package, as they have since 5.10.0.
3150
3151 =item *
3152
3153 Undefining C<%overload::> no longer causes a crash.
3154
3155 =back
3156
3157 =head2 Prototypes of built-in keywords
3158
3159 =over
3160
3161 =item *
3162
3163 The C<prototype> function no longer dies for the C<__FILE__>, C<__LINE__>
3164 and C<__PACKAGE__> directives.  It now returns an empty-string prototype
3165 for them, because they are syntactically indistinguishable from nullary
3166 functions like C<time>.
3167
3168 =item *
3169
3170 C<prototype> now returns C<undef> for all overridable infix operators,
3171 such as C<eq>, which are not callable in any way resembling functions.
3172 It used to return incorrect prototypes for some and die for others
3173 [perl #94984].
3174
3175 =item *
3176
3177 The prototypes of several built-in functions--C<getprotobynumber>, C<lock>,
3178 C<not> and C<select>--have been corrected, or at least are now closer to
3179 reality than before.
3180
3181 =back
3182
3183 =head2 Regular expressions
3184
3185 =for comment Is it possible to merge some of these items?
3186
3187 =over 4
3188
3189 =item *
3190
3191 C</[[:ascii:]]/> and C</[[:blank:]]/> now use locale rules under
3192 C<use locale> when the platform supports that.  Previously, they used
3193 the platform's native character set.
3194
3195 =item *
3196
3197 C<m/[[:ascii:]]/i> and C</\p{ASCII}/i> now match identically (when not
3198 under a differing locale).  This fixes a regression introduced in 5.14
3199 in which the first expression could match characters outside of ASCII,
3200 such as the KELVIN SIGN.
3201
3202 =item *
3203
3204 C</.*/g> would sometimes refuse to match at the end of a string that ends
3205 with "\n".  This has been fixed [perl #109206].
3206
3207 =item *
3208
3209 Starting with 5.12.0, Perl used to get its internal bookkeeping muddled up
3210 after assigning C<${ qr// }> to a hash element and locking it with
3211 L<Hash::Util>.  This could result in double frees, crashes or erratic
3212 behaviour.
3213
3214 =item *
3215
3216 The new (in 5.14.0) regular expression modifier C</a> when repeated like
3217 C</aa> forbids the characters outside the ASCII range that match
3218 characters inside that range from matching under C</i>.  This did not
3219 work under some circumstances, all involving alternation, such as:
3220
3221  "\N{KELVIN SIGN}" =~ /k|foo/iaa;
3222
3223 succeeded inappropriately.  This is now fixed.
3224
3225 =item *
3226
3227 5.14.0 introduced some memory leaks in regular expression character
3228 classes such as C<[\w\s]>, which have now been fixed. (5.14.1)
3229
3230 =item *
3231
3232 An edge case in regular expression matching could potentially loop.
3233 This happened only under C</i> in bracketed character classes that have
3234 characters with multi-character folds, and the target string to match
3235 against includes the first portion of the fold, followed by another
3236 character that has a multi-character fold that begins with the remaining
3237 portion of the fold, plus some more.
3238
3239  "s\N{U+DF}" =~ /[\x{DF}foo]/i
3240
3241 is one such case.  C<\xDF> folds to C<"ss">. (5.14.1)
3242
3243 =item *
3244
3245 A few characters in regular expression pattern matches did not
3246 match correctly in some circumstances, all involving C</i>.  The
3247 affected characters are:
3248 COMBINING GREEK YPOGEGRAMMENI,
3249 GREEK CAPITAL LETTER IOTA,
3250 GREEK CAPITAL LETTER UPSILON,
3251 GREEK PROSGEGRAMMENI,
3252 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
3253 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
3254 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA,
3255 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
3256 LATIN SMALL LETTER LONG S,
3257 LATIN SMALL LIGATURE LONG S T,
3258 and
3259 LATIN SMALL LIGATURE ST.
3260
3261 =item *
3262
3263 A memory leak regression in regular expression compilation
3264 under threading has been fixed.
3265
3266 =item *
3267
3268 A regression introduced in 5.13.6 has
3269 been fixed.  This involved an inverted
3270 bracketed character class in a regular expression that consisted solely
3271 of a Unicode property.  That property wasn't getting inverted outside the
3272 Latin1 range.
3273
3274 =item *
3275
3276 Three problematic Unicode characters now work better in regex pattern matching under C</i>
3277
3278 In the past, three Unicode characters:
3279 LATIN SMALL LETTER SHARP S,
3280 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
3281 and
3282 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
3283 along with the sequences that they fold to
3284 (including "ss" in the case of LATIN SMALL LETTER SHARP S),
3285 did not properly match under C</i>.  5.14.0 fixed some of these cases,
3286 but introduced others, including a panic when one of the characters or
3287 sequences was used in the C<(?(DEFINE)> regular expression predicate.
3288 The known bugs that were introduced in 5.14 have now been fixed; as well
3289 as some other edge cases that have never worked until now.  All these
3290 involve using the characters and sequences outside bracketed character
3291 classes under C</i>.  This closes [perl #98546].
3292
3293 There remain known problems when using certain characters with
3294 multi-character folds inside bracketed character classes, including such
3295 constructs as C<qr/[\N{LATIN SMALL LETTER SHARP}a-z]/i>.  These
3296 remaining bugs are addressed in [perl #89774].
3297
3298 =item *
3299
3300 RT #78266: The regex engine has been leaking memory when accessing
3301 named captures that weren't matched as part of a regex ever since 5.10
3302 when they were introduced, e.g. this would consume over a hundred MB of
3303 memory:
3304
3305     for (1..10_000_000) {
3306         if ("foo" =~ /(foo|(?<capture>bar))?/) {
3307             my $capture = $+{capture}
3308         }
3309     }
3310     system "ps -o rss $$"'
3311
3312 =item *
3313
3314 In 5.14, C</[[:lower:]]/i> and C</[[:upper:]]/i> no longer matched the
3315 opposite case.  This has been fixed [perl #101970].
3316
3317 =item *
3318
3319 A regular expression match with an overloaded object on the right-hand side
3320 would in some cases stringify the object too many times.
3321
3322 =item *
3323
3324 A regression has been fixed that was introduced in 5.14, in C</i>
3325 regular expression matching, in which a match improperly fails if the
3326 pattern is in UTF-8, the target string is not, and a Latin-1 character
3327 precedes a character in the string that should match the pattern.
3328 [perl #101710]
3329
3330 =item *
3331
3332 In case-insensitive regular expression pattern matching, no longer on
3333 UTF-8 encoded strings does the scan for the start of match only look at
3334 the first possible position.  This caused matches such as
3335 C<"f\x{FB00}" =~ /ff/i> to fail.
3336
3337 =item *
3338
3339 The regexp optimiser no longer crashes on debugging builds when merging
3340 fixed-string nodes with inconvenient contents.
3341
3342 =item *
3343
3344 A panic involving the combination of the regular expression modifiers
3345 C</aa> and the C<\b> escape sequence introduced in 5.14.0 has been
3346 fixed [perl #95964].
3347
3348 =item *
3349
3350 The combination of the regular expression modifiers C</aa> and the C<\b>
3351 and C<\B> escape sequences did not work properly on UTF-8 encoded
3352 strings.  All non-ASCII characters under C</aa> should be treated as
3353 non-word characters, but what was happening was that Unicode rules were
3354 used to determine wordness/non-wordness for non-ASCII characters.  This
3355 is now fixed [perl #95968].
3356
3357 =item *
3358
3359 C<< (?foo: ...) >> no longer loses passed in character set.
3360
3361 =item *
3362
3363 The trie optimisation used to have problems with alternations containing
3364 an empty C<(?:)>, causing C<< "x" =~ /\A(?>(?:(?:)A|B|C?x))\z/ >> not to
3365 match, whereas it should [perl #111842].
3366
3367 =item *
3368
3369 Use of lexical (C<my>) variables in code blocks embedded in regular
3370 expressions will no longer result in memory corruption or crashes.
3371
3372 Nevertheless, these code blocks are still experimental, as there are still
3373 problems with the wrong variables being closed over (in loops for instance)
3374 and with abnormal exiting (e.g., C<die>) causing memory corruption.
3375
3376 =item *
3377
3378 The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
3379 cause a panic error message when attempting to match at the end of the
3380 string [perl #96354].
3381
3382 =item *
3383
3384 The abbreviations for four C1 control characters C<MW> C<PM>, C<RI>, and
3385 C<ST> were previously unrecognized by C<\N{}>, vianame(), and
3386 string_vianame().
3387
3388 =item *
3389
3390 Mentioning a variable named "&" other than C<$&> (i.e., C<@&> or C<%&>) no
3391 longer stops C<$&> from working.  The same applies to variables named "'"
3392 and "`" [perl #24237].
3393
3394 =item *
3395
3396 Creating a C<UNIVERSAL::AUTOLOAD> sub no longer stops C<%+>, C<%-> and
3397 C<%!> from working some of the time [perl #105024].
3398
3399 =back
3400
3401 =head2 Smartmatching
3402
3403 =over
3404
3405 =item *
3406
3407 C<~~> now correctly handles the precedence of Any~~Object, and is not tricked
3408 by an overloaded object on the left-hand side.
3409
3410 =item *
3411
3412 In Perl 5.14.0, C<$tainted ~~ @array> stopped working properly.  Sometimes
3413 it would erroneously fail (when C<$tainted> contained a string that occurs
3414 in the array I<after> the first element) or erroneously succeed (when
3415 C<undef> occurred after the first element) [perl #93590].
3416
3417 =back
3418
3419 =head2 The C<sort> operator
3420
3421 =over
3422
3423 =item *
3424
3425 C<sort> was not treating C<sub {}> and C<sub {()}> as equivalent when
3426 such a sub was provided as the comparison routine.  It used to croak on
3427 C<sub {()}>.
3428
3429 =item *
3430
3431 C<sort> now works once more with custom sort routines that are XSUBs.  It
3432 stopped working in 5.10.0.
3433
3434 =item *
3435
3436 C<sort> with a constant for a custom sort routine, although it produces
3437 unsorted results, no longer crashes.  It started crashing in 5.10.0.
3438
3439 =item *
3440
3441 Warnings emitted by C<sort> when a custom comparison routine returns a
3442 non-numeric value now contain "in sort" and show the line number of the
3443 C<sort> operator, rather than the last line of the comparison routine.  The
3444 warnings also occur now only if warnings are enabled in the scope where
3445 C<sort> occurs.  Previously the warnings would occur if enabled in the
3446 comparison routine's scope.
3447
3448 =item *
3449
3450 C<< sort { $a <=> $b } >>, which is optimised internally, now produces
3451 "uninitialized" warnings for NaNs (not-a-number values), since C<< <=> >>
3452 returns C<undef> for those.  This brings it in line with
3453 S<C<< sort { 1; $a <=> $b } >>> and other more complex cases, which are not
3454 optimised [perl #94390].
3455
3456 =back
3457
3458 =head2 The C<substr> operator
3459
3460 =over
3461
3462 =item *
3463
3464 Tied (and otherwise magical) variables are no longer exempt from the
3465 "Attempt to use reference as lvalue in substr" warning.
3466
3467 =item *
3468
3469 That warning now occurs when the returned lvalue is assigned to, not
3470 when C<substr> itself is called.  This only makes a difference if the
3471 return value of C<substr> is referenced and assigned to later.
3472
3473 =item *
3474
3475 Passing a substring of a read-only value or a typeglob to a function
3476 (potential lvalue context) no longer causes an immediate "Can't coerce"
3477 or "Modification of a read-only value" error.  That error only occurs
3478 if and when the value passed is assigned to.
3479
3480 The same thing happens with the "substr outside of string" error.  If
3481 the lvalue is only read, not written to, it is now just a warning, as
3482 with rvalue C<substr>.
3483
3484 =item *
3485
3486 C<substr> assignments no longer call FETCH twice if the first argument
3487 is a tied variable, just once.
3488
3489 =back
3490
3491 =head2 Support for embedded nulls
3492
3493 Some parts of Perl did not work correctly with nulls (C<chr 0>) embedded in
3494 strings.  That meant that, for instance, C<< $m = "a\0b"; foo->$m >> would
3495 call the "a" method, instead of the actual method name contained in $m.
3496 These parts of perl have been fixed to support nulls:
3497
3498 =over
3499
3500 =item *
3501
3502 Method names
3503
3504 =item *
3505
3506 Typeglob names (including filehandle and subroutine names)
3507
3508 =item *
3509
3510 Package names, including the return value of C<ref()>
3511
3512 =item *
3513
3514 Typeglob elements (C<*foo{"THING\0stuff"}>)
3515
3516 =item *
3517
3518 Signal names
3519
3520 =item *
3521
3522 Various warnings and error messages that mention variable names or values,
3523 methods, etc.
3524
3525 =back
3526
3527 One side effect of these changes is that blessing into "\0" no longer
3528 causes C<ref()> to return false.
3529
3530 =head2 Threading bugs
3531
3532 =over
3533
3534 =item *
3535
3536 Typeglobs returned from threads are no longer cloned if the parent thread
3537 already has a glob with the same name.  This means that returned
3538 subroutines will now assign to the right package variables [perl #107366].
3539
3540 =item *
3541
3542 Some cases of threads crashing due to memory allocation during cloning have
3543 been fixed [perl #90006].
3544
3545 =item *
3546
3547 Thread joining would sometimes emit "Attempt to free unreferenced scalar"
3548 warnings if C<caller> had been used from the C<DB> package prior to thread
3549 creation [perl #98092].
3550
3551 =item *
3552
3553 Locking a subroutine (via C<lock &sub>) is no longer a compile-time error
3554 for regular subs.  For lvalue subroutines, it no longer tries to return the
3555 sub as a scalar, resulting in strange side effects like C<ref \$_>
3556 returning "CODE" in some instances.
3557
3558 C<lock &sub> is now a run-time error if L<threads::shared> is loaded (a
3559 no-op otherwise), but that may be rectified in a future version.
3560
3561 =back
3562
3563 =head2 Tied variables
3564
3565 =over
3566
3567 =item *
3568
3569 Various cases in which FETCH was being ignored or called too many times
3570 have been fixed:
3571
3572 =over
3573
3574 =item *
3575
3576 C<PerlIO::get_layers> [perl #97956]
3577
3578 =item *
3579
3580 C<$tied =~ y/a/b/>, C<chop $tied> and C<chomp $tied> when $tied holds a
3581 reference.
3582
3583 =item *
3584
3585 When calling C<local $_> [perl #105912]
3586
3587 =item *
3588
3589 Four-argument C<select>
3590
3591 =item *
3592
3593 A tied buffer passed to C<sysread>
3594
3595 =item *
3596
3597 C<< $tied .= <> >>
3598
3599 =item *
3600
3601 Three-argument C<open>, the third being a tied file handle
3602 (as in C<< open $fh, ">&", $tied >>)
3603
3604 =item *
3605
3606 C<sort> with a reference to a tied glob for the comparison routine.
3607
3608 =item *
3609
3610 C<..> and C<...> in list context [perl #53554].
3611
3612 =item *
3613
3614 C<${$tied}>, C<@{$tied}>, C<%{$tied}> and C<*{$tied}> where the tied
3615 variable returns a string (C<&{}> was unaffected)
3616
3617 =item *
3618
3619 C<defined ${ $tied_variable }>
3620
3621 =item *
3622
3623 Various functions that take a filehandle argument in rvalue context
3624 (C<close>, C<readline>, etc.) [perl #97482]
3625
3626 =item *
3627
3628 Some cases of dereferencing a complex expression, such as
3629 C<${ (), $tied } = 1>, used to call C<FETCH> multiple times, but now call
3630 it once.
3631
3632 =item *
3633
3634 C<$tied-E<gt>method> where $tied returns a package name--even resulting in
3635 a failure to call the method, due to memory corruption
3636
3637 =item *
3638
3639 Assignments like C<*$tied = \&{"..."}> and C<*glob = $tied>
3640
3641 =item *
3642
3643 C<chdir>, C<chmod>, C<chown>, C<utime>, C<truncate>, C<stat>, C<lstat> and
3644 the filetest ops (C<-r>, C<-x>, etc.)
3645
3646 =back
3647
3648 =item *
3649
3650 C<caller> sets C<@DB::args> to the subroutine arguments when called from
3651 the DB package.  It used to crash when doing so if C<@DB::args> happened to
3652 be tied.  Now it croaks instead.
3653
3654 =item *
3655
3656 Tying an element of %ENV or C<%^H> and then deleting that element would
3657 result in a call to the tie object's DELETE method, even though tying the
3658 element itself is supposed to be equivalent to tying a scalar (the element
3659 is, of course, a scalar) [perl #67490].
3660
3661 =item *
3662
3663 When Perl autovivifies an element of a tied array or hash (which entails
3664 calling STORE with a new reference), it now calls FETCH immediately after
3665 the STORE, instead of assuming that FETCH would have returned the same
3666 reference.  This can make it easier to implement tied objects [perl #35865, #43011].
3667
3668 =item *
3669
3670 Four-argument C<select> no longer produces its "Non-string passed as
3671 bitmask" warning on tied or tainted variables that are strings.
3672
3673 =item *
3674
3675 Localising a tied scalar that returns a typeglob no longer stops it from
3676 being tied till the end of the scope.
3677
3678 =item *
3679
3680 Attempting to C<goto> out of a tied handle method used to cause memory
3681 corruption or crashes.  Now it produces an error message instead
3682 [perl #8611].
3683
3684 =item *
3685
3686 A bug has been fixed that occurs when a tied variable is used as a
3687 subroutine reference:  if the last thing assigned to or returned from the
3688 variable was a reference or typeglob, the C<\&$tied> could either crash or
3689 return the wrong subroutine.  The reference case is a regression introduced
3690 in Perl 5.10.0.  For typeglobs, it has probably never worked till now.
3691
3692 =back
3693
3694 =head2 Version objects and vstrings
3695
3696 =over
3697
3698 =item *
3699
3700 The bitwise complement operator (and possibly other operators, too) when
3701 passed a vstring would leave vstring magic attached to the return value,
3702 even though the string had changed.  This meant that
3703 C<< version->new(~v1.2.3) >> would create a version looking like "v1.2.3"
3704 even though the string passed to C<< version->new >> was actually
3705 "\376\375\374".  This also caused L<B::Deparse> to deparse C<~v1.2.3>
3706 incorrectly, without the C<~> [perl #29070].
3707
3708 =item *
3709
3710 Assigning a vstring to a magic (e.g., tied, C<$!>) variable and then
3711 assigning something else used to blow away all the magic.  This meant that
3712 tied variables would come undone, C<$!> would stop getting updated on
3713 failed system calls, C<$|> would stop setting autoflush, and other
3714 mischief would take place.  This has been fixed.
3715
3716 =item *
3717
3718 C<< version->new("version") >> and C<printf "%vd", "version"> no longer
3719 crash [perl #102586].
3720
3721 =item *
3722
3723 Version comparisons, such as those that happen implicitly with C<use
3724 v5.43>, no longer cause locale settings to change [perl #105784].
3725
3726 =item *
3727
3728 Version objects no longer cause memory leaks in boolean context
3729 [perl #109762].
3730
3731 =back
3732
3733 =head2 Warnings, redefinition
3734
3735 =over
3736
3737 =item *
3738
3739 Subroutines from the C<autouse> namespace are once more exempt from
3740 redefinition warnings.  This used to work in 5.005, but was broken in
3741 5.6 for most subroutines.  For subs created via XS that redefine
3742 subroutines from the C<autouse> package, this stopped working in 5.10.
3743
3744 =item *
3745
3746 New XSUBs now produce redefinition warnings if they overwrite existing
3747 subs, as they did in 5.8.x.  (The C<autouse> logic was reversed in
3748 5.10-14.  Only subroutines from the C<autouse> namespace would warn
3749 when clobbered.)
3750
3751 =item *
3752
3753 C<newCONSTSUB> used to use compile-time warning hints, instead of
3754 run-time hints.  The following code should never produce a redefinition
3755 warning, but it used to, if C<newCONSTSUB> redefined an existing
3756 subroutine:
3757
3758     use warnings;
3759     BEGIN {
3760         no warnings;
3761         some_XS_function_that_calls_new_CONSTSUB();
3762     }
3763
3764 =item *
3765
3766 Redefinition warnings for constant subroutines are on by default (what
3767 are known as severe warnings in L<perldiag>).  This was only the case
3768 when it was a glob assignment or declaration of a Perl subroutine that
3769 caused the warning.  If the creation of XSUBs triggered the warning, it
3770 was not a default warning.  This has been corrected.
3771
3772 =item *
3773
3774 The internal check to see whether a redefinition warning should occur
3775 used to emit "uninitialized" warnings in cases like this:
3776
3777     use warnings "uninitialized";
3778     use constant {u => undef, v => undef};
3779     sub foo(){u}
3780     sub foo(){v}
3781
3782 =back
3783
3784 =head2 Warnings, "Uninitialized"
3785
3786 =over
3787
3788 =item *
3789
3790 Various functions that take a filehandle argument in rvalue context
3791 (C<close>, C<readline>, etc.) used to warn twice for an undefined handle
3792 [perl #97482].
3793
3794 =item *
3795
3796 C<dbmopen> now only warns once, rather than three times, if the mode
3797 argument is C<undef> [perl #90064].
3798
3799 =item *
3800
3801 The C<+=> operator does not usually warn when the left-hand side is
3802 C<undef>, but it was doing so for tied variables.  This has been fixed
3803 [perl #44895].
3804
3805 =item *
3806
3807 A bug fix in Perl 5.14 introduced a new bug, causing "uninitialized"
3808 warnings to report the wrong variable if the operator in question had
3809 two operands and one was C<%{...}> or C<@{...}>.  This has been fixed
3810 [perl #103766].
3811
3812 =item *
3813
3814 C<..> and C<...> in list context now mention the name of the variable in
3815 "uninitialized" warnings for string (as opposed to numeric) ranges.
3816
3817 =back
3818
3819 =head2 Weak references
3820
3821 =over
3822
3823 =item *
3824
3825 Weakening the first argument to an automatically-invoked C<DESTROY> method
3826 could result in erroneous "DESTROY created new reference" errors or
3827 crashes.  Now it is an error to weaken a read-only reference.
3828
3829 =item *
3830
3831 Weak references to lexical hashes going out of scope were not going stale
3832 (becoming undefined), but continued to point to the hash.
3833
3834 =item *
3835
3836 Weak references to lexical variables going out of scope are now broken
3837 before any magical methods (e.g., DESTROY on a tie object) are called.
3838 This prevents such methods from modifying the variable that will be seen
3839 the next time the scope is entered.
3840
3841 =item *
3842
3843 Creating a weak reference to an @ISA array or accessing the array index
3844 (C<$#ISA>) could result in confused internal bookkeeping for elements
3845 subsequently added to the @ISA array.  For instance, creating a weak
3846 reference to the element itself could push that weak reference on to @ISA;
3847 and elements added after use of C<$#ISA> would be ignored by method lookup
3848 [perl #85670].
3849
3850 =back
3851
3852 =head2 Other notable fixes
3853
3854 =over
3855
3856 =item *
3857
3858 C<quotemeta> now quotes consistently the same non-ASCII characters under
3859 C<use feature 'unicode_strings'>, regardless of whether the string is
3860 encoded in UTF-8 or not, hence fixing the last vestiges (we hope) of the
3861 infamous L<perlunicode/The "Unicode Bug">.  [perl #77654].
3862
3863 Which of these code points is quoted has changed, based on Unicode's
3864 recommendations.  See L<perlfunc/quotemeta> for details.
3865
3866 =item *
3867
3868 When one writes C<open foo || die>, which used to work in Perl 4, a
3869 "Precedence problem" warning is produced.  This warning used erroneously to
3870 apply to fully-qualified bareword handle names not followed by C<||>.  This
3871 has been corrected.
3872
3873 =item *
3874
3875 After package aliasing (C<*foo:: = *bar::>), C<select> with 0 or 1 argument
3876 would sometimes return a name that could not be used to refer to the
3877 filehandle, or sometimes it would return C<undef> even when a filehandle
3878 was selected.  Now it returns a typeglob reference in such cases.
3879
3880 =item *
3881
3882 C<PerlIO::get_layers> no longer ignores some arguments that it thinks are
3883 numeric, while treating others as filehandle names.  It is now consistent
3884 for flat scalars (i.e., not references).
3885
3886 =item *
3887
3888 Unrecognised switches on C<#!> line
3889
3890 If a switch, such as B<-x>, that cannot occur on the C<#!> line is used
3891 there, perl dies with "Can't emulate...".
3892
3893 It used to produce the same message for switches that perl did not
3894 recognise at all, whether on the command line or the C<#!> line.
3895
3896 Now it produces the "Unrecognized switch" error message [perl #104288].
3897
3898 =item *
3899
3900 C<system> now temporarily blocks the SIGCHLD signal handler, to prevent the
3901 signal handler from stealing the exit status [perl #105700].
3902
3903 =item *
3904
3905 The %n formatting code for C<printf> and C<sprintf>, which causes the number
3906 of characters to be assigned to the next argument, now actually
3907 assigns the number of characters, instead of the number of bytes.
3908
3909 It also works now with special lvalue functions like C<substr> and with
3910 nonexistent hash and array elements [perl #3471, #103492].
3911
3912 =item *
3913
3914 Perl skips copying values returned from a subroutine, for the sake of
3915 speed, if doing so would make no observable difference.  Due to faulty
3916 logic, this would happen with the
3917 result of C<delete>, C<shift> or C<splice>, even if the result was
3918 referenced elsewhere.  It also did so with tied variables about to be freed
3919 [perl #91844, #95548].
3920
3921 =item *
3922
3923 C<utf8::decode> now refuses to modify read-only scalars [perl #91850].
3924
3925 =item *
3926
3927 Freeing $_ inside a C<grep> or C<map> block, a code block embedded in a
3928 regular expression, or an @INC filter (a subroutine returned by a
3929 subroutine in @INC) used to result in double frees or crashes
3930 [perl #91880, #92254, #92256].
3931
3932 =item *
3933
3934 C<eval> returns C<undef> in scalar context or an empty list in list
3935 context when there is a run-time error.  When C<eval> was passed a
3936 string in list context and a syntax error occurred, it used to return a
3937 list containing a single undefined element.  Now it returns an empty
3938 list in list context for all errors [perl #80630].
3939
3940 =item *
3941
3942 C<goto &func> no longer crashes, but produces an error message, when
3943 the unwinding of the current subroutine's scope fires a destructor that
3944 undefines the subroutine being "goneto" [perl #99850].
3945
3946 =item *
3947
3948 Perl now holds an extra reference count on the package that code is
3949 currently compiling in.  This means that the following code no longer
3950 crashes [perl #101486]:
3951
3952     package Foo;
3953     BEGIN {*Foo:: = *Bar::}
3954     sub foo;
3955
3956 =item *
3957
3958 The C<x> repetition operator no longer crashes on 64-bit builds with large
3959 repeat counts [perl #94560].
3960
3961 =item *
3962
3963 Calling C<require> on an implicit C<$_> when C<*CORE::GLOBAL::require> has
3964 been overridden does not segfault anymore, and C<$_> is now passed to the
3965 overriding subroutine [perl #78260].
3966
3967 =item *
3968
3969 C<use> and C<require> are no longer affected by the I/O layers active in
3970 the caller's scope (enabled by L<open.pm|open>) [perl #96008].
3971
3972 =item *
3973
3974 C<our $::é; $é> (which is invalid) no longer produces the "Compilation
3975 error at lib/utf8_heavy.pl..." error message, which it started emitting in
3976 5.10.0 [perl #99984].
3977
3978 =item *
3979
3980 On 64-bit systems, C<read()> now understands large string offsets beyond
3981 the 32-bit range.
3982
3983 =item *
3984
3985 Errors that occur when processing subroutine attributes no longer cause the
3986 subroutine's op tree to leak.
3987
3988 =item *
3989
3990 Passing the same constant subroutine to both C<index> and C<formline> no
3991 longer causes one or the other to fail [perl #89218]. (5.14.1)
3992
3993 =item *
3994
3995 List assignment to lexical variables declared with attributes in the same
3996 statement (C<my ($x,@y) : blimp = (72,94)>) stopped working in Perl 5.8.0.
3997 It has now been fixed.
3998
3999 =item *
4000
4001 Perl 5.10.0 introduced some faulty logic that made "U*" in the middle of
4002 a pack template equivalent to "U0" if the input string was empty.  This has
4003 been fixed [perl #90160].
4004
4005 =item *
4006
4007 Destructors on objects were not called during global destruction on objects
4008 that were not referenced by any scalars.  This could happen if an array
4009 element were blessed (e.g., C<bless \$a[0]>) or if a closure referenced a
4010 blessed variable (C<bless \my @a; sub foo { @a }>).
4011
4012 Now there is an extra pass during global destruction to fire destructors on
4013 any objects that might be left after the usual passes that check for
4014 objects referenced by scalars [perl #36347].
4015
4016 =item *
4017
4018 Fixed a case where it was possible that a freed buffer may have been read
4019 from when parsing a here document [perl #90128]. (5.14.1)
4020
4021 =item *
4022
4023 C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
4024 inside a C<while> condition [perl #90888].
4025
4026 =item *
4027
4028 A problem with context propagation when a C<do> block is an argument to
4029 C<return> has been fixed.  It used to cause C<undef> to be returned in
4030 some cases of a C<return> inside an C<if> block which itself is followed by
4031 another C<return>.
4032
4033 =item *
4034
4035 Calling C<index> with a tainted constant no longer causes constants in
4036 subsequently compiled code to become tainted [perl #64804].
4037
4038 =item *
4039
4040 Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
4041 working for the rest of the block.t
4042
4043 =item *
4044
4045 For list assignments like C<($a,$b) = ($b,$a)>, Perl has to make a copy of
4046 the items on the right-hand side before assignment them to the left.  For
4047 efficiency's sake, it assigns the values on the right straight to the items
4048 on the left if no one variable is mentioned on both sides, as in C<($a,$b) =
4049 ($c,$d)>.  The logic for determining when it can cheat was faulty, in that
4050 C<&&> and C<||> on the right-hand side could fool it.  So C<($a,$b) =
4051 $some_true_value && ($b,$a)> would end up assigning the value of C<$b> to
4052 both scalars.
4053
4054 =item *
4055
4056 Perl no longer tries to apply lvalue context to the string in
4057 C<("string", $variable) ||= 1> (which used to be an error).  Since the
4058 left-hand side of C<||=> is evaluated in scalar context, that's a scalar
4059 comma operator, which gives all but the last item void context.  There is
4060 no such thing as void lvalue context, so it was a mistake for Perl to try
4061 to force it [perl #96942].
4062
4063 =item *
4064
4065 C<caller> no longer leaks memory when called from the DB package if
4066 C<@DB::args> was assigned to after the first call to C<caller>.  L<Carp>
4067 was triggering this bug [perl #97010].
4068
4069 =item *
4070
4071 C<close> and similar filehandle functions, when called on built-in global
4072 variables (like C<$+>), used to die if the variable happened to hold the
4073 undefined value, instead of producing the usual "Use of uninitialized
4074 value" warning.
4075
4076 =item *
4077
4078 When autovivified file handles were introduced in Perl 5.6.0, C<readline>
4079 was inadvertently made to autovivify when called as C<readline($foo)> (but
4080 not as C<E<lt>$fooE<gt>>).  It has now been fixed never to autovivify.
4081
4082 =item *
4083
4084 Calling an undefined anonymous subroutine (e.g., what $x holds after
4085 C<undef &{$x = sub{}}>) used to cause a "Not a CODE reference" error, which
4086 has been corrected to "Undefined subroutine called" [perl #71154].
4087
4088 =item *
4089
4090 Causing C<@DB::args> to be freed between uses of C<caller> no longer
4091 results in a crash [perl #93320].
4092
4093 =item *
4094
4095 C<setpgrp($foo)> used to be equivalent to C<($foo, setpgrp)>, because
4096 C<setpgrp> was ignoring its argument if there was just one.  Now it is
4097 equivalent to C<setpgrp($foo,0)>.
4098
4099 =item *
4100
4101 C<shmread> was not setting the scalar flags correctly when reading from
4102 shared memory, causing the existing cached numeric representation in the
4103 scalar to persist [perl #98480].
4104
4105 =item *
4106
4107 C<++> and C<--> now work on copies of globs, instead of dying.
4108
4109 =item *
4110
4111 C<splice()> doesn't warn when truncating
4112
4113 You can now limit the size of an array using C<splice(@a,MAX_LEN)> without
4114 worrying about warnings.
4115
4116 =item *
4117
4118 C<< $$ >> is no longer tainted.  Since this value comes directly from
4119 C<< getpid() >>, it is always safe.
4120
4121 =item *
4122
4123 The parser no longer leaks a filehandle if STDIN was closed before parsing
4124 started [perl #37033].
4125
4126 =item *
4127
4128 C<< die; >> with a non-reference, non-string, or magical (e.g., tainted)
4129 value in $@ now properly propagates that value [perl #111654].
4130
4131 =back
4132
4133 =head1 Known Problems
4134
4135 =over 4
4136
4137 =item *
4138
4139 On Solaris, we have two kinds of failure.
4140
4141 If F<make> is Sun's F<make≥>, we get an error about a badly formed macro
4142 assignment in the F<Makefile>.  That happens when F<./Configure> tries to
4143 make depends.  F<Configure> then exits  0, but further F<make>-ing fails.
4144
4145 If F<make> is F<gmake>, F<Configure> completes, then we get errors related
4146 to F</usr/include/stdbool.h>
4147
4148 =item *
4149
4150 The following CPAN modules have test failures with perl 5.16.  Patches have
4151 been submitted for all of these, so hopefully there will be new releases
4152 soon:
4153
4154 =over
4155
4156 =item *
4157
4158 L<Date::Pcalc> version 6.1
4159
4160 =item *
4161
4162 L<Module::CPANTS::Analyse> version 0.85
4163
4164 This fails due to problems in L<Module::Find> 0.10 and L<File::MMagic>
4165 1.27.
4166
4167 =item *
4168
4169 L<PerlIO::Util> version 0.72
4170
4171 =back
4172
4173 =back
4174
4175 =head1 Acknowledgements
4176
4177 Perl 5.16.0 represents approximately 12 months of development since Perl
4178 5.14.0 and contains approximately 590,000 lines of changes across 2,500
4179 files from 137 authors.
4180
4181 Perl continues to flourish into its third decade thanks to a vibrant
4182 community of users and developers.  The following people are known to
4183 have contributed the improvements that became Perl 5.14.1:
4184
4185 Aaron Crane, Abhijit Menon-Sen, Abigail, Alan Haggai Alavi, Alberto
4186 Simões, Alexandr Ciornii, Andreas König, Andy Dougherty, Aristotle
4187 Pagaltzis, Bo Johansson, Bo Lindbergh, brian d foy, Brian Fraser, Brian
4188 Greenfield, Carl Hayter, Chas. Owens, Chia-liang Kao, Chip Salzenberg,
4189 Chris 'BinGOs' Williams, Christian Hansen, Christopher J. Madsen,
4190 chromatic, Claes Jacobsson, Claudio Ramirez, Craig A. Berry, Damian
4191 Conway, Daniel Kahn Gillmor, Darin McBride, Dave Rolsky, David Cantrell,
4192 David Golden, David Leadbeater, David Mitchell, Dee Newcum, Dennis
4193 Kaarsemaker, Dominic Hargreaves, Douglas Christopher Wilson, Eric Brine,
4194 Father Chrysostomos, Florian Ragwitz, Frederic Briere, George Greer,
4195 Gerard Goossen, Gisle Aas, H.Merijn Brand, Hojung Youn, Ian Goodacre,
4196 James E Keenan, Jan Dubois, Jerry D. Hedden, Jesse Luehrs, Jesse
4197 Vincent, Jilles Tjoelker, Jim Cromie, Jim Meyering, Joel Berger, Johan
4198 Vromans, Johannes Plunien, John Hawkinson, John P. Linderman, John
4199 Peacock, Joshua ben Jore, Juerd Waalboer, Karl Williamson, Karthik
4200 Rajagopalan, Keith Thompson, Kevin J.  Woolley, Kevin Ryde, Laurent
4201 Dami, Leo Lapworth, Leon Brocard, Leon Timmermans, Louis Strous, Lukas
4202 Mai, Marc Green, Marcel Grünauer, Mark A. Stratman, Mark Dootson, Mark
4203 Jason Dominus, Martin Hasch, Matthew Horsfall, Max Maischein, Michael G
4204 Schwern, Michael Witten, Mike Sheldrake, Moritz Lenz, Nicholas Clark,
4205 Niko Tyni, Nuno Carvalho, Pau Amma, Paul Evans, Paul Green, Paul
4206 Johnson, Perlover, Peter John Acklam, Peter Martini, Peter Scott, Phil
4207 Monsen, Pino Toscano, Rafael Garcia-Suarez, Rainer Tammer, Reini Urban,
4208 Ricardo Signes, Robin Barker, Rodolfo Carvalho, Salvador Fandiño, Sam
4209 Kimbrel, Samuel Thibault, Shawn M Moore, Shigeya Suzuki, Shlomi Fish,
4210 Sisyphus, Slaven Rezic, Spiros Denaxas, Steffen Müller, Steffen
4211 Schwigon, Stephen Bennett, Stephen Oberholtzer, Stevan Little, Steve
4212 Hay, Steve Peters, Thomas Sibley, Thorsten Glaser, Timothe Litt, Todd
4213 Rinaldo, Tom Christiansen, Tom Hukins, Tony Cook, Vadim Konovalov,
4214 Vincent Pit, Vladimir Timofeev, Walt Mankowski, Yves Orton, Zefram,
4215 Zsbán Ambrus, Ævar Arnfjörð Bjarmason.
4216
4217 The list above is almost certainly incomplete as it is automatically
4218 generated from version control history.  In particular, it does not
4219 include the names of the (very much appreciated) contributors who
4220 reported issues to the Perl bug tracker.
4221
4222 Many of the changes included in this version originated in the CPAN
4223 modules included in Perl's core.  We're grateful to the entire CPAN
4224 community for helping Perl to flourish.
4225
4226 For a more complete list of all of Perl's historical contributors,
4227 please see the F<AUTHORS> file in the Perl source distribution.
4228
4229 =head1 Reporting Bugs
4230
4231 If you find what you think is a bug, you might check the articles
4232 recently posted to the comp.lang.perl.misc newsgroup and the perl
4233 bug database at L<http://rt.perl.org/perlbug/>.  There may also be
4234 information at L<http://www.perl.org/>, the Perl Home Page.
4235
4236 If you believe you have an unreported bug, please run the L<perlbug>
4237 program included with your release.  Be sure to trim your bug down
4238 to a tiny but sufficient test case.  Your bug report, along with the
4239 output of C<perl -V>, will be sent off to perlbug@perl.org to be
4240 analysed by the Perl porting team.
4241
4242 If the bug you are reporting has security implications, which make it
4243 inappropriate to send to a publicly archived mailing list, then please
4244 send it to perl5-security-report@perl.org.  This points to a closed
4245 subscription unarchived mailing list, which includes all the core
4246 committers, who will be able to help assess the impact of issues, figure
4247 out a resolution, and help co-ordinate the release of patches to
4248 mitigate or fix the problem across all platforms on which Perl is
4249 supported.  Please only use this address for security issues in the Perl
4250 core, not for modules independently distributed on CPAN.
4251
4252 =head1 SEE ALSO
4253
4254 The F<Changes> file for an explanation of how to view exhaustive details
4255 on what changed.
4256
4257 The F<INSTALL> file for how to build Perl.
4258
4259 The F<README> file for general stuff.
4260
4261 The F<Artistic> and F<Copying> files for copyright information.
4262
4263 =cut