This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perldelta: the incompatible changes section
[perl5.git] / Porting / perl5180delta.pod
CommitLineData
e5ba1bf1
FC
1=encoding utf8
2
3=head1 NAME
4
0bba4573 5perl5180delta - what is new for perl v5.18.0
e5ba1bf1
FC
6
7=head1 DESCRIPTION
8
0bba4573 9This document describes differences between the 5.16.0 release and the 5.18.0
e5ba1bf1
FC
10release.
11
dac2f7cf
RS
12If you are upgrading from an earlier release such as 5.16.0, first read
13L<perl5160delta>, which describes differences between 5.14.0 and 5.16.0.
e5ba1bf1 14
5946c067 15=head1 Core Enhancements
e5ba1bf1 16
d29861e7
RS
17=head2 New mechanism for experimental features
18
19Newly-added experimental features will now require this incantation:
20
21 no warnings "experimental::feature_name";
22 use feature "feature_name"; # would warn without the prev line
23
24There is a new warnings category, called "experimental", containing
25warnings that the L<feature> pragma emits when enabling experimental
26features.
27
28Newly-added experimental features will also be given special warning IDs,
29which consist of "experimental::" followed by the name of the feature. (The
30plan is to extend this mechanism eventually to all warnings, to allow them
31to be enabled or disabled individually, and not just by category.)
32
33By saying
34
35 no warnings "experimental::feature_name";
36
37you are taking responsibility for any breakage that future changes to, or
38removal of, the feature may cause.
39
40Existing experimental features may begin emitting these warnings, too. Please
41consult L<perlexperiment> for information on which features are considered
42experimental.
43
5946c067 44=head2 Hash overhaul
e5ba1bf1 45
5946c067
RS
46Changes to the implementation of hashes in perl 5.18.0 will be one of the most
47visible changes to the behavior of existing code. For the most part, these
48changes will be visible as two distinct hash variables now providing their
49contents in a different variable where it was previously identical. When
50encountering these changes, the key to cleaning up from them is to accept that
51B<hashes are unordered collections> and to act accordingly.
52
53=head3 Hash randomization
54
55The seed used by Perl's hash function is now random. This means that the
56order which keys/values will be returned from functions like C<keys()>,
57C<values()>, and C<each()> will differ from run to run.
58
59This change was introduced to make Perl's hashes more robust to algorithmic
60complexity attacks, and also because we discovered that it exposes hash
61ordering dependency bugs and makes them easier to track down.
62
63Toolchain maintainers might want to invest in additional infrastructure to
64test for things like this. Running tests several times in a row and then
65comparing results will make it easier to spot hash order dependencies in
66code. Authors are strongly encouraged not to expose the key order of
67Perl's hashes to insecure audiences.
68
69Further, every hash has its own iteration order, which should make it much
70more difficult to determine what the current hash seed is.
71
72=head3 New hash function: Murmurhash-32
73
74We have switched Perl's hash function to use Murmurhash-32, and added build
75support for several other hash functions. This new function is expected to
76perform equivalently to the old one for shorter strings and is faster for
77hashing longer strings.
78
79=head3 PERL_HASH_SEED enviornment variable now takes a hex value
80
81PERL_HASH_SEED no longer accepts an integer as a parameter, instead the
82value is expected to be a binary string encoded in hex. This is to make
83the infrastructure support hash seeds of arbitrary lengths which might
84exceed that of an integer. (SipHash uses a 16 byte seed).
85
86=head3 Hash::Util::hash_seed() now returns a string
87
88Hash::Util::hash_seed() now returns a string instead of an integer. This
89is to make the infrastructure support hash seeds of arbitrary lengths
90which might exceed that of an integer. (SipHash uses a 16 byte seed).
91
92=head3 Output of PERL_HASH_SEED_DEBUG has been changed
93
94The environment variable PERL_HASH_SEED_DEBUG now shows both the hash
95function perl was built with AND the seed, in hex in use for that process.
96Code parsing this output, should it exist, must change to accomodate the
97new format. Example of the new format:
98
99 $ PERL_HASH_SEED_DEBUG=1 ./perl -e1
100 HASH_FUNCTION = MURMUR3 HASH_SEED = 0x1476bb9f
e5ba1bf1 101
d29861e7 102=head2 Upgrade to Unicode 6.2
816361ee 103
d29861e7
RS
104Perl now supports the final version of Unicode 6.2. Earlier releases in
105the 5.17 series supported Unicode 6.2 beta versions. There were no
106substantive changes in the final Unicode 6.2 version from the most
107recent beta, included in Perl 5.17.4. A list of changes from Unicode
1086.1 is at L<http://www.unicode.org/versions/Unicode6.2.0>.
816361ee 109
7e7c78a1
RS
110=head2 Character name aliases may now include non-Latin1-range characters
111
112It is possible to define your own names for characters for use in
113C<\N{...}>, C<charnames::vianame()>, etc. These names can now be
114comprised of characters from the whole Unicode range. This allows for
115names to be in your native language, and not just English. Certain
116restrictions apply to the characters that may be used (you can't define
117a name that has punctuation in it, for example). See L<charnames/CUSTOM
118ALIASES>.
119
00785cb7
RS
120=head2 New DTrace probes
121
122The following new DTrace probes have been added:
123
124=over 4
125
126=item C<op-entry>
127
128=item C<loading-file>
129
130=item C<loaded-file>
131
132=back
133
134=head2 C<${^LAST_FH}>
135
136This new variable provides access to the filehandle that was last read.
137This is the handle used by C<$.> and by C<tell> and C<eof> without
138arguments.
139
d29861e7 140=head2 Regular Expression Set Operations
00785cb7 141
d29861e7
RS
142This is an B<experimental> feature to allow matching against the union,
143intersection, etc., of sets of code points, similar to
144L<Unicode::Regex::Set>. It can also be used to extend C</x> processing
145to [bracketed] character classes, and as a replacement of user-defined
146properties, allowing more complex expressions than they do. See
147L<perlre/(?[ ])>.
00785cb7
RS
148
149=head2 Lexical subroutines
150
d29861e7 151This new feature is still considered B<experimental>. To enable it:
00785cb7
RS
152
153 use 5.018;
7a3f436e 154 no warnings "experimental::lexical_subs";
00785cb7
RS
155 use feature "lexical_subs";
156
157You can now declare subroutines with C<state sub foo>, C<my sub foo>, and
158C<our sub foo>. (C<state sub> requires that the "state" feature be
159enabled, unless you write it as C<CORE::state sub foo>.)
160
161C<state sub> creates a subroutine visible within the lexical scope in which
162it is declared. The subroutine is shared between calls to the outer sub.
163
164C<my sub> declares a lexical subroutine that is created each time the
165enclosing block is entered. C<state sub> is generally slightly faster than
166C<my sub>.
167
168C<our sub> declares a lexical alias to the package subroutine of the same
169name.
170
d29861e7 171For more information, see L<perlsub/Lexical Subroutines>.
00785cb7 172
94b31d3f
RS
173=head2 Computed Labels
174
175The loop controls C<next>, C<last> and C<redo>, and the special C<dump>
176operator, now allow arbitrary expressions to be used to compute labels at run
177time. Previously, any argument that was not a constant was treated as the
178empty string.
179
0fef449b
RS
180=head2 More CORE:: subs
181
182Several more built-in functions have been added as subroutines to the
183CORE:: namespace, namely, those non-overridable keywords that can be
184implemented without custom parsers: C<defined>, C<delete>, C<exists>,
185C<glob>, C<pos>, C<protoytpe>, C<scalar>, C<split>, C<study>, and C<undef>.
186
187As some of these have prototypes, C<prototype('CORE::...')> has been
188changed to not make a distinction between overridable and non-overridable
189keywords. This is to make C<prototype('CORE::pos')> consistent with
190C<prototype(&CORE::pos)>.
e5ba1bf1 191
37133b20
RS
192=head2 C<kill> with negative signal names
193
194C<kill> has always allowed a negative signal number, which kills the
195process group instead of a single process. It has also allowed signal
196names. But it did not behave consistently, because negative signal names
197were treated as 0. Now negative signals names like C<-INT> are supported
198and treated the same way as -2 [perl #112990].
199
e5ba1bf1
FC
200=head1 Security
201
d268df4d
RS
202=head2 C<Storable> security warning in documentation
203
204The documentation for C<Storable> now includes a section which warns readers
205of the danger of accepting Storable documents from untrusted sources. The
206short version is that deserializing certain types of data can lead to loading
207modules and other code execution. This is documented behavior and wanted
208behavior, but this opens an attack vector for malicious entities.
209
210=head2 C<Locale::Maketext> allowed code injection via a malicious template
211
212If users could provide a translation string to Locale::Maketext, this could be
213used to invoke arbitrary Perl subroutines available in the current process.
214
215This has been fixed, but it is still possible to invoke any method provided by
216C<Locale::Maketext> itself or a subclass that you are using. One of these
217methods in turn will invoke the Perl core's C<sprintf> subroutine.
218
219In summary, allowing users to provide translation strings without auditing
220them is a bad idea.
221
222This vulnerability is documented in CVE-2012-6329.
223
2516b9f0
RS
224=head2 Avoid calling memset with a negative count
225
226Poorly written perl code that allows an attacker to specify the count to perl's
227C<x> string repeat operator can already cause a memory exhaustion
228denial-of-service attack. A flaw in versions of perl before 5.15.5 can escalate
229that into a heap buffer overrun; coupled with versions of glibc before 2.16, it
230possibly allows the execution of arbitrary code.
231
232The flaw addressed to this commit has been assigned identifier CVE-2012-5195
233and was researched by Tim Brown.
234
235=head1 Incompatible Changes
236
237=head2 See also: hash overhaul
238
239Some of the changes in the L<hash overhaul|/"Hash overhaul"> are not fully
240compatible with previous versions of perl. Please read that section.
241
7e7c78a1
RS
242=head2 An unknown character name in C<\N{...}> is now a syntax error
243
244Previously, it warned, and the Unicode REPLACEMENT CHARACTER was
245substituted. Unicode now recommends that this situation be a syntax
246error. Also, the previous behavior led to some confusing warnings and
247behaviors, and since the REPLACEMENT CHARACTER has no use other than as
248a stand-in for some unknown character, any code that has this problem is
249buggy.
250
251=head2 Formerly deprecated characters in C<\N{}> character name aliases are now errors.
252
253Since v5.12.0, it has been deprecated to use certain characters in
254user-defined C<\N{...}> character names. These now cause a syntax
255error. For example, it is now an error to begin a name with a digit,
256such as in
257
258 my $undraftable = "\N{4F}"; # Syntax error!
259
260or to have commas anywhere in the name. See L<charnames/CUSTOM ALIASES>
261
2516b9f0 262=head2 C<\N{BELL}> now refers to U+1F514 instead of U+0007
e5ba1bf1 263
2516b9f0
RS
264Unicode 6.0 reused the name "BELL" for a different code point than it
265traditionally had meant. Since Perl v5.14, use of this name still
266referred to U+0007, but would raise a deprecation warning. Now, "BELL"
267refers to U+1F514, and the name for U+0007 is "ALERT". All the
268functions in L<charnames> have been correspondingly updated.
e5ba1bf1 269
2516b9f0 270=head2 New Restrictions in Multi-Character Case-Insensitive Matching in Regular Expression Bracketed Character Classes
5946c067 271
2516b9f0
RS
272Unicode has now withdrawn their previous recommendation for regular
273expressions to automatically handle cases where a single character can
274match multiple characters case-insensitively; for example, the letter
275LATIN SMALL LETTER SHARP S and the sequence C<ss>. This is because
276it turns out to be impracticable to do this correctly in all
277circumstances. Because Perl has tried to do this as best it can, it
278will continue to do so. (We are considering an option to turn it off.)
279However, a new restriction is being added on such matches when they
280occur in [bracketed] character classes. People were specifying
281things such as C</[\0-\xff]/i>, and being surprised that it matches the
282two character sequence C<ss> (since LATIN SMALL LETTER SHARP S occurs in
283this range). This behavior is also inconsistent with the using a
284property instead of a range: C<\p{Block=Latin1}> also includes LATIN
285SMALL LETTER SHARP S, but C</[\p{Block=Latin1}]/i> does not match C<ss>.
286The new rule is that for there to be a multi-character case-insensitive
287match within a bracketed character class, the character must be
288explicitly listed, and not as an end point of a range. This more
289closely obeys the Principle of Least Astonishment. See
290L<perlrecharclass/Bracketed Character Classes>. Note that a bug [perl
291#89774], now fixed as part of this change, prevented the previous
292behavior from working fully.
5946c067 293
0d146223
RS
294=head2 Explicit rules for variable names and identifiers
295
296Due to an oversight, length-one variable names in 5.16 were completely
297unrestricted, and opened the door to several kinds of insanity. As of
2985.18, these now follow the rules of other identifiers, in addition
2516b9f0
RS
299to accepting characters that match the C<\p{POSIX_Punct}> property.
300
301There are no longer any differences in the parsing of identifiers
302specified as C<$...> or C<${...};> previously, they were dealt with in
303different parts of the core, and so had slightly different behavior. For
304instance, C<${foo:bar}> was a legal variable name. Since they are now
305both parsed by the same code, that is no longer the case.
306
307=head2 C<\s> in regular expressions now matches a Vertical Tab
308
309No one could recall why C<\s> didn't match C<\cK>, the vertical tab.
310Now it does. Given the extreme rarity of that character, very little
311breakage is expected.
312
313=head2 C</(?{})/> and C</(??{})/> have been heavily reworked
314
315The implementation of this feature has been almost completely rewritten.
316Although its main intent is to fix bugs, some behaviors, especially
317related to the scope of lexical variables, will have changed. This is
318described more fully in the L</Selected Bug Fixes> section.
319
320=head2 Stricter parsing of substitution replacement
0d146223 321
2516b9f0
RS
322It is no longer possible to abuse the way the parser parses C<s///e> like
323this:
324
325 %_=(_,"Just another ");
326 $_="Perl hacker,\n";
327 s//_}->{_/e;print
328
329=head2 C<given> now aliases the global C<$_>
330
331Instead of assigning to an implicit lexical C<$_>, C<given> now makes the
332global C<$_> an alias for its argument, just like C<foreach>. However, it
333still uses lexical C<$_> if there is lexical C<$_> in scope (again, just like
334C<foreach>) [perl #114020].
0d146223 335
2516b9f0 336=head2 Lexical $_ is now experimental
d268df4d
RS
337
338Since it was introduced in Perl 5.10, it has caused much confusion with no
339obvious solution:
340
341=over
342
343=item *
344
345Various modules (e.g., List::Util) expect callback routines to use the
2516b9f0
RS
346global C<$_>. C<use List::Util 'first'; my $_; first { $_ == 1 } @list>
347does not work as one would expect.
d268df4d
RS
348
349=item *
350
351A C<my $_> declaration earlier in the same file can cause confusing closure
352warnings.
353
354=item *
355
356The "_" subroutine prototype character allows called subroutines to access
2516b9f0 357your lexical C<$_>, so it is not really private after all.
d268df4d
RS
358
359=item *
360
361Nevertheless, subroutines with a "(@)" prototype and methods cannot access
2516b9f0 362the caller's lexical C<$_>, unless they are written in XS.
d268df4d
RS
363
364=item *
365
2516b9f0 366But even XS routines cannot access a lexical C<$_> declared, not in the
d268df4d 367calling subroutine, but in an outer scope, iff that subroutine happened not
2516b9f0 368to mention C<$_> or use any operators that default to C<$_>.
d268df4d
RS
369
370=back
371
2516b9f0
RS
372It is our hope that lexical C<$_> can be rehabilitated, but this may
373cause changes in its behavior. Please use it with caution until it
374becomes stable.
375
d268df4d
RS
376=head2 readline() with C<$/ = \N> now reads N characters, not N bytes
377
378Previously, when reading from a stream with I/O layers such as
379C<encoding>, the readline() function, otherwise known as the C<< <> >>
380operator, would read I<N> bytes from the top-most layer. [perl #79960]
381
382Now, I<N> characters are read instead.
383
384There is no change in behaviour when reading from streams with no
385extra layers, since bytes map exactly to characters.
386
d268df4d
RS
387=head2 Overridden C<glob> is now passed one argument
388
389C<glob> overrides used to be passed a magical undocumented second argument
390that identified the caller. Nothing on CPAN was using this, and it got in
391the way of a bug fix, so it was removed. If you really need to identify
392the caller, see L<Devel::Callsite> on CPAN.
393
00785cb7
RS
394=head2 Here-doc parsing
395
396The body of a here-document inside a quote-like operator now always begins
397on the line after the "<<foo" marker. Previously, it was documented to
398begin on the line following the containing quote-like operator, but that
399was only sometimes the case [perl #114040].
400
2516b9f0
RS
401=head2 Alphanumeric operators must now be separated from the closing
402delimiter of regular expressions
00785cb7 403
2516b9f0 404You may no longer write something like:
00785cb7 405
2516b9f0
RS
406 m/a/and 1
407
408Instead you must write
409
410 m/a/ and 1
411
412with whitespace separating the operator from the closing delimiter of
413the regular expression. Not having whitespace has resulted in a
414deprecation warning since Perl v5.14.0.
415
416=head2 qw(...) can no longer be used as parentheses
417
418C<qw> lists used to fool the parser into thinking they were always
419surrounded by parentheses. This permitted some surprising constructions
420such as C<foreach $x qw(a b c) {...}>, which should really be written
421C<foreach $x (qw(a b c)) {...}>. These would sometimes get the lexer into
422the wrong state, so they didn't fully work, and the similar C<foreach qw(a
423b c) {...}> that one might expect to be permitted never worked at all.
424
425This side effect of C<qw> has now been abolished. It has been deprecated
426since Perl 5.13.11. It is now necessary to use real parentheses
427everywhere that the grammar calls for them.
00785cb7
RS
428
429=head2 Interaction of lexical and default warnings
430
431Turning on any lexical warnings used first to disable all default warnings
432if lexical warnings were not already enabled:
433
434 $*; # deprecation warning
435 use warnings "void";
436 $#; # void warning; no deprecation warning
437
438Now, the debugging, deprecated, glob, inplace and malloc warnings
439categories are left on when turning on lexical warnings (unless they are
440turned off by C<no warnings>, of course).
441
442This may cause deprecation warnings to occur in code that used to be free
443of warnings.
444
445Those are the only categories consisting only of default warnings. Default
446warnings in other categories are still disabled by C<use warnings
447"category">, as we do not yet have the infrastructure for controlling
448individual warnings.
449
450=head2 C<state sub> and C<our sub>
451
452Due to an accident of history, C<state sub> and C<our sub> were equivalent
453to a plain C<sub>, so one could even create an anonymous sub with
454C<our sub { ... }>. These are now disallowed outside of the "lexical_subs"
455feature. Under the "lexical_subs" feature they have new meanings described
456in L<perlsub/Lexical Subroutines>.
457
94b31d3f
RS
458=head2 Defined values stored in environment are forced to byte strings
459
460A value stored in an environment variable has always been stringified. In this
461release, it is converted to be only a byte string. First, it is forced to be a
462only a string. Then if the string is utf8 and the equivalent of
463C<utf8::downgrade()> works, that result is used; otherwise, the equivalent of
464C<utf8::encode()> is used, and a warning is issued about wide characters
465(L</Diagnostics>).
466
0fef449b
RS
467=head2 C<require> dies for unreadable files
468
469When C<require> encounters an unreadable file, it now dies. It used to
2516b9f0 470ignore the file and continue searching the directories in C<@INC>
0fef449b
RS
471[perl #113422].
472
2516b9f0 473=head2 C<gv_fetchmeth_*> and SUPER
0fef449b 474
2516b9f0
RS
475The various C<gv_fetchmeth_*> XS functions used to treat a package whose
476named ended with ::SUPER specially. A method lookup on the Foo::SUPER
477package would be treated as a SUPER method lookup on the Foo package. This
478is no longer the case. To do a SUPER lookup, pass the Foo stash and the
479GV_SUPER flag.
0fef449b 480
e5ba1bf1
FC
481=head1 Deprecations
482
816361ee
RS
483=head2 Deprecated modules
484
e7ae12cf
RS
485The following modules will be removed from the core distribution in a
486future release, and should be installed from CPAN instead. Distributions
487on CPAN which require these should add them to their prerequisites. The
488core versions of these modules C<warnings> will issue a deprecation warning.
489
490You can silence these deprecation warnings by installing the modules
491in question from CPAN.
492
493=over
494
495=item L<encoding>
496
497This module is deprecated under perl 5.18. It uses a mechanism provided by
498perl that is deprecated under 5.18 and higher, and may be removed in a
499future version.
500
501=item L<Archive::Extract>
502
503=item L<B::Lint>
504
505=item L<B::Lint::Debug>
506
507=item L<CPANPLUS>
508
509=item L<CPANPLUS::Backend>
510
511=item L<CPANPLUS::Backend::RV>
512
513=item L<CPANPLUS::Config>
514
515=item L<CPANPLUS::Config::HomeEnv>
516
517=item L<CPANPLUS::Configure>
518
519=item C<CPANPLUS::Configure::Setup>
520
521=item L<CPANPLUS::Dist>
522
523=item L<CPANPLUS::Dist::Autobundle>
524
525=item L<CPANPLUS::Dist::Base>
526
527=item L<CPANPLUS::Dist::Build>
528
529=item L<CPANPLUS::Dist::Build::Constants>
530
531=item L<CPANPLUS::Dist::MM>
532
533=item L<CPANPLUS::Dist::Sample>
534
535=item L<CPANPLUS::Error>
536
537=item L<CPANPLUS::Internals>
538
539=item C<CPANPLUS::Internals::Constants>
540
541=item C<CPANPLUS::Internals::Constants::Report>
542
543=item L<CPANPLUS::Internals::Extract>
544
545=item L<CPANPLUS::Internals::Fetch>
546
547=item L<CPANPLUS::Internals::Report>
548
549=item L<CPANPLUS::Internals::Search>
550
551=item L<CPANPLUS::Internals::Source>
552
553=item L<CPANPLUS::Internals::Source::Memory>
554
555=item L<CPANPLUS::Internals::Source::SQLite>
556
557=item C<CPANPLUS::Internals::Source::SQLite::Tie>
558
559=item L<CPANPLUS::Internals::Utils>
560
561=item C<CPANPLUS::Internals::Utils::Autoflush>
562
563=item L<CPANPLUS::Module>
564
565=item L<CPANPLUS::Module::Author>
566
567=item L<CPANPLUS::Module::Author::Fake>
568
569=item L<CPANPLUS::Module::Checksums>
570
571=item L<CPANPLUS::Module::Fake>
572
573=item C<CPANPLUS::Module::Signature>
574
575=item L<CPANPLUS::Selfupdate>
576
577=item L<CPANPLUS::Shell>
578
579=item L<CPANPLUS::Shell::Classic>
580
581=item L<CPANPLUS::Shell::Default>
582
583=item L<CPANPLUS::Shell::Default::Plugins::CustomSource>
584
585=item L<CPANPLUS::Shell::Default::Plugins::Remote>
586
587=item L<CPANPLUS::Shell::Default::Plugins::Source>
588
589=item L<Devel::InnerPackage>
590
591=item L<Log::Message>
592
593=item L<Log::Message::Config>
594
595=item L<Log::Message::Handlers>
596
597=item L<Log::Message::Item>
598
599=item L<Log::Message::Simple>
600
601=item L<Module::Pluggable>
602
603=item L<Module::Pluggable::Object>
604
605=item L<Object::Accessor>
606
607=item L<Pod::LaTeX>
608
609=item L<Term::UI>
610
611=item L<Term::UI::History>
612
613=back
614
615=head2 Deprecated Utilities
616
617The following utilities will be removed from the core distribution in a
618future release as their associated modules have been deprecated. They
619will remain available with the applicable CPAN distribution.
620
621=over
622
623=item L<cpanp>
624
625Included with L<CPANPLUS>.
626
627=item C<cpanp-run-perl>
628
629Included with L<CPANPLUS>.
630
631=item L<cpan2dist>
632
633Included with L<CPANPLUS>.
634
635=item L<pod2latex>
636
637The L<Pod::LaTeX> module was deprecated with 5.17.8.
638
639=back
640
0d146223
RS
641=head2 PL_sv_objcount
642
643This interpreter-global variable used to track the total number of
644Perl objects in the interpreter. It is no longer maintained and will
645be removed altogether in Perl 5.20.
646
e7ae12cf
RS
647=head2 Five additional characters should be escaped in patterns with C</x>
648
649When a regular expression pattern is compiled with C</x>, Perl treats 6
650characters as white space to ignore, such as SPACE and TAB. However,
651Unicode recommends 11 characters be treated thusly. In preparation to
652conforming with this in a future Perl version, in the meantime, use of
653any of the missing characters will raise a deprecation warning, unless
654turned off. The five characters are:
655U+0085 NEXT LINE,
656U+200E LEFT-TO-RIGHT MARK,
657U+200F RIGHT-TO-LEFT MARK,
658U+2028 LINE SEPARATOR,
659and
660U+2029 PARAGRAPH SEPARATOR.
816361ee
RS
661
662=head2 User-defined charnames with surprising whitespace
663
664A user-defined character name with trailing or multiple spaces in a row is
665likely a typo. This now generates a warning when defined, on the assumption
666that uses of it will be unlikely to include the excess whitespace.
667
668=head2 Various XS-callable functions are now deprecated
669
670All the functions used to classify characters will be removed from a
671future version of Perl, and should not be used. With participating C
672compilers (e.g., gcc), compiling any file that uses any of these will
673generate a warning. These were not intended for public use; there are
674equivalent, faster, macros for most of them.
675See L<perlapi/Character classes>. The complete list (including some
676that were deprecated in 5.17.7) is:
677C<is_uni_alnum>, C<is_uni_alnumc>, C<is_uni_alnumc_lc>,
678C<is_uni_alnum_lc>, C<is_uni_alpha>, C<is_uni_alpha_lc>,
679C<is_uni_ascii>, C<is_uni_ascii_lc>, C<is_uni_blank>,
680C<is_uni_blank_lc>, C<is_uni_cntrl>, C<is_uni_cntrl_lc>,
681C<is_uni_digit>, C<is_uni_digit_lc>, C<is_uni_graph>,
682C<is_uni_graph_lc>, C<is_uni_idfirst>, C<is_uni_idfirst_lc>,
683C<is_uni_lower>, C<is_uni_lower_lc>, C<is_uni_print>,
684C<is_uni_print_lc>, C<is_uni_punct>, C<is_uni_punct_lc>,
685C<is_uni_space>, C<is_uni_space_lc>, C<is_uni_upper>,
686C<is_uni_upper_lc>, C<is_uni_xdigit>, C<is_uni_xdigit_lc>,
687C<is_utf8_alnum>, C<is_utf8_alnumc>, C<is_utf8_alpha>,
688C<is_utf8_ascii>, C<is_utf8_blank>, C<is_utf8_char>,
689C<is_utf8_cntrl>, C<is_utf8_digit>, C<is_utf8_graph>,
690C<is_utf8_idcont>, C<is_utf8_idfirst>, C<is_utf8_lower>,
691C<is_utf8_mark>, C<is_utf8_perl_space>, C<is_utf8_perl_word>,
692C<is_utf8_posix_digit>, C<is_utf8_print>, C<is_utf8_punct>,
693C<is_utf8_space>, C<is_utf8_upper>, C<is_utf8_xdigit>,
694C<is_utf8_xidcont>, C<is_utf8_xidfirst>.
695
696In addition these three functions that have never worked properly are
697deprecated:
698C<to_uni_lower_lc>, C<to_uni_title_lc>, and C<to_uni_upper_lc>.
699
700=head2 Certain rare uses of backslashes within regexes are now deprectated
701
702There are three pairs of characters that Perl recognizes as
703metacharacters in regular expression patterns: C<{}>, C<[]>, and C<()>.
704These can be used as well to delimit patterns, as in:
705
706 m{foo}
707 s(foo)(bar)
708
709Since they are metacharacters, they have special meaning to regular
710expression patterns, and it turns out that you can't turn off that
711special meaning by the normal means of preceding them with a backslash,
712if you use them, paired, within a pattern delimitted by them. For
713example, in
714
715 m{foo\{1,3\}}
716
717the backslashes do not change the behavior, and this matches
718S<C<"f o">> followed by one to three more occurrences of C<"o">.
719
720Usages like this, where they are interpreted as metacharacters, are
721exceedingly rare; we think there are none, for example, in all of CPAN.
722Hence, this deprecation should affect very little code. It does give
723notice, however, that any such code needs to change, which will in turn
724allow us to change the behavior in future Perl versions so that the
725backslashes do have an effect, and without fear that we are silently
726breaking any existing code.
727
d268df4d
RS
728=head2 Various XS-callable functions are now deprecated
729
730The following functions will be removed from a future version of Perl,
731and should not be used. With participating C compilers (e.g., gcc),
732compiling any file that uses any of these will generate a warning.
733These were not intended for public use; there are equivalent, faster,
734macros for most of them. See L<perlapi/Character classes>:
735C<is_uni_ascii>, C<is_uni_ascii_lc>, C<is_uni_blank>, C<is_uni_blank_lc>,
736C<is_uni_cntrl>, C<is_uni_cntrl_lc>, C<is_uni_idfirst_lc>, C<is_uni_space>,
737C<is_uni_space_lc>, C<is_uni_xdigit>, C<is_uni_xdigit_lc>, C<is_utf8_ascii>,
738C<is_utf8_blank>, C<is_utf8_cntrl>, C<is_utf8_idcont>, C<is_utf8_idfirst>,
739C<is_utf8_perl_space>, C<is_utf8_perl_word>, C<is_utf8_posix_digit>,
740C<is_utf8_space>, C<is_utf8_xdigit>. C<is_utf8_xidcont>, C<is_utf8_xidfirst>,
741C<to_uni_lower_lc>, C<to_uni_title_lc>, and C<to_uni_upper_lc>.
742
e5ba1bf1
FC
743=head1 Performance Enhancements
744
7e7c78a1
RS
745=over 4
746
747=item *
e5ba1bf1 748
7e7c78a1
RS
749Lists of lexical variable declarations (C<my($x, $y)>) are now optimised
750down to a single op, and are hence faster than before.
e5ba1bf1 751
7e7c78a1
RS
752=item *
753
754A new C preprocessor define NO_TAINT_SUPPORT was added that, if set, disables
755Perl's taint support altogether. Using the -T or -t command line flags will
756cause a fatal error. Beware that both core tests as well as many a CPAN
757distribution's tests will fail with this change. On the upside, it provides
758a small performance benefit due to reduced branching.
759
760B<Do not enable this unless you know exactly what you are getting yourself
761into.>
e5ba1bf1
FC
762
763=item *
764
d29861e7
RS
765C<pack> with constant arguments is now constant folded in most cases
766[perl #113470].
767
768=item *
769
00785cb7
RS
770Speed up in regular expression matching against Unicode properties. The
771largest gain is for C<\X>, the Unicode "extended grapheme cluster". The
772gain for it is about 35% - 40%. Bracketed character classes, e.g.,
773C<[0-9\x{100}]> containing code points above 255 are also now faster.
774
775=item *
776
777On platforms supporting it, several former macros are now implemented as static
778inline functions. This should speed things up slightly on non-GCC platforms.
779
780=item *
781
782Apply the optimisation of hashes in boolean context, such as in C<if> or C<and>,
783to constructs in non-void context.
784
785=item *
786
787Extend the optimisation of hashes in boolean context to C<scalar(%hash)>,
788C<%hash ? ... : ...>, and C<sub { %hash || ... }>.
789
790=item *
791
792When making a copy of the string being matched against (so that $1, $& et al
793continue to show the correct value even if the original string is subsequently
794modified), only copy that substring of the original string needed for the
795capture variables, rather than copying the whole string.
796
797This is a big win for code like
798
799 $&;
800 $_ = 'x' x 1_000_000;
801 1 while /(.)/;
802
803Also, when pessimizing if the code contains C<$`>, C<$&> or C<$'>, record the
804presence of each variable separately, so that the determination of the substring
805range is based on each variable separately. So performance-wise,
806
807 $&; /x/
808
809is now roughly equivalent to
810
811 /(x)/
812
813whereas previously it was like
814
815 /^(.*)(x)(.*)$/
816
817and
818
819 $&; $'; /x/
820
821is now roughly equivalent to
822
823 /(x)(.*)$/
824
825etc.
826
00785cb7
RS
827=item *
828
0bba4573
RS
829Filetest ops manage the stack in a fractionally more efficient manner.
830
831=item *
832
833Globs used in a numeric context are now numerified directly in most cases,
834rather than being numerified via stringification.
e5ba1bf1 835
0fef449b
RS
836=item *
837
838The C<x> repetition operator is now folded to a single constant at compile
839time if called in scalar context with constant operands and no parentheses
840around the left operand.
841
e5ba1bf1
FC
842=back
843
844=head1 Modules and Pragmata
845
846XXX All changes to installed files in F<cpan/>, F<dist/>, F<ext/> and F<lib/>
847go here. If Module::CoreList is updated, generate an initial draft of the
848following sections using F<Porting/corelist-perldelta.pl>, which prints stub
849entries to STDOUT. Results can be pasted in place of the '=head2' entries
850below. A paragraph summary for important changes should then be added by hand.
851In an ideal world, dual-life modules would have a F<Changes> file that could be
852cribbed.
853
854[ Within each section, list entries as a =item entry ]
855
856=head2 New Modules and Pragmata
857
858=over 4
859
860=item *
861
e7ae12cf
RS
862L<Config::Perl::V> version 0.16 has been added as a dual-lifed module.
863It provides structured data retrieval of C<perl -V> output including
864information only known to the C<perl> binary and not available via L<Config>.
e5ba1bf1
FC
865
866=back
867
868=head2 Updated Modules and Pragmata
869
870=over 4
871
872=item *
873
874L<XXX> has been upgraded from version A.xx to B.yy.
875
876=back
877
878=head2 Removed Modules and Pragmata
879
0bba4573 880=over
e5ba1bf1
FC
881
882=item *
883
0bba4573
RS
884L<Version::Requirements> has been removed from the core distribution. It is
885available under a different name: L<CPAN::Meta::Requirements>.
e5ba1bf1
FC
886
887=back
888
889=head1 Documentation
890
891XXX Changes to files in F<pod/> go here. Consider grouping entries by
892file and be sure to link to the appropriate page, e.g. L<perlfunc>.
893
894=head2 New Documentation
895
896XXX Changes which create B<new> files in F<pod/> go here.
897
898=head3 L<XXX>
899
900XXX Description of the purpose of the new file here
901
902=head2 Changes to Existing Documentation
903
0bba4573 904=head3 L<perldata>
e5ba1bf1 905
0bba4573
RS
906=over 4
907
908=item *
909
910Now explicitly documents the behaviour of hash initializer lists that
911contain duplicate keys.
912
913=back
914
915=head3 L<perldiag>
916
917=over 4
918
919=item *
920
921The explanation of symbolic references being prevented by "strict refs"
922now doesn't assume that the reader knows what symbolic references are.
923
924=back
925
926=head3 L<perlfunc>
e5ba1bf1
FC
927
928=over 4
929
930=item *
931
0bba4573 932The return value of C<pipe> is now documented.
e5ba1bf1 933
37133b20
RS
934=item *
935
936Clarified documentation of C<our>.
937
e5ba1bf1
FC
938=back
939
0fef449b
RS
940=head3 L<perlfaq>
941
942=over 4
943
944=item *
945
946L<perlfaq> has been synchronized with version 5.0150040 from CPAN.
947
948=back
949
950=head3 L<perlcheat>
951
952=over 4
953
954=item *
955
956L<perlcheat> has been reorganized, and a few new sections were added.
957
958=back
959
94b31d3f
RS
960=head3 L<perlop>
961
962=over 4
963
964=item *
965
966Loop control verbs (C<dump>, C<goto>, C<next>, C<last> and C<redo>) have always
967had the same precedence as assignment operators, but this was not documented
968until now.
969
970=back
971
0bba4573 972=head3 Diagnostics
e5ba1bf1
FC
973
974The following additions or changes have been made to diagnostic output,
975including warnings and fatal error messages. For the complete list of
976diagnostic messages, see L<perldiag>.
977
978XXX New or changed warnings emitted by the core's C<C> code go here. Also
979include any changes in L<perldiag> that reconcile it to the C<C> code.
980
981=head2 New Diagnostics
982
983XXX Newly added diagnostic messages go under here, separated into New Errors
984and New Warnings
985
986=head3 New Errors
987
988=over 4
989
990=item *
991
94b31d3f
RS
992L<Unterminated delimiter for here document|perldiag/"Unterminated delimiter for here document">
993
994This message now occurs when a here document label has an initial quotation
995mark but the final quotation mark is missing.
996
997This replaces a bogus and misleading error message about not finding the label
998itself [perl #114104].
999
1000=item *
1001
1002L<panic: child pseudo-process was never scheduled|perldiag/"panic: child pseudo-process was never scheduled">
1003
1004This error is thrown when a child pseudo-process in the ithreads implementation
1005on Windows was not scheduled within the time period allowed and therefore was
1006not able to initialize properly [perl #88840].
1007
1008=item *
1009
37133b20
RS
1010L<Group name must start with a non-digit word character in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Group name must start with a non-digit word character in regex; marked by <-- HERE in m/%s/">
1011
1012This error has been added for C<(?&0)>, which is invalid. It used to
1013produce an incomprehensible error message [perl #101666].
1014
1015=item *
1016
1017L<Can't use an undefined value as a subroutine reference|perldiag/"Can't use an undefined value as %s reference">
1018
1019Calling an undefined value as a subroutine now produces this error message.
1020It used to, but was accidentally disabled, first in Perl 5.004 for
1021non-magical variables, and then in Perl 5.14 for magical (e.g., tied)
1022variables. It has now been restored. In the mean time, undef was treated
1023as an empty string [perl #113576].
e5ba1bf1
FC
1024
1025=back
1026
1027=head3 New Warnings
1028
1029=over 4
1030
1031=item *
1032
0d146223
RS
1033L<%c* is deprecated, and will become a syntax error|perldiag/"%c* is deprecated, and will become a syntax error">
1034
1035Use of C<@*>, C<&*>, C<**> or C<%*> is now deprecated, and will generate a
1036compile time warning, enabled by default. In future such code will fail to
1037compile with a syntax error. Removing these variables, along with C<$*>,
1038will permit future syntax additions.
1039
1040=item *
1041
e7ae12cf
RS
1042XXX: This needs more detail.
1043
1044Strings with code points over 0xFF may not be mapped into in-memory file
1045handles
1046
1047=item *
1048
816361ee
RS
1049L<'%s' resolved to '\o{%s}%d'|perldiag/"'%s' resolved to '\o{%s}%d'">
1050
1051=item *
1052
1053L<'Trailing white-space in a charnames alias definition is deprecated'|perldiag/"Trailing white-space in a charnames alias definition is deprecated">
1054
1055=item *
1056
1057L<'A sequence of multiple spaces in a charnames alias definition is deprecated'|perldiag/"A sequence of multiple spaces in a charnames alias definition is deprecated">
1058
1059=item *
1060
1061L<'Passing malformed UTF-8 to "%s" is deprecated'|perldiag/"Passing malformed UTF-8 to "%s" is deprecated">
1062
816361ee
RS
1063=item *
1064
00785cb7
RS
1065L<Experimental "%s" subs not enabled|perldiag/"Experimental "%s" subs not enabled">
1066
1067(F) To use lexical subs, you must first enable them:
1068
7a3f436e 1069 no warnings 'experimental::lexical_subs';
00785cb7
RS
1070 use feature 'lexical_subs';
1071 my sub foo { ... }
1072
1073=item *
1074
1075L<Subroutine "&%s" is not available|perldiag/"Subroutine "&%s" is not available">
1076
1077(W closure) During compilation, an inner named subroutine or eval is
1078attempting to capture an outer lexical subroutine that is not currently
1079available. This can happen for one of two reasons. First, the lexical
1080subroutine may be declared in an outer anonymous subroutine that has not
1081yet been created. (Remember that named subs are created at compile time,
1082while anonymous subs are created at run-time.) For example,
1083
1084 sub { my sub a {...} sub f { \&a } }
1085
1086At the time that f is created, it can't capture the current the "a" sub,
1087since the anonymous subroutine hasn't been created yet. Conversely, the
1088following won't give a warning since the anonymous subroutine has by now
1089been created and is live:
1090
1091 sub { my sub a {...} eval 'sub f { \&a }' }->();
1092
1093The second situation is caused by an eval accessing a variable that has
1094gone out of scope, for example,
1095
1096 sub f {
1097 my sub a {...}
1098 sub { eval '\&a' }
1099 }
1100 f()->();
1101
1102Here, when the '\&a' in the eval is being compiled, f() is not currently
1103being executed, so its &a is not available for capture.
1104
1105=item *
1106
1107L<"%s" subroutine &%s masks earlier declaration in same %s|perldiag/"%s" subroutine &%s masks earlier declaration in same %s>
1108
1109(W misc) A "my" or "state" subroutine has been redeclared in the
1110current scope or statement, effectively eliminating all access to
1111the previous instance. This is almost always a typographical error.
1112Note that the earlier subroutine will still exist until the end of
1113the scope or until all closure references to it are destroyed.
1114
1115=item *
1116
1117L<The %s feature is experimental|perldiag/"The %s feature is experimental">
1118
1119(S experimental) This warning is emitted if you enable an experimental
1120feature via C<use feature>. Simply suppress the warning if you want
1121to use the feature, but know that in doing so you are taking the risk
1122of using an experimental feature which may change or be removed in a
1123future Perl version:
1124
7a3f436e 1125 no warnings "experimental::lexical_subs";
00785cb7
RS
1126 use feature "lexical_subs";
1127
1128=item *
1129
1130L<sleep(%u) too large|perldiag/"sleep(%u) too large">
1131
1132(W overflow) You called C<sleep> with a number that was larger than it can
1133reliably handle and C<sleep> probably slept for less time than requested.
1134
1135=item *
1136
94b31d3f
RS
1137L<Wide character in setenv|perldiag/"Wide character in %s">
1138
1139Attempts to put wide characters into environment variables via C<%ENV> now
1140provoke this warning.
1141
1142=item *
1143
37133b20
RS
1144"L<Invalid negative number (%s) in chr|perldiag/"Invalid negative number (%s) in chr">"
1145
1146C<chr()> now warns when passed a negative value [perl #83048].
1147
1148=item *
1149
1150"L<Integer overflow in srand|perldiag/"Integer overflow in srand">"
1151
1152C<srand()> now warns when passed a value that doesn't fit in a C<UV> (since the
1153value will be truncated rather than overflowing) [perl #40605].
1154
1155=item *
1156
1157"L<-i used with no filenames on the command line, reading from STDIN|perldiag/"-i used with no filenames on the command line, reading from STDIN">"
1158
1159Running perl with the C<-i> flag now warns if no input files are provided on
1160the command line [perl #113410].
e5ba1bf1
FC
1161
1162=back
1163
1164=head2 Changes to Existing Diagnostics
1165
e5ba1bf1
FC
1166=over 4
1167
1168=item *
1169
0d146223
RS
1170L<$* is no longer supported, and will become a syntax error|perldiag/"$* is no longer supported, and will become a syntax error">
1171
1172The warning that use of C<$*> and C<$#> is no longer supported is now
1173generated for every location that references them. Previously it would fail
1174to be generated if another variable using the same typeglob was seen first
1175(e.g. C<@*> before C<$*>), and would not be generated for the second and
1176subsequent uses. (It's hard to fix the failure to generate warnings at all
1177without also generating them every time, and warning every time is
1178consistent with the warnings that C<$[> used to generate.)
1179
1180=item *
1181
e7ae12cf
RS
1182The warnings for \b{ and \B{ were added in the 5.17 series; they are a
1183deprecation warning which should be turned off by that category. One
1184should not have to turn off regular regexp warnings as well to get rid
1185of these.
1186
1187=item *
1188
d268df4d
RS
1189L<Constant(%s): Call to &{$^H{%s}} did not return a defined value|perldiag/Constant(%s): Call to &{$^H{%s}} did not return a defined value>
1190
1191Constant overloading that returns C<undef> results in this error message.
1192For numeric constants, it used to say "Constant(undef)". "undef" has been
1193replaced with the number itself.
1194
1195=item *
1196
f7b06e7f
RS
1197The error produced when a module cannot be loaded now includes a hint that
1198the module may need to be installed: "Can't locate hopping.pm in @INC (you
1199may need to install the hopping module) (@INC contains: ...)"
1200
1201=item *
1202
00785cb7
RS
1203L<vector argument not supported with alpha versions|perldiag/vector argument not supported with alpha versions>
1204
1205This warning was not suppressable, even with C<no warnings>. Now it is
1206suppressible, and has been moved from the "internal" category to the
1207"printf" category.
1208
1209=item *
1210
1211C<< Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ >>
1212
1213This fatal error has been turned into a warning that reads:
1214
1215L<< Quantifier {n,m} with n > m can't match in regex | perldiag/Quantifier {n,m} with n > m can't match in regex >>
1216
1217(W regexp) Minima should be less than or equal to maxima. If you really want
1218your regexp to match something 0 times, just put {0}.
1219
1220=item *
1221
0fef449b
RS
1222The "Runaway prototype" warning that occurs in bizarre cases has been
1223removed as being unhelpful and inconsistent.
1224
1225=item *
1226
1227The "Not a format reference" error has been removed, as the only case in
1228which it could be triggered was a bug.
1229
1230=item *
1231
1232The "Unable to create sub named %s" error has been removed for the same
1233reason.
e5ba1bf1 1234
37133b20
RS
1235=item *
1236
1237The 'Can't use "my %s" in sort comparison' error has been downgraded to a
1238warning, '"my %s" used in sort comparison' (with 'state' instead of 'my'
1239for state variables). In addition, the heuristics for guessing whether
1240lexical $a or $b has been misused have been improved to generate fewer
1241false positives. Lexical $a and $b are no longer disallowed if they are
1242outside the sort block. Also, a named unary or list operator inside the
1243sort block no longer causes the $a or $b to be ignored [perl #86136].
1244
e5ba1bf1
FC
1245=back
1246
1247=head1 Utility Changes
1248
f7b06e7f 1249=head3 L<h2xs>
e5ba1bf1
FC
1250
1251=over 4
1252
1253=item *
1254
f7b06e7f 1255F<h2xs> no longer produces invalid code for empty defines. [perl #20636]
e5ba1bf1
FC
1256
1257=back
1258
1259=head1 Configuration and Compilation
1260
1261XXX Changes to F<Configure>, F<installperl>, F<installman>, and analogous tools
1262go here. Any other changes to the Perl build process should be listed here.
1263However, any platform-specific changes should be listed in the
1264L</Platform Support> section, instead.
1265
1266[ List changes as a =item entry ].
1267
1268=over 4
1269
1270=item *
1271
e7ae12cf
RS
1272Added C<useversionedarchname> option to Configure
1273
1274When set, it includes 'api_versionstring' in 'archname'. E.g.
1275x86_64-linux-5.13.6-thread-multi. It is unset by default.
1276
1277This feature was requested by Tim Bunce, who observed that
1278INSTALL_BASE creates a library structure that does not
1279differentiate by perl version. Instead, it places architecture
1280specific files in "$install_base/lib/perl5/$archname". This makes
1281it difficult to use a common INSTALL_BASE library path with
1282multiple versions of perl.
1283
1284By setting -Duseversionedarchname, the $archname will be
1285distinct for architecture *and* API version, allowing mixed use of
1286INSTALL_BASE.
1287
1288=item *
1289
1290Configure will honour the external C<MAILDOMAIN> environment variable, if set.
1291
1292=item *
1293
1294C<installman> no longer ignores the silent option
1295
1296=item *
1297
1298Both C<META.yml> and C<META.json> files are now included in the distribution.
1299
1300=item *
1301
00785cb7
RS
1302F<Configure> will now correctly detect C<isblank()> when compiling with a C++
1303compiler.
1304
1305=item *
1306
94b31d3f
RS
1307The pager detection in F<Configure> has been improved to allow responses which
1308specify options after the program name, e.g. B</usr/bin/less -R>, if the user
1309accepts the default value. This helps B<perldoc> when handling ANSI escapes
1310[perl #72156].
e5ba1bf1
FC
1311
1312=back
1313
1314=head1 Testing
1315
1316XXX Any significant changes to the testing of a freshly built perl should be
1317listed here. Changes which create B<new> files in F<t/> go here as do any
1318large changes to the testing harness (e.g. when parallel testing was added).
1319Changes to existing files in F<t/> aren't worth summarizing, although the bugs
1320that they represent may be covered elsewhere.
1321
1322[ List each test improvement as a =item entry ]
1323
1324=over 4
1325
1326=item *
1327
0bba4573
RS
1328The test suite now has a section for tests that require very large amounts
1329of memory. These tests won't run by default; they can be enabled by
1330setting the C<PERL_TEST_MEMORY> environment variable to the number of
1331gibibytes of memory that may be safely used.
e5ba1bf1
FC
1332
1333=back
1334
1335=head1 Platform Support
1336
1337XXX Any changes to platform support should be listed in the sections below.
1338
1339[ Within the sections, list each platform as a =item entry with specific
1340changes as paragraphs below it. ]
1341
1342=head2 New Platforms
1343
1344XXX List any platforms that this version of perl compiles on, that previous
1345versions did not. These will either be enabled by new files in the F<hints/>
1346directories, or new subdirectories and F<README> files at the top level of the
1347source tree.
1348
1349=over 4
1350
1351=item XXX-some-platform
1352
1353XXX
1354
1355=back
1356
1357=head2 Discontinued Platforms
1358
e5ba1bf1
FC
1359=over 4
1360
94b31d3f 1361=item UTS Global
e5ba1bf1 1362
94b31d3f
RS
1363Support code relating to UTS global has been removed. UTS was a mainframe
1364version of System V created by Amdahl, subsequently sold to UTS Global. The
1365port has not been touched since before Perl 5.8.0, and UTS Global is now
1366defunct.
e5ba1bf1 1367
00785cb7
RS
1368=item VM/ESA
1369
1370Support for VM/ESA has been removed. The port was tested on 2.3.0, which
1371IBM ended service on in March 2002. 2.4.0 ended service in June 2003, and
1372was superseded by Z/VM. The current version of Z/VM is V6.2.0, and scheduled
1373for end of service on 2015/04/30.
1374
f7b06e7f
RS
1375=item MPE/IX
1376
1377Support for MPE/IX has been removed.
1378
7e7c78a1
RS
1379=item EPOC
1380
1381Support code relating to EPOC has been removed. EPOC was a family of
1382operating systems developed by Psion for mobile devices. It was the
1383predecessor of Symbian. The port was last updated in April 2002.
1384
816361ee
RS
1385=item Rhapsody
1386
1387Support for Rhapsody has been removed.
1388
e5ba1bf1
FC
1389=back
1390
1391=head2 Platform-Specific Notes
1392
1393XXX List any changes for specific platforms. This could include configuration
1394and compilation changes or changes in portability/compatibility. However,
1395changes within modules for platforms should generally be listed in the
1396L</Modules and Pragmata> section.
1397
1398=over 4
1399
0bba4573 1400=item clang++
e5ba1bf1 1401
0bba4573
RS
1402There is now a workaround for a compiler bug that prevented compiling
1403with clang++ since Perl 5.15.7 [perl #112786].
1404
1405=item C++
1406
1407When compiling the Perl core as C++ (which is only semi-supported), the
1408mathom functions are now compiled as C<extern "C">, to ensure proper
1409binary compatibility. (However, binary compatibility isn't generally
1410guaranteed anyway in the situations where this would matter.)
1411
7e7c78a1
RS
1412=item VMS
1413
1414Where possible, the case of filenames and command-line arguments is now
1415preserved by enabling the CRTL features C<DECC$EFS_CASE_PRESERVE> and
1416C<DECC$ARGV_PARSE_STYLE> at start-up time. The latter only takes effect
1417when extended parse is enabled in the process from which Perl is run.
1418
e7ae12cf
RS
1419=item VMS
1420
1421The character set for Extended Filename Syntax (EFS) is now enabled by default
1422on VMS. Among other things, this provides better handling of dots in directory
1423names, multiple dots in filenames,and spaces in filenames. To obtain the old
1424behavior, set the logical name C<DECC$EFS_CHARSET> to C<DISABLE>.
1425
1426=item MidnightBSD
1427
1428C<libc_r> was removed from recent versions of MidnightBSD and older versions
1429work better with C<pthread>. Threading is now enabled using C<pthread> which
1430corrects build errors with threading enabled on 0.4-CURRENT.
1431
7e7c78a1
RS
1432=item WinCE
1433
1434Building on WinCE is now possible once again, although more work is required
1435to fully restore a clean build.
1436
816361ee
RS
1437=item Windows
1438
1439Perl can now be built using Microsoft's Visual C++ 2012 compiler by specifying
1440CCTYPE=MSVC110 (or MSVC110FREE if you are using the free Express edition for
1441Windows Desktop) in F<win32/Makefile>.
1442
1443=item Haiku
1444
1445Perl should now work out of the box on Haiku R1 Alpha 4.
1446
00785cb7
RS
1447=item Win32
1448
1449Fixed a problem where perl could crash while cleaning up threads (including the
1450main thread) in threaded debugging builds on Win32 and possibly other platforms
1451[perl #114496].
1452
1453A rare race condition that would lead to L<sleep|perlfunc/sleep> taking more
1454time than requested, and possibly even hanging, has been fixed [perl #33096].
1455
f7b06e7f
RS
1456=item Win32
1457
1458The option to build without USE_SOCKETS_AS_HANDLES has been removed.
1459
00785cb7
RS
1460=item Solaris
1461
1462In Configure, avoid running sed commands with flags not supported on Solaris.
1463
1464=item Darwin
1465
1466Stop hardcoding an alignment on 8 byte boundaries to fix builds using
1467-Dusemorebits.
1468
1469=item VMS
1470
1471Fix linking on builds configured with -Dusemymalloc=y.
1472
0bba4573
RS
1473=item VMS
1474
1475It should now be possible to compile Perl as C++ on VMS.
e5ba1bf1 1476
0fef449b
RS
1477=item Win32
1478
1479C<link> on Win32 now attempts to set C<$!> to more appropriate values
1480based on the Win32 API error code. [perl #112272]
1481
1482Perl no longer mangles the environment block, e.g. when launching a new
1483sub-process, when the environment contains non-ASCII characters. Known
1484problems still remain, however, when the environment contains characters
1485outside of the current ANSI codepage (e.g. see the item about Unicode in
1486C<%ENV> in L<http://perl5.git.perl.org/perl.git/blob/HEAD:/Porting/todo.pod>).
1487[perl #113536]
1488
37133b20
RS
1489=item Win32
1490
1491Building perl with some Windows compilers used to fail due to a problem
1492with miniperl's C<glob> operator (which uses the C<perlglob> program)
1493deleting the PATH environment variable [perl #113798].
1494
94b31d3f
RS
1495=item Win32
1496
1497A new makefile option, USE_64_BIT_INT, has been added to the Windows makefiles.
1498Set this to "define" when building a 32-bit perl if you want it to use 64-bit
1499integers.
1500
1501Machine code size reductions, already made to the DLLs of XS modules in Perl
15025.17.2, have now been extended to the perl DLL itself.
1503
1504Building with VC++ 6.0 was inadvertently broken in Perl 5.17.2 but has now been
1505fixed again.
1506
0fef449b
RS
1507=item VMS
1508
1509All C header files from the top-level directory of the distribution are now
1510installed on VMS, providing consistency with a long-standing practice on other
1511platforms. Previously only a subset were installed, which broke non-core
1512extension builds for extensions that depended on the missing include files.
1513
37133b20
RS
1514=item VMS
1515
1516Quotes are now removed from the command verb (but not the parameters) for
1517commands spawned via C<system>, backticks, or a piped C<open>. Previously,
1518quotes on the verb were passed through to DCL, which would fail to recognize
1519the command. Also, if the verb is actually a path to an image or command
1520procedure on an ODS-5 volume, quoting it now allows the path to contain spaces.
1521
94b31d3f
RS
1522=item VMS
1523
1524The B<a2p> build has been fixed for the HP C++ compiler on OpenVMS.
1525
37133b20
RS
1526=item AIX
1527
1528Configure now always adds C<-qlanglvl=extc99> to the CC flags on AIX when
1529using xlC. This will make it easier to compile a number of XS-based modules
1530that assume C99 [perl #113778].
1531
e5ba1bf1
FC
1532=back
1533
1534=head1 Internal Changes
1535
0bba4573 1536=over
e5ba1bf1 1537
0bba4573 1538=item *
e5ba1bf1 1539
e7ae12cf
RS
1540Synonyms for the misleadingly named C<av_len()> has been created:
1541C<av_top_index()> and C<av_tindex>. All three of these return the
1542number of the highest index in the array, not the number of elements it
1543contains.
816361ee
RS
1544
1545=item *
1546
d268df4d
RS
1547SvUPGRADE() is no longer an expression. Originally this macro (and its
1548underlying function, sv_upgrade()) were documented as boolean, although
1549in reality they always croaked on error and never returned false. In 2005
1550the documentation was updated to specify a void return value, but
1551SvUPGRADE() was left always returning 1 for backwards compatibility. This
1552has now been removed, and SvUPGRADE() is now a statement with no return
1553value.
1554
1555So this is now a syntax error:
1556
1557 if (!SvUPGRADE(sv)) { croak(...); }
1558
1559If you have code like that, simply replace it with
1560
1561 SvUPGRADE(sv);
1562
1563or to to avoid compiler warnings with older perls, possibly
1564
1565 (void)SvUPGRADE(sv);
1566
1567=item *
1568
1569Perl has a new copy-on-write mechanism that allows any SvPOK scalar to be
1570upgraded to a copy-on-write scalar. A reference count on the string buffer
1571is stored in the string buffer itself.
1572
1573This breaks a few XS modules by allowing copy-on-write scalars to go
1574through code paths that never encountered them before.
1575
1576This behaviour can still be disabled by running F<Configure> with
1577B<-Accflags=-DPERL_NO_COW>. This option will probably be removed in Perl
15785.20.
1579
1580=item *
1581
1582Copy-on-write no longer uses the SvFAKE and SvREADONLY flags. Hence,
1583SvREADONLY indicates a true read-only SV.
1584
1585Use the SvIsCOW macro (as before) to identify a copy-on-write scalar.
1586
1587=item *
1588
1589C<PL_sawampersand> is now a constant. The switch this variable provided
1590(to enable/disable the pre-match copy depending on whether C<$&> had been
1591seen) has been removed and replaced with copy-on-write, eliminating a few
1592bugs.
1593
1594The previous behaviour can still be enabled by running F<Configure> with
1595B<-Accflags=-DPERL_SAWAMPERSAND>.
1596
1597=item *
1598
1599PL_glob_index is gone.
1600
1601=item *
1602
7e7c78a1
RS
1603The private Perl_croak_no_modify has had its context parameter removed. It is
1604now has a void prototype. Users of the public API croak_no_modify remain
1605unaffected.
1606
1607=item *
1608
1609Copy-on-write (shared hash key) scalars are no longer marked read-only.
1610C<SvREADONLY> returns false on such an SV, but C<SvIsCOW> still returns
1611true.
1612
1613=item *
1614
1615A new op type, C<OP_PADRANGE> has been introduced. The perl peephole
1616optimiser will, where possible, substitute a single padrange op for a
1617pushmark followed by one or more pad ops, and possibly also skipping list
1618and nextstate ops. In addition, the op can carry out the tasks associated
1619with the RHS of a my(...) = @_ assignment, so those ops may be optimised
1620away too.
1621
1622=item *
1623
f7b06e7f
RS
1624Case-insensitive matching inside a [bracketed] character class with a
1625multi-character fold, no longer excludes one of the possibilities in the
1626circumstances that it used to. [perl #89774].
1627
1628=item *
1629
1630C<PL_formfeed> has been removed.
1631
1632=item *
1633
1634The regular expression engine no longer reads one byte past the end of the
1635target string. While for all internally well-formed scalars this should
1636never have been a problem, this change facilitates clever tricks with
1637string buffers in CPAN modules. [perl #73542]
1638
1639=item *
1640
1641Inside a BEGIN block, C<PL_compcv> now points to the currently-compiling
1642subroutine, rather than the BEGIN block itself.
1643
1644=item *
1645
1646C<mg_length> has been deprecated.
1647
1648=item *
1649
1650C<sv_len> now always returns a byte count and C<sv_len_utf8> a character
1651count. Previously, C<sv_len> and C<sv_len_utf8> were both buggy and would
1652sometimes returns bytes and sometimes characters. C<sv_len_utf8> no longer
1653assumes that its argument is in UTF8. Neither of these creates UTF8 caches
1654for tied or overloaded values or for non-PVs any more.
1655
1656=item *
1657
1658C<sv_mortalcopy> now copies string buffers of shared hash key scalars when
1659called from XS modules [perl #79824].
1660
1661=item *
1662
1663C<RXf_SPLIT> and C<RXf_SKIPWHITE> are no longer used. They are now
1664#defined as 0.
1665
1666=item *
1667
1668The new C<RXf_MODIFIES_VARS> flag can be set by custom regular expression
1669engines to indicate that the execution of the regular expression may cause
1670variables to be modified. This lets C<s///> know to skip certain
1671optimisations. Perl's own regular expression engine sets this flag for the
1672special backtracking verbs that set $REGMARK and $REGERROR.
1673
1674=item *
1675
00785cb7
RS
1676The APIs for accessing lexical pads have changed considerably.
1677
1678C<PADLIST>s are now longer C<AV>s, but their own type instead. C<PADLIST>s now
1679contain a C<PAD> and a C<PADNAMELIST> of C<PADNAME>s, rather than C<AV>s for the
1680pad and the list of pad names. C<PAD>s, C<PADNAMELIST>s, and C<PADNAME>s are to
1681be accessed as such through the newly added pad API instead of the plain C<AV>
1682and C<SV> APIs. See L<perlapi> for details.
1683
1684=item *
1685
1686In the regex API, the numbered capture callbacks are passed an index
1687indicating what match variable is being accessed. There are special
1688index values for the C<$`, $&, $&> variables. Previously the same three
1689values were used to retrieve C<${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}>
1690too, but these have now been assigned three separate values. See
1691L<perlreapi/Numbered capture callbacks>.
1692
1693=item *
1694
1695C<PL_sawampersand> was previously a boolean indicating that any of
1696C<$`, $&, $&> had been seen; it now contains three one-bit flags
1697indicating the presence of each of the variables individually.
1698
00785cb7
RS
1699=item *
1700
0bba4573
RS
1701The C<CV *> typemap entry now supports C<&{}> overloading and typeglobs,
1702just like C<&{...}> [perl #96872].
e5ba1bf1
FC
1703
1704=item *
1705
0bba4573
RS
1706The C<SVf_AMAGIC> flag to indicate overloading is now on the stash, not the
1707object. It is now set automatically whenever a method or @ISA changes, so
1708its meaning has changed, too. It now means "potentially overloaded". When
1709the overload table is calculated, the flag is automatically turned off if
1710there is no overloading, so there should be no noticeable slowdown.
1711
1712The staleness of the overload tables is now checked when overload methods
1713are invoked, rather than during C<bless>.
1714
1715"A" magic is gone. The changes to the handling of the C<SVf_AMAGIC> flag
1716eliminate the need for it.
1717
1718C<PL_amagic_generation> has been removed as no longer necessary. For XS
1719modules, it is now a macro alias to C<PL_na>.
1720
1721The fallback overload setting is now stored in a stash entry separate from
1722overloadedness itself.
1723
1724=item *
1725
1726The character-processing code has been cleaned up in places. The changes
1727should be operationally invisible.
e5ba1bf1 1728
0fef449b
RS
1729=item *
1730
1731The C<study> function was made a no-op in 5.16. It was simply disabled via
1732a C<return> statement; the code was left in place. Now the code supporting
1733what C<study> used to do has been removed.
1734
1735=item *
1736
1737Under threaded perls, there is no longer a separate PV allocated for every
1738COP to store its package name (C<< cop->stashpv >>). Instead, there is an
1739offset (C<< cop->stashoff >>) into the new C<PL_stashpad> array, which
1740holds stash pointers.
1741
1742=item *
1743
1744In the pluggable regex API, the C<regexp_engine> struct has acquired a new
1745field C<op_comp>, which is currently just for perl's internal use, and
1746should be initialised to NULL by other regex plugin modules.
1747
1748=item *
1749
1750A new function C<alloccoptash> has been added to the API, but is considered
1751experimental. See L<perlapi>.
1752
37133b20
RS
1753=item *
1754
1755Perl used to implement get magic in a way that would sometimes hide bugs in
1756code could call mg_get() too many times on magical values. This hiding of
1757errors no longer occurs, so long-standing bugs may become visible now. If
1758you see magic-related errors in XS code, check to make sure it, together
1759with the Perl API functions it uses, calls mg_get() only once on SvGMAGICAL()
1760values.
1761
1762=item *
1763
1764OP allocation for CVs now uses a slab allocator. This simplifies
1765memory management for OPs allocated to a CV, so cleaning up after a
1766compilation error is simpler and safer [perl #111462][perl #112312].
1767
1768=item *
1769
1770PERL_DEBUG_READONLY_OPS has been rewritten to work with the new slab
1771allocator, allowing it to catch more violations than before.
1772
1773=item *
1774
1775The old slab allocator for ops, which was only enabled for PERL_IMPLICIT_SYS
1776and PERL_DEBUG_READONLY_OPS, has been retired.
1777
e5ba1bf1
FC
1778=back
1779
1780=head1 Selected Bug Fixes
1781
94b31d3f
RS
1782=over 4
1783
1784=item *
e5ba1bf1 1785
d29861e7
RS
1786Here-doc terminators no longer require a terminating newline character when
1787they occur at the end of a file. This was already the case at the end of a
1788string eval [perl #65838].
1789
1790=item *
1791
e7ae12cf
RS
1792-DPERL_GLOBAL_STRUCT builds now free the global struct B<after>
1793they've finished using it.
1794
1795=item *
1796
1797A trailing '/' on a path in @INC will no longer have an additional '/' appended.
1798
1799=item *
1800
1801The C<:crlf> layer now works when unread data doesn't fit into its own
1802buffer. [perl #112244].
1803
1804=item *
1805
1806C<ungetc()> now handles UTF-8 encoded data. [perl #116322].
1807
1808=item *
1809
816361ee
RS
1810A bug in the core typemap caused any C types that map to the T_BOOL core
1811typemap entry to not be set, updated, or modified when the T_BOOL variable was
1812used in an OUTPUT: section with an exception for RETVAL. T_BOOL in an INPUT:
1813section was not affected. Using a T_BOOL return type for an XSUB (RETVAL)
1814was not affected. A side effect of fixing this bug is, if a T_BOOL is specified
1815in the OUTPUT: section (which previous did nothing to the SV), and a read only
1816SV (literal) is passed to the XSUB, croaks like "Modification of a read-only
1817value attempted" will happen. [perl #115796]
1818
1819=item *
1820
1821On many platforms, providing a directory name as the script name caused perl
1822to do nothing and report success. It should now universally report an error
1823and exit nonzero. [perl #61362]
1824
1825=item *
1826
d268df4d
RS
1827C<sort {undef} ...> under fatal warnings no longer crashes. It started
1828crashing in Perl 5.16.
1829
1830=item *
1831
1832Stashes blessed into each other
1833(C<bless \%Foo::, 'Bar'; bless \%Bar::, 'Foo'>) no longer result in double
1834frees. This bug started happening in Perl 5.16.
1835
1836=item *
1837
1838Numerous memory leaks have been fixed, mostly involving fatal warnings and
1839syntax errors.
1840
1841=item *
1842
1843Lexical constants (C<my sub answer () { 42 }>) no longer cause double
1844frees.
1845
1846=item *
1847
1848Constant subroutine redefinition warns by default, but lexical constants
1849were accidentally exempt from default warnings. This has been corrected.
1850
1851=item *
1852
1853Some failed regular expression matches such as C<'f' =~ /../g> were not
1854resetting C<pos>. Also, "match-once" patterns (C<m?...?g>) failed to reset
1855it, too, when invoked a second time [perl #23180].
1856
1857=item *
1858
1859Accessing C<$&> after a pattern match now works if it had not been seen
1860before the match. I.e., this applies to C<${'&'}> (under C<no strict>) and
1861C<eval '$&'>. The same applies to C<$'> and C<$`> [perl #4289].
1862
1863=item *
1864
1865Several bugs involving C<local *ISA> and C<local *Foo::> causing stale
1866MRO caches have been fixed.
1867
1868=item *
1869
1870Defining a subroutine when its typeglob has been aliased no longer results
1871in stale method caches. This bug was introduced in Perl 5.10.
1872
1873=item *
1874
1875Localising a typeglob containing a subroutine when the typeglob's package
1876has been deleted from its parent stash no longer produces an error. This
1877bug was introduced in Perl 5.14.
1878
1879=item *
1880
1881Under some circumstances, C<local *method=...> would fail to reset method
1882caches upon scope exit.
1883
1884=item *
1885
1886C</[.foo.]/> is no longer an error, but produces a warning (as before) and
1887is treated as C</[.fo]/> [perl #115818].
1888
1889=item *
1890
1891C<goto $tied_var> now calls FETCH before deciding what type of goto
1892(subroutine or label) this is.
1893
1894=item *
1895
1896Renaming packages through glob assignment
1897(C<*Foo:: = *Bar::; *Bar:: = *Baz::>) in combination with C<m?...?> and
1898C<reset> no longer makes threaded builds crash.
1899
1900=item *
1901
1902An earlier release in the 5.17.x series could crash if user code prevented
1903_charnames from loading via C<$INC{'_charnames.pm'}++>.
1904
1905=item *
1906
1907A number of bugs related to assigning a list to hash have been fixed. Many of
1908these involve lists with repeated keys like C<(1, 1, 1, 1)>.
1909
1910=over 4
1911
1912=item *
1913
1914The expression C<scalar(%h = (1, 1, 1, 1))> now returns C<4>, not C<2>.
1915
1916=item *
1917
1918The return value of C<%h = (1, 1, 1)> in list context was wrong. Previously
1919this would return C<(1, undef, 1)>, now it returns C<(1, undef)>.
1920
1921=item *
1922
1923Perl now issues the same warning on C<($s, %h) = (1, {})> as it does for
1924C<(%h) = ({})>, "Reference found where even-sized list expected".
1925
1926=item *
1927
1928A number of additional edge cases in list assignment to hashes were
1929corrected. For more details see commit 23b7025ebc.
1930
1931=back
1932
1933=item *
1934
f7b06e7f
RS
1935A bug, case-insensitive regex with UTF8-flagged strings, introduced
1936earlier in the 5.17 series has been fixed. [perl #114982]
1937
1938=item *
1939
1940Attributes applied to lexical variables no longer leak memory.
1941[perl #114764]
1942
1943=item *
1944
1945C<dump>, C<goto>, C<last>, C<next>, C<redo> or C<require> followed by a
1946bareword (or version) and then an infix operator is no longer a syntax
1947error. It used to be for those infix operators (like C<+>) that have a
1948different meaning where a term is expected. [perl #105924]
1949
1950=item *
1951
1952C<require a::b . 1> and C<require a::b + 1> no longer produce erroneous
1953ambiguity warnings. [perl #107002]
1954
1955=item *
1956
1957Class method calls are now allowed on any string, and not just strings
1958beginning with an alphanumeric character. [perl #105922]
1959
1960=item *
1961
1962An empty pattern created with C<qr//> used in C<m///> no longer triggers
1963the "empty pattern reuses last pattern" behaviour. [perl #96230]
1964
1965=item *
1966
1967Tying a hash during iteration no longer results in a memory leak.
1968
1969=item *
1970
1971Freeing a tied hash during iteration no longer results in a memory leak.
1972
1973=item *
1974
1975List assignment to a tied array or hash that dies on STORE no longer
1976results in a memory leak.
1977
1978=item *
1979
1980If the hint hash (C<%^H>) is tied, compile-time scope entry (which copies
1981the hint hash) no longer leaks memory if FETCH dies. [perl #107000]
1982
1983=item *
1984
1985Constant folding no longer inappropriately triggers the special
1986C<split " "> behaviour. [perl #94490]
1987
1988=item *
1989
1990C<defined scalar(@array)>, C<defined do { &foo }>, and similar constructs
1991now treat the argument to C<defined> as a simple scalar. [perl #97466]
1992
1993=item *
1994
1995Running a custom debugging that defines no C<*DB::DB> glob or provides a
1996subroutine stub for C<&DB::DB> no longer results in a crash, but an error
1997instead. [perl #114990]
1998
1999=item *
2000
2001C<reset ""> now matches its documentation. C<reset> only resets C<m?...?>
2002patterns when called with no argument. An empty string for an argument now
2003does nothing. (It used to be treated as no argument.) [perl #97958]
2004
2005=item *
2006
2007C<printf> with an argument returning an empty list no longer reads past the
2008end of the stack, resulting in erratic behaviour. [perl #77094]
2009
2010=item *
2011
2012C<--subname> no longer produces erroneous ambiguity warnings.
2013[perl #77240]
2014
2015=item *
2016
2017C<v10> is now allowed as a label or package name. This was inadvertently
2018broken when v-strings were added in Perl 5.6. [perl #56880]
2019
2020=item *
2021
2022A regression introduced in 5.17.2 has been fixed, which made C</[\@\\]||/>
2023result in a "panic" error. [perl #115050]
2024
2025=item *
2026
2027C<length>, C<pos>, C<substr> and C<sprintf> could be confused by ties,
2028overloading, references and typeglobs if the stringification of such
2029changed the internal representation to or from UTF8. [perl #114410]
2030
2031=item *
2032
2033utf8::encode now calls FETCH and STORE on tied variables. utf8::decode now
2034calls STORE (it was already calling FETCH).
2035
2036=item *
2037
2038C<$tied =~ s/$non_utf8/$utf8/> no longer loops infinitely if the tied
2039variable returns a Latin-1 string, shared hash key scalar, or reference or
2040typeglob that stringifies as ASCII or Latin-1. This is a regression from
20415.12.x.
2042
2043=item *
2044
2045C<s///> without /e is now better at detecting when it needs to forego
2046certain optimisations, fixing some buggy cases:
2047
2048=over
2049
2050=item *
2051
2052Match variables in certain constructs (C<&&>, C<||>, C<..> and others) in
2053the replacement part; e.g., C<s/(.)/$l{$a||$1}/g>. [perl #26986]
2054
2055=item *
2056
2057Aliases to match variables in the replacement.
2058
2059=item *
2060
2061$REGERROR or $REGMARK in the replacement. [perl #49190]
2062
2063=item *
2064
2065An empty pattern (C<s//$foo/>) that causes the last-successful pattern to
2066be used, when that pattern contains code blocks that modify the variables
2067in the replacement.
2068
2069=back
2070
2071=item *
2072
2073The taintedness of the replacement string no longer affects the taintedness
2074of the return value of C<s///e>.
2075
2076=item *
2077
2078The C<$|> autoflush variable is created on-the-fly when needed. If this
2079happened (e.g., if it was mentioned in a module or eval) when the
2080currently-selected filehandle was a typeglob with an empty IO slot, it used
2081to crash. [perl #115206]
2082
2083=item *
2084
2085Line numbers at the end of a string eval are no longer off by one.
2086[perl #114658]
2087
2088=item *
2089
2090@INC filters (subroutines returned by subroutines in @INC) that set $_ to a
2091copy-on-write scalar no longer cause the parser to modify that string
2092buffer in place.
2093
2094=item *
2095
2096C<length($object)> no longer returns the undefined value if the object has
2097string overloading that returns undef. [perl #115260]
2098
2099=item *
2100
2101The use of C<PL_stashcache>, the stash name lookup cache for method calls, has
2102been restored,
2103
2104Commit da6b625f78f5f133 in August 2011 inadvertently broke the code that looks
2105up values in C<PL_stashcache>. As it's a only cache, quite correctly everything
2106carried on working without it.
2107
2108=item *
2109
00785cb7
RS
2110The error "Can't localize through a reference" had disappeared in 5.16.0
2111when C<local %$ref> appeared on the last line of an lvalue subroutine.
2112This error disappeared for C<\local %$ref> in perl 5.8.1. It has now
2113been restored.
2114
2115=item *
2116
2117The parsing of here-docs has been improved significantly, fixing several
2118parsing bugs and crashes and one memory leak, and correcting wrong
2119subsequent line numbers under certain conditions.
2120
2121=item *
2122
2123Inside an eval, the error message for an unterminated here-doc no longer
2124has a newline in the middle of it [perl #70836].
2125
2126=item *
2127
2128A substitution inside a substitution pattern (C<s/${s|||}//>) no longer
2129confuses the parser.
2130
2131=item *
2132
2133It may be an odd place to allow comments, but C<s//"" # hello/e> has
2134always worked, I<unless> there happens to be a null character before the
2135first #. Now it works even in the presence of nulls.
2136
2137=item *
2138
2139An invalid range in C<tr///> or C<y///> no longer results in a memory leak.
2140
2141=item *
2142
2143String eval no longer treats a semicolon-delimited quote-like operator at
2144the very end (C<eval 'q;;'>) as a syntax error.
2145
2146=item *
2147
2148C<< warn {$_ => 1} + 1 >> is no longer a syntax error. The parser used to
2149get confused with certain list operators followed by an anonymous hash and
2150then an infix operator that shares its form with a unary operator.
2151
2152=item *
2153
2154C<(caller $n)[6]> (which gives the text of the eval) used to return the
2155actual parser buffer. Modifying it could result in crashes. Now it always
2156returns a copy. The string returned no longer has "\n;" tacked on to the
2157end. The returned text also includes here-doc bodies, which used to be
2158omitted.
2159
2160=item *
2161
2162Reset the utf8 position cache when accessing magical variables to avoid the
2163string buffer and the utf8 position cache getting out of sync
2164[perl #114410].
2165
2166=item *
2167
2168Various cases of get magic being called twice for magical utf8 strings have been
2169fixed.
2170
2171=item *
2172
2173This code (when not in the presence of C<$&> etc)
2174
2175 $_ = 'x' x 1_000_000;
2176 1 while /(.)/;
2177
2178used to skip the buffer copy for performance reasons, but suffered from C<$1>
2179etc changing if the original string changed. That's now been fixed.
2180
2181=item *
2182
2183Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO
2184might attempt to allocate more memory.
2185
2186=item *
2187
2188In a regular expression, if something is quantified with C<{n,m}>
2189where C<S<n E<gt> m>>, it can't possibly match. Previously this was a fatal error,
2190but now is merely a warning (and that something won't match). [perl #82954].
2191
2192=item *
2193
2194It used to be possible for formats defined in subroutines that have
2195subsequently been undefined and redefined to close over variables in the
2196wrong pad (the newly-defined enclosing sub), resulting in crashes or
2197"Bizarre copy" errors.
2198
2199=item *
2200
2201Redefinition of XSUBs at run time could produce warnings with the wrong
2202line number.
2203
2204=item *
2205
2206The %vd sprintf format does not support version objects for alpha versions.
2207It used to output the format itself (%vd) when passed an alpha version, and
2208also emit an "Invalid conversion in printf" warning. It no longer does,
2209but produces the empty string in the output. It also no longer leaks
2210memory in this case.
2211
2212=item *
2213
2214A bug fix in an earlier 5.17.x release caused C<no a a 3> (a syntax error)
2215to result in a bad read or assertion failure, because an op was being freed
2216twice.
2217
2218=item *
2219
2220C<< $obj->SUPER::method >> calls in the main package could fail if the
2221SUPER package had already been accessed by other means.
2222
2223=item *
2224
2225Stash aliasing (C<*foo:: = *bar::>) no longer causes SUPER calls to ignore
2226changes to methods or @ISA or use the wrong package.
2227
2228=item *
2229
2230Method calls on packages whose names end in ::SUPER are no longer treated
2231as SUPER method calls, resulting in failure to find the method.
2232Furthermore, defining subroutines in such packages no longer causes them to
2233be found by SUPER method calls on the containing package [perl #114924].
2234
00785cb7
RS
2235=item *
2236
94b31d3f
RS
2237C<\w> now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D
2238(ZERO WIDTH JOINER). C<\W> no longer matches these. This change is because
2239Unicode corrected their definition of what C<\w> should match.
e5ba1bf1 2240
94b31d3f
RS
2241=item *
2242
2243C<dump LABEL> no longer leaks its label.
2244
2245=item *
2246
2247Constant folding no longer changes the behaviour of functions like C<stat()>
2248and C<truncate()> that can take either filenames or handles.
2249C<stat 1 ? foo : bar> nows treats its argument as a file name (since it is an
2250arbitrary expression), rather than the handle "foo".
2251
2252=item *
2253
2254C<truncate FOO, $len> no longer falls back to treating "FOO" as a file name if
2255the filehandle has been deleted. This was broken in Perl 5.16.0.
2256
2257=item *
2258
2259Subroutine redefinitions after sub-to-glob and glob-to-glob assignments no
2260longer cause double frees or panic messages.
2261
2262=item *
2263
2264C<s///> now turns vstrings into plain strings when performing a substitution,
2265even if the resulting string is the same (C<s/a/a/>).
2266
2267=item *
2268
2269Prototype mismatch warnings no longer erroneously treat constant subs as having
2270no prototype when they actually have "".
2271
2272=item *
2273
2274Constant subroutines and forward declarations no longer prevent prototype
2275mismatch warnings from omitting the sub name.
2276
2277=item *
2278
2279C<undef> on a subroutine now clears call checkers.
2280
2281=item *
2282
2283The C<ref> operator started leaking memory on blessed objects in Perl 5.16.0.
2284This has been fixed [perl #114340].
2285
2286=item *
2287
2288C<use> no longer tries to parse its arguments as a statement, making
2289C<use constant { () };> a syntax error [perl #114222].
2290
2291=item *
2292
2293On debugging builds, "uninitialized" warnings inside formats no longer cause
2294assertion failures.
2295
2296=item *
2297
2298On debugging builds, subroutines nested inside formats no longer cause
2299assertion failures [perl #78550].
2300
2301=item *
2302
2303Formats and C<use> statements are now permitted inside formats.
2304
2305=item *
2306
2307C<print $x> and C<sub { print $x }-E<gt>()> now always produce the same output.
2308It was possible for the latter to refuse to close over $x if the variable was
2309not active; e.g., if it was defined outside a currently-running named
2310subroutine.
2311
2312=item *
2313
2314Similarly, C<print $x> and C<print eval '$x'> now produce the same output.
2315This also allows "my $x if 0" variables to be seen in the debugger [perl
2316#114018].
2317
2318=item *
2319
2320Formats called recursively no longer stomp on their own lexical variables, but
2321each recursive call has its own set of lexicals.
2322
2323=item *
2324
2325Attempting to free an active format or the handle associated with it no longer
2326results in a crash.
2327
2328=item *
2329
2330Format parsing no longer gets confused by braces, semicolons and low-precedence
2331operators. It used to be possible to use braces as format delimiters (instead
2332of C<=> and C<.>), but only sometimes. Semicolons and low-precedence operators
2333in format argument lines no longer confuse the parser into ignoring the line's
2334return value. In format argument lines, braces can now be used for anonymous
2335hashes, instead of being treated always as C<do> blocks.
2336
2337=item *
2338
2339Formats can now be nested inside code blocks in regular expressions and other
2340quoted constructs (C</(?{...})/> and C<qq/${...}/>) [perl #114040].
2341
2342=item *
2343
2344Formats are no longer created after compilation errors.
2345
2346=item *
2347
2348Some format syntax errors started causing crashes in Perl 5.17.2, but have now
2349been fixed.
2350
2351=item *
2352
2353Under debugging builds, the B<-DA> command line option started crashing in Perl
23545.16.0. It has been fixed [perl #114368].
2355
2356=item *
2357
2358Scope::Escape compatibility, which was broken in Perl 5.17.2, has been restored
2359[perl #113872].
2360
2361=item *
2362
2363A potential deadlock scenario involving the premature termination of a pseudo-
2364forked child in a Windows build with ithreads enabled has been fixed. This
2365resolves the common problem of the F<t/op/fork.t> test hanging on Windows [perl
2366#88840].
2367
2368=item *
2369
2370The microperl build, broken since Perl 5.15.7, has now been restored.
2371
2372=item *
2373
2374The code which generates errors from C<require()> could potentially read one or
2375two bytes before the start of the filename for filenames less than three bytes
2376long and ending C</\.p?\z/>. This has now been fixed. Note that it could
2377never have happened with module names given to C<use()> or C<require()> anyway.
2378
2379=item *
2380
2381The handling of pathnames of modules given to C<require()> has been made
2382thread-safe on VMS.
2383
2384=item *
2385
2386The C<re_compile()> API function, the entry point for perl's regex compiler,
2387was accidentally changed in Perl 5.17.1 to operate on the current engine. This
2388has now been restored to its former core-engine-specific state [perl #114302].
2389
2390=item *
2391
2392Perl 5.17.1 introduced a memory leak into the re-use of run-time regexes where
2393the pattern hasn't changed (i.e. C</$unchanging/>). This has now been fixed.
2394
2395=item *
2396
2397A bug in the compilation of a C</(?{})/> expression which affected the TryCatch
2398test suite has been fixed [perl #114242].
2399
2400=item *
2401
2402Formats no longer leak. They started leaking in Perl 5.17.2.
2403
2404=item *
2405
2406Pod can now be nested in code inside a quoted construct outside of a string
2407eval. This used to work only within string evals [perl #114040].
e5ba1bf1
FC
2408
2409=item *
2410
0bba4573
RS
2411C<goto ''> now looks for an empty label, producing the "goto must have
2412label" error message, instead of exiting the program [perl #111794].
e5ba1bf1 2413
0bba4573 2414=item *
e5ba1bf1 2415
0bba4573
RS
2416C<goto "\0"> now dies with "Can't find label" instead of "goto must have
2417label".
e5ba1bf1 2418
0bba4573 2419=item *
e5ba1bf1 2420
0bba4573
RS
2421The C function C<hv_store> used to result in crashes when used on C<%^H>
2422[perl #111000].
e5ba1bf1 2423
0bba4573
RS
2424=item *
2425
2426A call checker attached to a closure prototype via C<cv_set_call_checker>
2427is now copied to closures cloned from it. So C<cv_set_call_checker> now
2428works inside an attribute handler for a closure.
e5ba1bf1
FC
2429
2430=item *
2431
0bba4573
RS
2432Writing to C<$^N> used to have no effect. Now it croaks with "Modification
2433of a read-only value" by default, but that can be overridden by a custom
2434regular expression engine, as with C<$1> [perl #112184].
2435
23dd6e2e
FC
2436=item *
2437
0bba4573
RS
2438C<undef> on a control character glob (C<undef *^H>) no longer emits an
2439erroneous warning about ambiguity [perl #112456].
23dd6e2e 2440
0bba4573
RS
2441=item *
2442
2443For efficiency's sake, many operators and built-in functions return the
2444same scalar each time. Lvalue subroutines and subroutines in the CORE::
2445namespace were allowing this implementation detail to leak through.
2446C<print &CORE::uc("a"), &CORE::uc("b")> used to print "BB". The same thing
2447would happen with an lvalue subroutine returning the return value of C<uc>.
2448Now the value is copied in such cases.
23dd6e2e
FC
2449
2450=item *
2451
0bba4573
RS
2452C<method {}> syntax with an empty block or a block returning an empty list
2453used to crash or use some random value left on the stack as its invocant.
2454Now it produces an error.
b92848b5 2455
0f023b5a
FC
2456=item *
2457
0bba4573 2458C<vec> now works with extremely large offsets (E<gt>2 GB) [perl #111730].
0f023b5a
FC
2459
2460=item *
2461
0bba4573
RS
2462Changes to overload settings now take effect immediately, as do changes to
2463inheritance that affect overloading. They used to take effect only after
2464C<bless>.
2465
2466Objects that were created before a class had any overloading used to remain
2467non-overloaded even if the class gained overloading through C<use overload>
2468or @ISA changes, and even after C<bless>. This has been fixed
2469[perl #112708].
c53e3a75
FC
2470
2471=item *
2472
0bba4573 2473Classes with overloading can now inherit fallback values.
c53e3a75
FC
2474
2475=item *
2476
0bba4573
RS
2477Overloading was not respecting a fallback value of 0 if there were
2478overloaded objects on both sides of an assignment operator like C<+=>
2479[perl #111856].
0f023b5a
FC
2480
2481=item *
2482
0bba4573
RS
2483C<pos> now croaks with hash and array arguments, instead of producing
2484erroneous warnings.
0f023b5a
FC
2485
2486=item *
2487
0bba4573
RS
2488C<while(each %h)> now implies C<while(defined($_ = each %h))>, like
2489C<readline> and C<readdir>.
0f023b5a 2490
0bba4573
RS
2491=item *
2492
2493Subs in the CORE:: namespace no longer crash after C<undef *_> when called
2494with no argument list (C<&CORE::time> with no parentheses).
2495
2496=item *
2497
2498Unicode 6.1 published an incorrect alias for one of the
2499Canonical_Combining_Class property's values (which range between 0 and
2500254). The alias C<CCC133> should have been C<CCC132>. Perl now
2501overrides the data file furnished by Unicode to give the correct value.
2502
2503=item *
2504
2505C<unpack> no longer produces the "'/' must follow a numeric type in unpack"
2506error when it is the data that are at fault [perl #60204].
2507
2508=item *
2509
2510C<join> and C<"@array"> now call FETCH only once on a tied C<$">
2511[perl #8931].
2512
2513=item *
2514
2515Some subroutine calls generated by compiling core ops affected by a
2516C<CORE::GLOBAL> override had op checking performed twice. The checking
2517is always idempotent for pure Perl code, but the double checking can
2518matter when custom call checkers are involved.
2519
2520=item *
2521
2522A race condition used to exist around fork that could cause a signal sent to
2523the parent to be handled by both parent and child. Signals are now blocked
2524briefly around fork to prevent this from happening [perl #82580].
e5ba1bf1 2525
0fef449b
RS
2526=item *
2527
2528The implementation of code blocks in regular expressions, such as C<(?{})>
2529and C<(??{})>, has been heavily reworked to eliminate a whole slew of bugs.
2530The main user-visible changes are:
2531
2532=over 4
2533
2534=item *
2535
2536Code blocks within patterns are now parsed in the same pass as the
2537surrounding code; in particular it is no longer necessary to have balanced
2538braces: this now works:
2539
2540 /(?{ $x='{' })/
2541
2542This means that this error message is longer generated:
2543
2544 Sequence (?{...}) not terminated or not {}-balanced in regex
2545
2546but a new error may be seen:
2547
2548 Sequence (?{...}) not terminated with ')'
2549
2550In addition, literal code blocks within run-time patterns are only
2551compiled once, at perl compile-time:
2552
2553 for my $p (...) {
2554 # this 'FOO' block of code is compiled once,
2555 # at the same time as the surrounding 'for' loop
2556 /$p{(?{FOO;})/;
2557 }
2558
2559=item *
2560
2561Lexical variables are now sane as regards scope, recursion and closure
2562behavior. In particular, C</A(?{B})C/> behaves (from a closure viewpoint)
2563exactly like C</A/ && do { B } && /C/>, while C<qr/A(?{B})C/> is like
2564C<sub {/A/ && do { B } && /C/}>. So this code now works how you might
2565expect, creating three regexes that match 0, 1, and 2:
2566
2567 for my $i (0..2) {
2568 push @r, qr/^(??{$i})$/;
2569 }
2570 "1" =~ $r[1]; # matches
2571
2572=item *
2573
2574The C<use re 'eval'> pragma is now only required for code blocks defined
2575at runtime; in particular in the following, the text of the C<$r> pattern is
2576still interpolated into the new pattern and recompiled, but the individual
2577compiled code-blocks within C<$r> are reused rather than being recompiled,
2578and C<use re 'eval'> isn't needed any more:
2579
2580 my $r = qr/abc(?{....})def/;
2581 /xyz$r/;
2582
2583=item *
2584
2585Flow control operators no longer crash. Each code block runs in a new
2586dynamic scope, so C<next> etc. will not see
2587any enclosing loops. C<return> returns a value
2588from the code block, not from any enclosing subroutine.
2589
2590=item *
2591
2592Perl normally caches the compilation of run-time patterns, and doesn't
2593recompile if the pattern hasn't changed, but this is now disabled if
2594required for the correct behavior of closures. For example:
2595
2596 my $code = '(??{$x})';
2597 for my $x (1..3) {
2598 # recompile to see fresh value of $x each time
2599 $x =~ /$code/;
2600 }
2601
0fef449b
RS
2602=item *
2603
2604The C</msix> and C<(?msix)> etc. flags are now propagated into the return
2605value from C<(??{})>; this now works:
2606
2607 "AB" =~ /a(??{'b'})/i;
2608
2609=item *
2610
2611Warnings and errors will appear to come from the surrounding code (or for
2612run-time code blocks, from an eval) rather than from an C<re_eval>:
2613
2614 use re 'eval'; $c = '(?{ warn "foo" })'; /$c/;
2615 /(?{ warn "foo" })/;
2616
2617formerly gave:
2618
2619 foo at (re_eval 1) line 1.
2620 foo at (re_eval 2) line 1.
2621
2622and now gives:
2623
2624 foo at (eval 1) line 1.
2625 foo at /some/prog line 2.
2626
2627=back
2628
2629=item *
2630
2631Perl now works as well as can be expected on all releases of Unicode so
2632far. In v5.16, it worked on Unicodes 6.0 and 6.1, but there were
2633various bugs for earlier releases; the older the release the more
2634problems.
2635
2636=item *
2637
2638C<vec> no longer produces "uninitialized" warnings in lvalue context
2639[perl #9423].
2640
2641=item *
2642
2643An optimization involving fixed strings in regular expressions could cause
2644a severe performance penalty in edge cases. This has been fixed
2645[perl #76546].
2646
2647=item *
2648
2649In certain cases, including empty subpatterns within a regular expression (such
2650as C<(?:)> or C<(?:|)>) could disable some optimizations. This has been fixed.
2651
2652=item *
2653
2654The "Can't find an opnumber" message that C<prototype> produces when passed
2655a string like "CORE::nonexistent_keyword" now passes UTF-8 and embedded
2656NULs through unchanged [perl #97478].
2657
2658=item *
2659
2660C<prototype> now treats magical variables like C<$1> the same way as
2661non-magical variables when checking for the CORE:: prefix, instead of
2662treating them as subroutine names.
2663
2664=item *
2665
2666Under threaded perls, a runtime code block in a regular expression could
2667corrupt the package name stored in the op tree, resulting in bad reads
2668in C<caller>, and possibly crashes [perl #113060].
2669
2670=item *
2671
2672Referencing a closure prototype (C<\&{$_[1]}> in an attribute handler for a
2673closure) no longer results in a copy of the subroutine (or assertion
2674failures on debugging builds).
2675
2676=item *
2677
2678C<eval '__PACKAGE__'> now returns the right answer on threaded builds if
2679the current package has been assigned over (as in
2680C<*ThisPackage:: = *ThatPackage::>) [perl #78742].
2681
2682=item *
2683
2684If a package is deleted by code that it calls, it is possible for C<caller>
2685to see a stack frame belonging to that deleted package. C<caller> could
2686crash if the stash's memory address was reused for a scalar and a
2687substitution was performed on the same scalar [perl #113486].
2688
2689=item *
2690
2691C<UNIVERSAL::can> no longer treats its first argument differently
2692depending on whether it is a string or number internally.
2693
2694=item *
2695
2696C<open> with C<< <& >> for the mode checks to see whether the third argument is
2697a number, in determining whether to treat it as a file descriptor or a handle
2698name. Magical variables like C<$1> were always failing the numeric check and
2699being treated as handle names.
2700
2701=item *
2702
2703C<warn>'s handling of magical variables (C<$1>, ties) has undergone several
2704fixes. C<FETCH> is only called once now on a tied argument or a tied C<$@>
2705[perl #97480]. Tied variables returning objects that stringify as "" are
2706no longer ignored. A tied C<$@> that happened to return a reference the
2707I<previous> time it was used is no longer ignored.
2708
2709=item *
2710
2711C<warn ""> now treats C<$@> with a number in it the same way, regardless of
2712whether it happened via C<$@=3> or C<$@="3">. It used to ignore the
2713former. Now it appends "\t...caught", as it has always done with
2714C<$@="3">.
2715
2716=item *
2717
2718Numeric operators on magical variables (e.g., S<C<$1 + 1>>) used to use
2719floating point operations even where integer operations were more appropriate,
2720resulting in loss of accuracy on 64-bit platforms [perl #109542].
2721
2722=item *
2723
2724Unary negation no longer treats a string as a number if the string happened
2725to be used as a number at some point. So, if C<$x> contains the string "dogs",
2726C<-$x> returns "-dogs" even if C<$y=0+$x> has happened at some point.
2727
2728=item *
2729
2730In Perl 5.14, C<-'-10'> was fixed to return "10", not "+10". But magical
2731variables (C<$1>, ties) were not fixed till now [perl #57706].
2732
2733=item *
2734
2735Unary negation now treats strings consistently, regardless of the internal
2736C<UTF8> flag.
2737
2738=item *
2739
2740A regression introduced in Perl v5.16.0 involving
2741C<tr/I<SEARCHLIST>/I<REPLACEMENTLIST>/> has been fixed. Only the first
2742instance is supposed to be meaningful if a character appears more than
2743once in C<I<SEARCHLIST>>. Under some circumstances, the final instance
2744was overriding all earlier ones. [perl #113584]
2745
2746=item *
2747
2748Regular expressions like C<qr/\87/> previously silently inserted a NUL
2749character, thus matching as if it had been written C<qr/\00087/>. Now it
2750matches as if it had been written as C<qr/87/>, with a message that the
2751sequence C<"\8"> is unrecognized.
2752
2753=item *
2754
2755C<__SUB__> now works in special blocks (C<BEGIN>, C<END>, etc.).
2756
2757=item *
2758
2759Thread creation on Windows could theoretically result in a crash if done
2760inside a C<BEGIN> block. It still does not work properly, but it no longer
2761crashes [perl #111610].
2762
2763=item *
2764
2765C<\&{''}> (with the empty string) now autovivifies a stub like any other
2766sub name, and no longer produces the "Unable to create sub" error
2767[perl #94476].
2768
37133b20
RS
2769=item *
2770
2771A regression introduced in v5.14.0 has been fixed, in which some calls
2772to the C<re> module would clobber C<$_> [perl #113750].
2773
2774=item *
2775
2776C<do FILE> now always either sets or clears C<$@>, even when the file can't be
2777read. This ensures that testing C<$@> first (as recommended by the
2778documentation) always returns the correct result.
2779
2780=item *
2781
2782The array iterator used for the C<each @array> construct is now correctly
2783reset when C<@array> is cleared (RT #75596). This happens for example when the
2784array is globally assigned to, as in C<@array = (...)>, but not when its
2785B<values> are assigned to. In terms of the XS API, it means that C<av_clear()>
2786will now reset the iterator.
2787
2788This mirrors the behaviour of the hash iterator when the hash is cleared.
2789
2790=item *
2791
2792C<< $class->can >>, C<< $class->isa >>, and C<< $class->DOES >> now return
2793correct results, regardless of whether that package referred to by C<$class>
2794exists [perl #47113].
2795
2796=item *
2797
2798Arriving signals no longer clear C<$@> [perl #45173].
2799
2800=item *
2801
2802Allow C<my ()> declarations with an empty variable list [perl #113554].
2803
2804=item *
2805
2806During parsing, subs declared after errors no longer leave stubs
2807[perl #113712].
2808
2809=item *
2810
2811Closures containing no string evals no longer hang on to their containing
2812subroutines, allowing variables closed over by outer subroutines to be
2813freed when the outer sub is freed, even if the inner sub still exists
2814[perl #89544].
2815
2816=item *
2817
2818Duplication of in-memory filehandles by opening with a "<&=" or ">&=" mode
2819stopped working properly in 5.16.0. It was causing the new handle to
2820reference a different scalar variable. This has been fixed [perl #113764].
2821
2822=item *
2823
2824C<qr//> expressions no longer crash with custom regular expression engines
2825that do not set C<offs> at regular expression compilation time
2826[perl #112962].
2827
2828=item *
2829
2830C<delete local> no longer crashes with certain magical arrays and hashes
2831[perl #112966].
2832
2833=item *
2834
2835C<local> on elements of certain magical arrays and hashes used not to
2836arrange to have the element deleted on scope exit, even if the element did
2837not exist before C<local>.
2838
2839=item *
2840
2841C<scalar(write)> no longer returns multiple items [perl #73690].
2842
2843=item *
2844
2845String to floating point conversions no longer misparse certain strings under
2846C<use locale> [perl #109318].
2847
2848=item *
2849
2850C<@INC> filters that die no longer leak memory [perl #92252].
2851
2852=item *
2853
2854The implementations of overloaded operations are now called in the correct
2855context. This allows, among other things, being able to properly override
2856C<< <> >> [perl #47119].
2857
2858=item *
2859
2860Specifying only the C<fallback> key when calling C<use overload> now behaves
2861properly [perl #113010].
2862
2863=item *
2864
2865C<< sub foo { my $a = 0; while ($a) { ... } } >> and
2866C<< sub foo { while (0) { ... } } >> now return the same thing [perl #73618].
2867
2868=item *
2869
2870Fixed the debugger C<l> and C<M> commands, and other debugger
2871functionality which was broken in 5.17.0 [perl #113918].
2872
2873=item *
2874
2875String negation now behaves the same under C<use integer;> as it does
2876without [perl #113012].
2877
2878=item *
2879
2880C<chr> now returns the Unicode replacement character (U+FFFD) for -1,
2881regardless of the internal representation. -1 used to wrap if the argument
2882was tied or a string internally.
2883
2884=item *
2885
2886Using a C<format> after its enclosing sub was freed could crash as of
2887perl 5.12.0, if the format referenced lexical variables from the outer sub.
2888
2889=item *
2890
2891Using a C<format> after its enclosing sub was undefined could crash as of
2892perl 5.10.0, if the format referenced lexical variables from the outer sub.
2893
2894=item *
2895
2896Using a C<format> defined inside a closures, which format references
2897lexical variables from outside, never really worked unless the C<write>
2898call was directly inside the closure. In 5.10.0 it even started crashing.
2899Now the copy of that closure nearest the top of the call stack is used to
2900find those variables.
2901
2902=item *
2903
2904Formats that close over variables in special blocks no longer crash if a
2905stub exists with the same name as the special block before the special
2906block is compiled.
2907
2908=item *
2909
2910The parser no longer gets confused, treating C<eval foo ()> as a syntax
2911error if preceded by C<print;> [perl #16249].
2912
2913=item *
2914
2915The return value of C<syscall> is no longer truncated on 64-bit platforms
2916[perl #113980].
2917
2918=item *
2919
2920Constant folding no longer causes C<print 1 ? FOO : BAR> to print to the
2921FOO handle [perl #78064].
2922
2923=item *
2924
2925C<do subname> now calls the named subroutine and uses the file name it
2926returns, instead of opening a file named "subname".
2927
2928=item *
2929
2930Subroutines looked up by rv2cv check hooks (registered by XS modules) are
2931now taken into consideration when determining whether C<foo bar> should be
2932the sub call C<foo(bar)> or the method call C<< "bar"->foo >>.
2933
2934=item *
2935
2936C<CORE::foo::bar> is no longer treated specially, allowing global overrides
2937to be called directly via C<CORE::GLOBAL::uc(...)> [perl #113016].
2938
2939=item *
2940
2941Calling an undefined sub whose typeglob has been undefined now produces the
2942customary "Undefined subroutine called" error, instead of "Not a CODE
2943reference".
2944
2945=item *
2946
2947Two bugs involving @ISA have been fixed. C<*ISA = *glob_without_array> and
2948C<undef *ISA; @{*ISA}> would prevent future modifications to @ISA from
2949updating the internal caches used to look up methods. The
2950*glob_without_array case was a regression from Perl 5.12.
2951
2952=item *
2953
2954Regular expression optimisations sometimes caused C<$> with C</m> to
2955produce failed or incorrect matches [perl #114068].
2956
2957=item *
2958
2959C<__SUB__> now works in a C<sort> block when the enclosing subroutine is
2960predeclared with C<sub foo;> syntax [perl #113710].
2961
2962=item *
2963
2964Unicode properties only apply to Unicode code points, which leads to
2965some subtleties when regular expressions are matched against
2966above-Unicode code points. There is a warning generated to draw your
2967attention to this. However, this warning was being generated
2968inappropriately in some cases, such as when a program was being parsed.
2969Non-Unicode matches such as C<\w> and C<[:word;]> should not generate the
2970warning, as their definitions don't limit them to apply to only Unicode
2971code points. Now the message is only generated when matching against
2972C<\p{}> and C<\P{}>. There remains a bug, [perl #114148], for the very
2973few properties in Unicode that match just a single code point. The
2974warning is not generated if they are matched against an above-Unicode
2975code point.
2976
7e7c78a1
RS
2977=item *
2978
2979Uninitialized warnings mentioning hash elements would only mention the
2980element name if it was not in the first bucket of the hash, due to an
2981off-by-one error.
2982
2983=item *
2984
2985A regular expression optimizer bug could cause multiline "^" to behave
2986incorrectly in the presence of line breaks, such that
2987C<"/\n\n" =~ m#\A(?:^/$)#im> would not match [perl #115242].
2988
2989=item *
2990
2991Failed C<fork> in list context no longer currupts the stack.
2992C<@a = (1, 2, fork, 3)> used to gobble up the 2 and assign C<(1, undef, 3)>
2993if the C<fork> call failed.
2994
2995=item *
2996
2997Numerous memory leaks have been fixed, mostly involving tied variables that
2998die, regular expression character classes and code blocks, and syntax
2999errors.
3000
3001=item *
3002
3003Assigning a regular expression (C<${qr//}>) to a variable that happens to
3004hold a floating point number no longer causes assertion failures on
3005debugging builds.
3006
3007=item *
3008
3009Assigning a regular expression to a scalar containing a number no longer
3010causes subsequent nummification to produce random numbers.
3011
3012=item *
3013
3014Assigning a regular expression to a magic variable no longer wipes away the
3015magic. This is a regression from 5.10.
3016
3017=item *
3018
3019Assigning a regular expression to a blessed scalar no longer results in
3020crashes. This is also a regression from 5.10.
3021
3022=item *
3023
3024Regular expression can now be assigned to tied hash and array elements with
3025flattening into strings.
3026
3027=item *
3028
3029Nummifying a regular expression no longer results in an uninitialized
3030warning.
3031
3032=item *
3033
3034Negative array indices no longer cause EXISTS methods of tied variables to
3035be ignored. This is a regression from 5.12.
3036
3037=item *
3038
3039Negative array indices no longer result in crashes on arrays tied to
3040non-objects.
3041
3042=item *
3043
3044C<$x = "(?{})"; /a++(?{})+$x/x> no longer erroneous produces an error (just
3045a warning, as expected). This was broken in 5.17.1.
3046
3047=item *
3048
3049C<$byte_overload .= $utf8> no longer results in doubly-encoded UTF8 if the
3050left-hand scalar happened to have produced a UTF8 string the last time
3051overloading was invoked.
3052
3053=item *
3054
3055C<goto &sub> now uses the current value of @_, instead of using the array
3056the subroutine was originally called with. This means
3057C<local @_ = (...); goto &sub> now works [perl #43077].
3058
3059=item *
3060
3061If a debugger is invoked recursively, it no longer stomps on its own
3062lexical variables. Formerly under recursion all calls would share the same
3063set of lexical variables [perl #115742].
3064
3065=item *
3066
3067C<*_{ARRAY}> returned from a subroutine no longer spontaneously
3068becomes empty.
3069
e5ba1bf1
FC
3070=back
3071
0bba4573 3072=head1 Known Problems
e5ba1bf1 3073
0bba4573
RS
3074XXX Descriptions of platform agnostic bugs we know we can't fix go here. Any
3075tests that had to be C<TODO>ed for the release would be noted here. Unfixed
3076platform specific bugs also go here.
3077
3078[ List each fix as a =item entry ]
3079
3080=over 4
3081
3082=item *
3083
3084XXX
3085
3086=back
e5ba1bf1
FC
3087
3088=head1 Acknowledgements
3089
3090XXX Generate this with:
3091
de3d8d88 3092 perl Porting/acknowledgements.pl v5.17.12..HEAD
e5ba1bf1
FC
3093
3094=head1 Reporting Bugs
3095
3096If you find what you think is a bug, you might check the articles recently
3097posted to the comp.lang.perl.misc newsgroup and the perl bug database at
3098http://rt.perl.org/perlbug/ . There may also be information at
3099http://www.perl.org/ , the Perl Home Page.
3100
3101If you believe you have an unreported bug, please run the L<perlbug> program
3102included with your release. Be sure to trim your bug down to a tiny but
3103sufficient test case. Your bug report, along with the output of C<perl -V>,
3104will be sent off to perlbug@perl.org to be analysed by the Perl porting team.
3105
3106If the bug you are reporting has security implications, which make it
3107inappropriate to send to a publicly archived mailing list, then please send it
3108to perl5-security-report@perl.org. This points to a closed subscription
3109unarchived mailing list, which includes all the core committers, who will be
3110able to help assess the impact of issues, figure out a resolution, and help
3111co-ordinate the release of patches to mitigate or fix the problem across all
3112platforms on which Perl is supported. Please only use this address for
3113security issues in the Perl core, not for modules independently distributed on
3114CPAN.
3115
3116=head1 SEE ALSO
3117
3118The F<Changes> file for an explanation of how to view exhaustive details on
3119what changed.
3120
3121The F<INSTALL> file for how to build Perl.
3122
3123The F<README> file for general stuff.
3124
3125The F<Artistic> and F<Copying> files for copyright information.
3126
3127=cut