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