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