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