This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perl5200delta: Correct which gcc versions we add -fwrapv for
[perl5.git] / Porting / perl5200delta.pod
1 =encoding utf8
2
3 =head1 NAME
4
5 perldelta - what is new for perl v5.20.0
6
7 =head1 DESCRIPTION
8
9 This document describes differences between the 5.18.0 release and the
10 5.20.0 release.
11
12 If you are upgrading from an earlier release such as 5.16.0, first read
13 L<perl5180delta>, which describes differences between 5.16.0 and 5.18.0.
14
15 =head1 Core Enhancements
16
17 =head2 Experimental Subroutine signatures
18
19 Declarative syntax to unwrap argument list into lexical variables.
20 C<sub foo ($a,$b) {...}> checks the number of arguments and puts the
21 arguments into lexical variables.  Signatures are not equivalent to
22 the existing idiom of C<sub foo { my($a,$b) = @_; ... }>.  Signatures
23 are only available by enabling a non-default feature, and generate
24 warnings about being experimental.  The syntactic clash with
25 prototypes is managed by disabling the short prototype syntax when
26 signatures are enabled.
27
28 See L<perlsub/Signatures> for details.
29
30 =head2 C<sub>s now take a C<prototype> attribute
31
32 When declaring or defining a C<sub>, the prototype can now be specified inside
33 of a C<prototype> attribute instead of in parens following the name.
34
35 For example, C<sub foo($$){}> could be rewritten as
36 C<sub foo : prototype($$){}>.
37
38 =head2 More consistent prototype parsing
39
40 Multiple semicolons in subroutine prototypes have long been tolerated and
41 treated as a single semicolon.  There was one case where this did not
42 happen.  A subroutine whose prototype begins with "*" or ";*" can affect
43 whether a bareword is considered a method name or sub call.  This now
44 applies also to ";;;*".
45
46 Whitespace has long been allowed inside subroutine prototypes, so
47 C<sub( $ $ )> is equivalent to C<sub($$)>, but until now it was stripped
48 when the subroutine was parsed.  Hence, whitespace was I<not> allowed in
49 prototypes set by C<Scalar::Util::set_prototype>.  Now it is permitted,
50 and the parser no longer strips whitespace.  This means
51 C<prototype &mysub> returns the original prototype, whitespace and all.
52
53 =head2 C<rand> now uses a consistent random number generator
54
55 Previously perl would use a platform specific random number generator, varying
56 between the libc rand(), random() or drand48().
57
58 This meant that the quality of perl's random numbers would vary from platform
59 to platform, from the 15 bits of rand() on Windows to 48-bits on POSIX
60 platforms such as Linux with drand48().
61
62 Perl now uses its own internal drand48() implementation on all platforms.  This
63 does not make perl's C<rand> cryptographically secure.  [perl #115928]
64
65 =head2 New slice syntax
66
67 The new C<%hash{...}> and C<%array[...]> syntax returns a list of key/value (or
68 index/value) pairs.  See L<perldata/"Key/Value Hash Slices">.
69
70 =head2 Experimental Postfix Dereferencing
71
72 When the C<postderef> feature is in effect, the following syntactical
73 equivalencies are set up:
74
75   $sref->$*;  # same as ${ $sref }  # interpolates
76   $aref->@*;  # same as @{ $aref }  # interpolates
77   $href->%*;  # same as %{ $href }
78   $cref->&*;  # same as &{ $cref }
79   $gref->**;  # same as *{ $gref }
80
81   $aref->$#*; # same as $#{ $aref }
82
83   $gref->*{ $slot }; # same as *{ $gref }{ $slot }
84
85   $aref->@[ ... ];  # same as @$aref[ ... ]  # interpolates
86   $href->@{ ... };  # same as @$href{ ... }  # interpolates
87   $aref->%[ ... ];  # same as %$aref[ ... ]
88   $href->%{ ... };  # same as %$href{ ... }
89
90 Those marked as interpolating only interpolate if the associated
91 C<postderef_qq> feature is also enabled.  This feature is B<experimental> and
92 will trigger C<experimental::postderef>-category warnings when used, unless
93 they are suppressed.
94
95 For more information, consult L<the Postfix Dereference Syntax section of
96 perlref|perlref/Postfix Dereference Syntax>.
97
98 =head2 Unicode 6.3 now supported
99
100 Perl now supports and is shipped with Unicode 6.3 (though Perl may be
101 recompiled with any previous Unicode release as well).  A detailed list of
102 Unicode 6.3 changes is at L<http://www.unicode.org/versions/Unicode6.3.0/>.
103
104 =head2 New C<\p{Unicode}> regular expression pattern property
105
106 This is a synonym for C<\p{Any}> and matches the set of Unicode-defined
107 code points 0 - 0x10FFFF.
108
109 =head2 Better 64-bit support
110
111 On 64-bit platforms, the internal array functions now use 64-bit offsets,
112 allowing Perl arrays to hold more than 2**31 elements, if you have the memory
113 available.
114
115 The regular expression engine now supports strings longer than 2**31
116 characters.  [perl #112790, #116907]
117
118 The functions PerlIO_get_bufsiz, PerlIO_get_cnt, PerlIO_set_cnt and
119 PerlIO_set_ptrcnt now have SSize_t, rather than int, return values and
120 parameters.
121
122 =head2 C<S<use locale>> now works on UTF-8 locales
123
124 Until this release, only single-byte locales, such as the ISO 8859
125 series were supported.  Now, the increasingly common multi-byte UTF-8
126 locales are also supported.  A UTF-8 locale is one in which the
127 character set is Unicode and the encoding is UTF-8.  The POSIX
128 C<LC_CTYPE> category operations (case changing (like C<lc()>, C<"\U">),
129 and character classification (C<\w>, C<\D>, C<qr/[[:punct:]]/>)) under
130 such a locale work just as if not under locale, but instead as if under
131 C<S<use feature 'unicode_strings'>>, except taint rules are followed.
132 Sorting remains by code point order in this release.  [perl #56820].
133
134 =head2 C<S<use locale>> now compiles on systems without locale ability
135
136 Previously doing this caused the program to not compile.  Within its
137 scope the program behaves as if in the "C" locale.  Thus programs
138 written for platforms that support locales can run on locale-less
139 platforms without change.  Attempts to change the locale away from the
140 "C" locale will, of course, fail.
141
142 =head2 More locale initialization fallback options
143
144 If there was an error with locales during Perl start-up, it immediately
145 gave up and tried to use the C<"C"> locale.  Now it first tries using
146 other locales given by the environment variables, as detailed in
147 L<perllocale/ENVIRONMENT>.  For example, if C<LC_ALL> and C<LANG> are
148 both set, and using the C<LC_ALL> locale fails, Perl will now try the
149 C<LANG> locale, and only if that fails, will it fall back to C<"C">.  On
150 Windows machines, Perl will try, ahead of using C<"C">, the system
151 default locale if all the locales given by environment variables fail.
152
153 =head2 C<-DL> runtime option now added for tracing locale setting
154
155 This is designed for Perl core developers to aid in field debugging bugs
156 regarding locales.
157
158 =head2 B<-F> now implies B<-a> and B<-a> implies B<-n>
159
160 Previously B<-F> without B<-a> was a no-op, and B<-a> without B<-n> or B<-p>
161 was a no-op, with this change, if you supply B<-F> then both B<-a> and B<-n>
162 are implied and if you supply B<-a> then B<-n> is implied.
163
164 You can still use B<-p> for its extra behaviour. [perl #116190]
165
166 =head2 $a and $b warnings exemption
167
168 The special variables $a and $b, used in C<sort>, are now exempt from "used
169 once" warnings, even where C<sort> is not used.  This makes it easier for
170 CPAN modules to provide functions using $a and $b for similar purposes.
171 [perl #120462]
172
173 =head1 Security
174
175 =head2 Avoid possible read of free()d memory during parsing
176
177 It was possible that free()d memory could be read during parsing in the unusual
178 circumstance of the Perl program ending with a heredoc and the last line of the
179 file on disk having no terminating newline character.  This has now been fixed.
180
181 =head1 Incompatible Changes
182
183 =head2 C<do> can no longer be used to call subroutines
184
185 The C<do SUBROUTINE(LIST)> form has resulted in a deprecation warning
186 since Perl v5.0.0, and is now a syntax error.
187
188 =head2 Quote-like escape changes
189
190 The character after C<\c> in a double-quoted string ("..." or qq(...))
191 or regular expression must now be a printable character and may not be
192 C<{>.
193
194 A literal C<{> after C<\B> or C<\b> is now fatal.
195
196 These were deprecated in perl v5.14.0.
197
198 =head2 Tainting happens under more circumstances; now conforms to documentation
199
200 This affects regular expression matching and changing the case of a
201 string (C<lc>, C<"\U">, I<etc>.) within the scope of C<use locale>.
202 The result is now tainted based on the operation, no matter what the
203 contents of the string were, as the documentation (L<perlsec>,
204 L<perllocale/SECURITY>) indicates it should.  Previously, for the case
205 change operation, if the string contained no characters whose case
206 change could be affected by the locale, the result would not be tainted.
207 For example, the result of C<uc()> on an empty string or one containing
208 only above-Latin1 code points is now tainted, and wasn't before.  This
209 leads to more consistent tainting results.  Regular expression patterns
210 taint their non-binary results (like C<$&>, C<$2>) if and only if the
211 pattern contains elements whose matching depends on the current
212 (potentially tainted) locale.  Like the case changing functions, the
213 actual contents of the string being matched now do not matter, whereas
214 formerly it did.  For example, if the pattern contains a C<\w>, the
215 results will be tainted even if the match did not have to use that
216 portion of the pattern to succeed or fail, because what a C<\w> matches
217 depends on locale.  However, for example, a C<.> in a pattern will not
218 enable tainting, because the dot matches any single character, and what
219 the current locale is doesn't change in any way what matches and what
220 doesn't.
221
222 =head2 C<\p{}>, C<\P{}> matching has changed for non-Unicode code
223 points.
224
225 C<\p{}> and C<\P{}> are defined by Unicode only on Unicode-defined code
226 points (C<U+0000> through C<U+10FFFF>).  Their behavior on matching
227 these legal Unicode code points is unchanged, but there are changes for
228 code points C<0x110000> and above.  Previously, Perl treated the result
229 of matching C<\p{}> and C<\P{}> against these as C<undef>, which
230 translates into "false".  For C<\P{}>, this was then complemented into
231 "true".  A warning was supposed to be raised when this happened.
232 However, various optimizations could prevent the warning, and the
233 results were often counter-intuitive, with both a match and its seeming
234 complement being false.  Now all non-Unicode code points are treated as
235 typical unassigned Unicode code points.  This generally is more
236 Do-What-I-Mean.  A warning is raised only if the results are arguably
237 different from a strict Unicode approach, and from what Perl used to do.
238 Code that needs to be strictly Unicode compliant can make this warning
239 fatal, and then Perl always raises the warning.
240
241 Details are in L<perlunicode/Beyond Unicode code points>.
242
243 =head2 C<\p{All}> has been expanded to match all possible code points
244
245 The Perl-defined regular expression pattern element C<\p{All}>, unused
246 on CPAN, used to match just the Unicode code points; now it matches all
247 possible code points; that is, it is equivalent to C<qr/./s>.  Thus
248 C<\p{All}> is no longer synonymous with C<\p{Any}>, which continues to
249 match just the Unicode code points, as Unicode says it should.
250
251 =head2 Data::Dumper's output may change
252
253 Depending on the data structures dumped and the settings set for
254 Data::Dumper, the dumped output may have changed from previous
255 versions.
256
257 If you have tests that depend on the exact output of Data::Dumper,
258 they may fail.
259
260 To avoid this problem in your code, test against the data structure
261 from evaluating the dumped structure, instead of the dump itself.
262
263 =head2 Locale decimal point character no longer leaks outside of S<C<use locale>> scope
264
265 This is actually a bug fix, but some code has come to rely on the bug
266 being present, so this change is listed here.  The current locale that
267 the program is running under is not supposed to be visible to Perl code
268 except within the scope of a S<C<use locale>>.  However, until now under
269 certain circumstances, the character used for a decimal point (often a
270 comma) leaked outside the scope.  If your code is affected by this
271 change, simply add a S<C<use locale>>.
272
273 =head2 Assignments of Windows sockets error codes to $! now prefer F<errno.h> values over WSAGetLastError() values
274
275 In previous versions of Perl, Windows sockets error codes as returned by
276 WSAGetLastError() were assigned to $!, and some constants such as ECONNABORTED,
277 not in F<errno.h> in VC++ (or the various Windows ports of gcc) were defined to
278 corresponding WSAE* values to allow $! to be tested against the E* constants
279 exported by L<Errno> and L<POSIX>.
280
281 This worked well until VC++ 2010 and later, which introduced new E* constants
282 with values E<gt> 100 into F<errno.h>, including some being (re)defined by perl
283 to WSAE* values.  That caused problems when linking XS code against other
284 libraries which used the original definitions of F<errno.h> constants.
285
286 To avoid this incompatibility, perl now maps WSAE* error codes to E* values
287 where possible, and assigns those values to $!.  The E* constants exported by
288 L<Errno> and L<POSIX> are updated to match so that testing $! against them,
289 wherever previously possible, will continue to work as expected, and all E*
290 constants found in F<errno.h> are now exported from those modules with their
291 original F<errno.h> values.
292
293 In order to avoid breakage in existing Perl code which assigns WSAE* values to
294 $!, perl now intercepts the assignment and performs the same mapping to E*
295 values as it uses internally when assigning to $! itself.
296
297 However, one backwards-incompatibility remains: existing Perl code which
298 compares $! against the numeric values of the WSAE* error codes that were
299 previously assigned to $! will now be broken in those cases where a
300 corresponding E* value has been assigned instead.  This is only an issue for
301 those E* values E<lt> 100, which were always exported from L<Errno> and
302 L<POSIX> with their original F<errno.h> values, and therefore could not be used
303 for WSAE* error code tests (e.g. WSAEINVAL is 10022, but the corresponding
304 EINVAL is 22).  (E* values E<gt> 100, if present, were redefined to WSAE*
305 values anyway, so compatibility can be achieved by using the E* constants,
306 which will work both before and after this change, albeit using different
307 numeric values under the hood.)
308
309 =head2 Functions C<PerlIO_vsprintf> and C<PerlIO_sprintf> have been removed
310
311 These two functions, undocumented, unused in CPAN, and problematic, have been
312 removed.
313
314 =head1 Deprecations
315
316 =head2 The C</\C/> character class
317
318 The C</\C/> regular expression character class is deprecated. From perl
319 5.22 onwards it will generate a warning, and from perl 5.24 onwards it
320 will be a regular expression compiler error. If you need to examine the
321 individual bytes that make up a UTF8-encoded character, then use
322 C<utf8::encode()> on the string (or a copy) first.
323
324 =head2 Literal control characters in variable names
325
326 This deprecation affects things like $\cT, where \cT is a literal control (such
327 as a C<NAK> or C<NEGATIVE ACKNOWLEDGE> character) in
328 the source code.  Surprisingly, it appears that originally this was intended as
329 the canonical way of accessing variables like $^T, with the caret form only
330 being added as an alternative.
331
332 The literal control form is being deprecated for two main reasons.  It has what
333 are likely unfixable bugs, such as $\cI not working as an alias for $^I, and
334 their usage not being portable to non-ASCII platforms: While $^T will work
335 everywhere, \cT is whitespace in EBCDIC.  [perl #119123]
336
337 =head2 References to non-integers and non-positive integers in C<$/>
338
339 Setting C<$/> to a reference to zero or a reference to a negative integer is
340 now deprecated, and will behave B<exactly> as though it was set to C<undef>.
341 If you want slurp behavior set C<$/> to C<undef> explicitly.
342
343 Setting C<$/> to a reference to a non integer is now forbidden and will
344 throw an error. Perl has never documented what would happen in this
345 context and while it used to behave the same as setting C<$/> to
346 the address of the references in future it may behave differently, so we
347 have forbidden this usage.
348
349 =head2 Character matching routines in POSIX
350
351 Use of any of these functions in the C<POSIX> module is now deprecated:
352 C<isalnum>, C<isalpha>, C<iscntrl>, C<isdigit>, C<isgraph>, C<islower>,
353 C<isprint>, C<ispunct>, C<isspace>, C<isupper>, and C<isxdigit>.  The
354 functions are buggy and don't work on UTF-8 encoded strings.  See their
355 entries in L<POSIX> for more information.
356
357 A warning is raised on the first call to any of them from each place in
358 the code that they are called.  (Hence a repeated statement in a loop
359 will raise just the one warning.)
360
361 =head2 Interpreter-based threads are now I<discouraged>
362
363 The "interpreter-based threads" provided by Perl are not the fast, lightweight
364 system for multitasking that one might expect or hope for.  Threads are
365 implemented in a way that make them easy to misuse.  Few people know how to
366 use them correctly or will be able to provide help.
367
368 The use of interpreter-based threads in perl is officially
369 L<discouraged|perlpolicy/discouraged>.
370
371 =head2 Module removals
372
373 The following modules will be removed from the core distribution in a
374 future release, and will at that time need to be installed from CPAN.
375 Distributions on CPAN which require these modules will need to list them as
376 prerequisites.
377
378 The core versions of these modules will now issue C<"deprecated">-category
379 warnings to alert you to this fact.  To silence these deprecation warnings,
380 install the modules in question from CPAN.
381
382 Note that the planned removal of these modules from core does not reflect a
383 judgement about the quality of the code and should not be taken as a suggestion
384 that their use be halted.  Their disinclusion from core primarily hinges on
385 their necessity to bootstrapping a fully functional, CPAN-capable Perl
386 installation, not on concerns over their design.
387
388 =over
389
390 =item L<CGI> and its associated CGI:: packages
391
392 =item L<inc::latest>
393
394 =item L<Package::Constants>
395
396 =item L<Module::Build> and its associated Module::Build:: packages
397
398 =back
399
400 =head1 Performance Enhancements
401
402 =over 4
403
404 =item *
405
406 Perl has a new copy-on-write mechanism that avoids the need to copy the
407 internal string buffer when assigning from one scalar to another. This
408 makes copying large strings appear much faster.  Modifying one of the two
409 (or more) strings after an assignment will force a copy internally. This
410 makes it unnecessary to pass strings by reference for efficiency.
411
412 This feature was already available in 5.18.0, but wasn't enabled by
413 default. It is the default now, and so you no longer need build perl with
414 the F<Configure> argument:
415
416     -Accflags=-DPERL_NEW_COPY_ON_WRITE
417
418 It can be disabled (for now) in a perl build with:
419
420     -Accflags=-DPERL_NO_COW
421
422 On some operating systems Perl can be compiled in such a way that any
423 attempt to modify string buffers shared by multiple SVs will crash.  This
424 way XS authors can test that their modules handle copy-on-write scalars
425 correctly.  See L<perlguts/"Copy on Write"> for detail.
426
427 =item *
428
429 Perl has an optimizer for regular expression patterns.  It analyzes the pattern
430 to find things such as the minimum length a string has to be to match, etc.  It
431 now better handles code points that are above the Latin1 range.
432
433 =item *
434
435 Executing a regex that contains the C<^> anchor (or its variant under the
436 C</m> flag) has been made much faster in several situations.
437
438 =item *
439
440 Precomputed hash values are now used in more places during method lookup.
441
442 =item *
443
444 Constant hash key lookups (C<$hash{key}> as opposed to C<$hash{$key}>) have
445 long had the internal hash value computed at compile time, to speed up
446 lookup.  This optimisation has only now been applied to hash slices as
447 well.
448
449 =item *
450
451 Combined C<and> and C<or> operators in void context, like those
452 generated for C<< unless ($a && $b) >> and C<< if ($a || b) >> now
453 short circuit directly to the end of the statement. [perl #120128]
454
455 =item *
456
457 In certain situations, when C<return> is the last statement in a subroutine's
458 main scope, it will be optimized out. This means code like:
459
460   sub baz { return $cat; }
461
462 will now behave like:
463
464   sub baz { $cat; }
465
466 which is notably faster.
467
468 [perl #120765]
469
470 =item *
471
472 Code like:
473
474   my $x; # or @x, %x
475   my $y;
476
477 is now optimized to:
478
479   my ($x, $y);
480
481 In combination with the padrange optimization, this means longer
482 uninitialized my variable statements are also optimized, so:
483
484   my $x; my @y; my %z;
485
486 becomes:
487
488   my ($x, @y, %z);
489
490 [perl #121077]
491
492 =item *
493
494 The creation of certain sorts of lists, including array and hash slices, is now
495 faster.
496
497 =item *
498
499 The optimisation for arrays indexed with a small constant integer is now
500 applied for integers in the range -128..127, rather than 0..255. This should
501 speed up Perl code using expressions like C<$x[-1]>, at the expense of
502 (presumably much rarer) code using expressions like C<$x[200]>.
503
504 =item *
505
506 The first iteration over a large hash (using C<keys> or C<each>) is now
507 faster. This is achieved by preallocating the hash's internal iterator
508 state, rather than lazily creating it when the hash is first iterated. (For
509 small hashes, the iterator is still created only when first needed. The
510 assumption is that small hashes are more likely to be used as objects, and
511 therefore never allocated. For large hashes, that's less likely to be true,
512 and the cost of allocating the iterator is swamped by the cost of allocating
513 space for the hash itself.)
514
515 =item *
516
517 When doing a global regex match on a string that came from the C<readline>
518 or C<E<lt>E<gt>> operator, the data is no longer copied unnecessarily.
519 [perl #121259]
520
521 =item *
522
523 Dereferencing (as in C<$obj-E<gt>[0]> or C<$obj-E<gt>{k}>) is now faster
524 when C<$obj> is an instance of a class that has overloaded methods, but
525 doesn't overload any of the dereferencing methods C<@{}>, C<%{}>, and so on.
526
527 =item *
528
529 Perl's optimiser no longer skips optimising code that follows certain
530 C<eval {}> expressions (including those with an apparent infinite loop).
531
532 =item *
533
534 The implementation now does a better job of avoiding meaningless work at
535 runtime. Internal effect-free "null" operations (created as a side-effect of
536 parsing Perl programs) are normally deleted during compilation. That
537 deletion is now applied in some situations that weren't previously handled.
538
539 =item *
540
541 Perl now does less disk I/O when dealing with Unicode properties that cover
542 up to three ranges of consecutive code points.
543
544 =back
545
546 =head1 Modules and Pragmata
547
548   XXX TO BE AUTOGENERATED
549
550 =head1 Documentation
551
552 =head2 New Documentation
553
554 =head3 L<perlrepository>
555
556 This document was removed (actually, renamed L<perlgit> and given a major
557 overhaul) in Perl v5.14, causing Perl documentation websites to show the now
558 out of date version in Perl v5.12 as the latest version.  It has now been
559 restored in stub form, directing readers to current information.
560
561 =head2 Changes to Existing Documentation
562
563 =head3 L<perldata>
564
565 =over 4
566
567 =item *
568
569 New sections have been added to document the new index/value array slice and
570 key/value hash slice syntax.
571
572 =back
573
574 =head3 L<perldebguts>
575
576 =over 4
577
578 =item *
579
580 The C<DB::goto> and C<DB::lsub> debugger subroutines are now documented.  [perl
581 #77680]
582
583 =back
584
585 =head3 L<perlexperiment>
586
587 =over
588
589 =item *
590
591 C<\s> matching C<\cK> is marked experimental.
592
593 =item *
594
595 ithreads were accepted in v5.8.0 (but are discouraged as of v5.20.0).
596
597 =item *
598
599 Long doubles are not considered experimental.
600
601 =item *
602
603 Code in regular expressions, regular expression backtracking verbs,
604 and lvalue subroutines are no longer listed as experimental.  (This
605 also affects L<perlre> and L<perlsub>.)
606
607 =back
608
609 =head3 L<perlfunc>
610
611 =over
612
613 =item *
614
615 C<chop> and C<chomp> now note that they can reset the hash iterator.
616
617 =item *
618
619 C<exec>'s handling of arguments is now more clearly documented.
620
621 =item *
622
623 C<eval EXPR> now has caveats about expanding floating point numbers in some
624 locales.
625
626 =item *
627
628 C<goto EXPR> is now documented to handle an expression that evalutes to a
629 code reference as if it was C<goto &$coderef>.  This behavior is at least ten
630 years old.
631
632 =item *
633
634 Since Perl v5.10, it has been possible for subroutines in C<@INC> to return
635 a reference to a scalar holding initial source code to prepend to the file.
636 This is now documented.
637
638 =item *
639
640 The documentation of C<ref> has been updated to recommend the use of
641 C<blessed>, C<isa> and C<reftype> when dealing with references to blessed
642 objects.
643
644 =back
645
646 =head3 L<perlguts>
647
648 =over 4
649
650 =item *
651
652 Numerous minor changes have been made to reflect changes made to the perl
653 internals in this release.
654
655 =item *
656
657 New sections on L<Read-Only Values|perlguts/"Read-Only Values"> and
658 L<Copy on Write|perlguts/"Copy on Write"> have been added.
659
660 =back
661
662 =head3 L<perlhack>
663
664 =over 4
665
666 =item *
667
668 The L<Super Quick Patch Guide|perlhack/SUPER QUICK PATCH GUIDE> section has
669 been updated.
670
671 =back
672
673 =head3 L<perlhacktips>
674
675 =over 4
676
677 =item *
678
679 The documentation has been updated to include some more examples of C<gdb>
680 usage.
681
682 =back
683
684 =head2 L<perllexwarn>
685
686 =over 4
687
688 =item *
689
690 The L<perllexwarn> documentation used to describe the hierarchy of warning
691 categories understood by the L<warnings> pragma. That description has now
692 been moved to the L<warnings> documentation itself, leaving L<perllexwarn>
693 as a stub that points to it. This change consolidates all documentation for
694 lexical warnings in a single place.
695
696 =back
697
698 =head3 L<perllocale>
699
700 =over
701
702 =item *
703
704 The documentation now mentions F<fc()> and C<\F>, and includes many
705 clarifications and corrections in general.
706
707 =back
708
709 =head3 L<perlop>
710
711 =over 4
712
713 =item *
714
715 The language design of Perl has always called for monomorphic operators.
716 This is now mentioned explicitly.
717
718 =back
719
720 =head3 L<perlopentut>
721
722 =over 4
723
724 =item *
725
726 The C<open> tutorial has been completely rewritten by Tom Christiansen, and now
727 focuses on covering only the basics, rather than providing a comprehensive
728 reference to all things openable.  This rewrite came as the result of a
729 vigorous discussion on perl5-porters kicked off by a set of improvements
730 written by Alexander Hartmaier to the existing L<perlopentut>.  A "more than
731 you ever wanted to know about C<open>" document may follow in subsequent
732 versions of perl.
733
734 =back
735
736 =head3 L<perlre>
737
738 =over 4
739
740 =item *
741
742 The fact that the regexp engine makes no effort to call (?{}) and (??{})
743 constructs any specified number of times (although it will basically DWIM
744 in case of a successful match) has been documented.
745
746 =item *
747
748 The C</r> modifier (for non-destructive substitution) is now documented. [perl
749 #119151]
750
751 =item *
752
753 The documentation for C</x> and C<(?# comment)> has been expanded and clarified.
754
755 =back
756
757 =head3 L<perlreguts>
758
759 =over 4
760
761 =item *
762
763 The documentation has been updated in the light of recent changes to
764 F<regcomp.c>.
765
766 =back
767
768 =head3 L<perlsub>
769
770 =over 4
771
772 =item *
773
774 The need to predeclare recursive functions with prototypes in order for the
775 prototype to be honoured in the recursive call is now documented. [perl #2726]
776
777 =item *
778
779 A list of subroutine names used by the perl implementation is now included.
780 [perl #77680]
781
782 =back
783
784 =head3 L<perltrap>
785
786 =over 4
787
788 =item *
789
790 There is now a L<JavaScript|perltrap/JavaScript Traps> section.
791
792 =back
793
794 =head3 L<perlunicode>
795
796 =over 4
797
798 =item *
799
800 The documentation has been updated to reflect C<Bidi_Class> changes in
801 Unicode 6.3.
802
803 =back
804
805 =head3 L<perlvar>
806
807 =over 4
808
809 =item *
810
811 A new section explaining the performance issues of $`, $& and $', including
812 workarounds and changes in different versions of Perl, has been added.
813
814 =item *
815
816 Three L<English> variable names which have long been documented but do not
817 actually exist have been removed from the documentation.  These were
818 C<$OLD_PERL_VERSION>, C<$OFMT>, and C<$ARRAY_BASE>.
819
820 =back
821
822 =head3 L<perlxs>
823
824 =over 4
825
826 =item *
827
828 Several problems in the C<MY_CXT> example have been fixed.
829
830 =back
831
832 =head1 Diagnostics
833
834 The following additions or changes have been made to diagnostic output,
835 including warnings and fatal error messages.  For the complete list of
836 diagnostic messages, see L<perldiag>.
837
838 =head2 New Diagnostics
839
840 =head3 New Errors
841
842 =over 4
843
844 =item *
845
846 L<delete argument is indexE<sol>value array slice, use array slice|perldiag/"delete argument is index/value array slice, use array slice">
847
848 (F) You used index/value array slice syntax (C<%array[...]>) as the argument to
849 C<delete>.  You probably meant C<@array[...]> with an @ symbol instead.
850
851 =item *
852
853 L<delete argument is keyE<sol>value hash slice, use hash slice|perldiag/"delete argument is key/value hash slice, use hash slice">
854
855 (F) You used key/value hash slice syntax (C<%hash{...}>) as the argument to
856 C<delete>.  You probably meant C<@hash{...}> with an @ symbol instead.
857
858 =item *
859
860 L<Magical list constants are not supported|perldiag/"Magical list constants are
861 not supported">
862
863 (F) You assigned a magical array to a stash element, and then tried to use the
864 subroutine from the same slot.  You are asking Perl to do something it cannot
865 do, details subject to change between Perl versions.
866
867 =item *
868
869 Added L<Setting $E<sol> to a %s reference is forbidden|perldiag/"Setting $E<sol> to %s reference is forbidden">
870
871 =back
872
873 =head3 New Warnings
874
875 =over 4
876
877 =item *
878
879 L<%s on a reference is experimental|perldiag/"%s on a reference is experimental">:
880
881 The "auto-deref" feature is experimental.
882
883 Starting in v5.14.0, it was possible to use push, pop, keys, and other
884 built-in functions not only on aggregate types, but on references to
885 them.  The feature was not deployed to its original intended
886 specification, and now may become redundant to postfix dereferencing.
887 It has always been categorized as an experimental feature, and in
888 v5.20.0 is carries a warning as such.
889
890 Warnings will now be issued at compile time when these operations are
891 detected.
892
893   no if $] >= 5.01908, warnings => "experimental::autoderef";
894
895 Consider, though, replacing the use of these features, as they may
896 change behavior again before becoming stable.
897
898 =item *
899
900 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">
901
902 L<Trailing white-space in a charnames alias definition is deprecated|perldiag/"Trailing white-space in a charnames alias definition is deprecated">
903
904 These two deprecation warnings involving C<\N{...}> were incorrectly
905 implemented.  They did not warn by default (now they do) and could not be
906 made fatal via C<< use warnings FATAL => 'deprecated' >> (now they can).
907
908 =item *
909
910 L<Attribute prototype(%s) discards earlier prototype attribute in same sub|perldiag/"Attribute prototype(%s) discards earlier prototype attribute in same sub">
911
912 (W misc) A sub was declared as sub foo : prototype(A) : prototype(B) {}, for
913 example.  Since each sub can only have one prototype, the earlier
914 declaration(s) are discarded while the last one is applied.
915
916 =item *
917
918 L<Invalid \0 character in %s for %s: %s\0%s|perldiag/"Invalid \0 character in %s for %s: %s\0%s">
919
920 (W syscalls) Embedded \0 characters in pathnames or other system call arguments
921 produce a warning as of 5.20.  The parts after the \0 were formerly ignored by
922 system calls.
923
924 =item *
925
926 L<Matched non-Unicode code point 0x%X against Unicode property; may not be portable|perldiag/"Matched non-Unicode code point 0x%X against Unicode property; may not be portable">.
927
928 This replaces the message "Code point 0x%X is not Unicode, all \p{} matches
929 fail; all \P{} matches succeed".
930
931 =item *
932
933 L<Missing ']' in prototype for %s : %s|perldiag/"Missing ']' in prototype for %s : %s">
934
935 (W illegalproto) A grouping was started with C<[> but never closed with C<]>.
936
937 =item *
938
939 L<Possible precedence issue with control flow operator|perldiag/"Possible precedence issue with control flow operator">
940
941 (W syntax) There is a possible problem with the mixing of a control flow
942 operator (e.g. C<return>) and a low-precedence operator like C<or>.  Consider:
943
944     sub { return $a or $b; }
945
946 This is parsed as:
947
948     sub { (return $a) or $b; }
949
950 Which is effectively just:
951
952     sub { return $a; }
953
954 Either use parentheses or the high-precedence variant of the operator.
955
956 Note this may be also triggered for constructs like:
957
958     sub { 1 if die; }
959
960 =item *
961
962 L<Postfix dereference is experimental|perldiag/"Postfix dereference is experimental">
963
964 (S experimental::postderef) This warning is emitted if you use the experimental
965 postfix dereference syntax.  Simply suppress the warning if you want to use the
966 feature, but know that in doing so you are taking the risk of using an
967 experimental feature which may change or be removed in a future Perl version:
968
969     no warnings "experimental::postderef";
970     use feature "postderef", "postderef_qq";
971     $ref->$*;
972     $aref->@*;
973     $aref->@[@indices];
974     ... etc ...
975
976 =item *
977
978 L<Prototype '%s' overridden by attribute 'prototype(%s)' in %s|perldiag/"Prototype '%s' overridden by attribute 'prototype(%s)' in %s">
979
980 (W prototype) A prototype was declared in both the parentheses after the sub
981 name and via the prototype attribute.  The prototype in parentheses is useless,
982 since it will be replaced by the prototype from the attribute before it's ever
983 used.
984
985 =item *
986
987 L<Scalar value %%s[%s] better written as $%s[%s]|perldiag/"Scalar value %%s[%s] better written as $%s[%s]">
988
989 (W syntax) In scalar context, you've used an array index/value slice (indicated
990 by %) to select a single element of an array.  Generally it's better to ask for
991 a scalar value (indicated by $).  The difference is that C<$foo[&bar]> always
992 behaves like a scalar, both in the value it returns and when evaluating its
993 argument, while C<%foo[&bar]> provides a list context to its subscript, which
994 can do weird things if you're expecting only one subscript.  When called in
995 list context, it also returns the index (what C<&bar> returns) in addition to
996 the value.
997
998 =item *
999
1000 L<Scalar value %%s{%s} better written as $%s{%s}|perldiag/"Scalar value %%s{%s} better written as $%s{%s}">
1001
1002 (W syntax) In scalar context, you've used a hash key/value slice (indicated by
1003 %) to select a single element of a hash.  Generally it's better to ask for a
1004 scalar value (indicated by $).  The difference is that C<$foo{&bar}> always
1005 behaves like a scalar, both in the value it returns and when evaluating its
1006 argument, while C<@foo{&bar}> and provides a list context to its subscript,
1007 which can do weird things if you're expecting only one subscript.  When called
1008 in list context, it also returns the key in addition to the value.
1009
1010 =item *
1011
1012 L<Setting $E<sol> to a reference to %s as a form of slurp is deprecated, treating as undef|perldiag/"Setting $E<sol> to a reference to %s as a form of slurp is deprecated, treating as undef">
1013
1014 =item *
1015
1016 L<Unexpected exit %u|perldiag/"Unexpected exit %u">
1017
1018 (S) exit() was called or the script otherwise finished gracefully when
1019 C<PERL_EXIT_WARN> was set in C<PL_exit_flags>.
1020
1021 =item *
1022
1023 L<Unexpected exit failure %u|perldiag/"Unexpected exit failure %u">
1024
1025 (S) An uncaught die() was called when C<PERL_EXIT_WARN> was set in
1026 C<PL_exit_flags>.
1027
1028 =item *
1029
1030 L<Use of literal control characters in variable names is deprecated|perldiag/"Use of literal control characters in variable names is deprecated">
1031
1032 (D deprecated) Using literal control characters in the source to refer to the
1033 ^FOO variables, like $^X and ${^GLOBAL_PHASE} is now deprecated.  This only
1034 affects code like $\cT, where \cT is a control (like a C<SOH>) in the
1035 source code: ${"\cT"} and $^T remain valid.
1036
1037 =item *
1038
1039 L<Useless use of greediness modifier|perldiag/"Useless use of greediness modifier '%c' in regex; marked by <-- HERE in m/%s/">
1040
1041 This fixes [Perl #42957].
1042
1043 =back
1044
1045 =head2 Changes to Existing Diagnostics
1046
1047 =over 4
1048
1049 =item *
1050
1051 Warnings and errors from the regexp engine are now UTF-8 clean
1052
1053 =item *
1054
1055 The "Unknown switch condition" error message has some slight changes.  This
1056 error triggers when there is an unknown condition in a C<(?(foo))> conditional.
1057 The error message used to read:
1058
1059     Unknown switch condition (?(%s in regex;
1060
1061 But what %s could be was mostly up to luck.  For C<(?(foobar))>, you might have
1062 seen "fo" or "f".  For Unicode characters, you would generally get a corrupted
1063 string.  The message has been changed to read:
1064
1065     Unknown switch condition (?(...)) in regex;
1066
1067 Additionally, the C<'E<lt>-- HERE'> marker in the error will now point to the
1068 correct spot in the regex.
1069
1070 =item *
1071
1072 The "%s "\x%X" does not map to Unicode" warning is now correctly listed as a
1073 severe warning rather than as a fatal error.
1074
1075 =item *
1076
1077 Under rare circumstances, one could get a "Can't coerce readonly REF to
1078 string" instead of the customary "Modification of a read-only value".  This
1079 alternate error message has been removed.
1080
1081 =item *
1082
1083 "Ambiguous use of * resolved as operator *": This and similar warnings
1084 about "%" and "&" used to occur in some circumstances where there was no
1085 operator of the type cited, so the warning was completely wrong.  This has
1086 been fixed [perl #117535, #76910].
1087
1088 =item *
1089
1090 Warnings about malformed subroutine prototypes are now more consistent in
1091 how the prototypes are rendered.  Some of these warnings would truncate
1092 prototypes containing nulls.  In other cases one warning would suppress
1093 another.  The warning about illegal characters in prototypes no longer says
1094 "after '_'" if the bad character came before the underscore.
1095
1096 =item *
1097
1098 L<Perl folding rules are not up-to-date for 0x%X; please use the perlbug
1099 utility to report; in regex; marked by <-- HERE in
1100 mE<sol>%sE<sol>|perldiag/"Perl folding rules are not up-to-date for 0x%X;
1101 please use the perlbug utility to report; in regex; marked by <-- HERE in
1102 m/%s/">
1103
1104 This message is now only in the regexp category, and not in the deprecated
1105 category.  It is still a default (i.e., severe) warning [perl #89648].
1106
1107 =item *
1108
1109 L<%%s[%s] in scalar context better written as $%s[%s]|perldiag/"%%s[%s] in scalar context better written as $%s[%s]">
1110
1111 This warning now occurs for any C<%array[$index]> or C<%hash{key}> known to
1112 be in scalar context at compile time.  Previously it was worded "Scalar
1113 value %%s[%s] better written as $%s[%s]".
1114
1115 =item *
1116
1117 L<Switch condition not recognized in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Switch condition not recognized in regex; marked by <-- HERE in m/%s/">:
1118
1119 The description for this diagnostic has been extended to cover all cases where the warning may occur.
1120 Issues with the positioning of the arrow indicator have also been resolved.
1121
1122 =item *
1123
1124 The error messages for C<my($a?$b$c)> and C<my(do{})> now mention "conditional
1125 expression" and "do block", respectively, instead of reading 'Can't declare
1126 null operation in "my"'.
1127
1128 =item *
1129
1130 When C<use re "debug"> executes a regex containing a backreference, the
1131 debugging output now shows what string is being matched.
1132
1133 =item *
1134
1135 The now fatal error message C<Character following "\c" must be ASCII> has been
1136 reworded as C<Character following "\c" must be printable ASCII> to emphasize
1137 that in C<\cI<X>>, I<X> must be a I<printable (non-control)> ASCII character.
1138
1139 =back
1140
1141 =head1 Utility Changes
1142
1143 =head3 L<a2p>
1144
1145 =over 4
1146
1147 =item *
1148
1149 A possible crash from an off-by-one error when trying to access before the
1150 beginning of a buffer has been fixed.  [perl #120244]
1151
1152 =back
1153
1154 =head3 F<bisect.pl>
1155
1156 The git bisection tool F<Porting/bisect.pl> has had many enhancements.
1157
1158 It is provided as part of the source distribution but not installed because
1159 it is not self-contained as it relies on being run from within a git
1160 checkout. Note also that it makes no attempt to fix tests, correct runtime
1161 bugs or make something useful to install - its purpose is to make minimal
1162 changes to get any historical revision of interest to build and run as close
1163 as possible to "as-was", and thereby make C<git bisect> easy to use.
1164
1165 =over 4
1166
1167 =item *
1168
1169 Can optionally run the test case with a timeout.
1170
1171 =item *
1172
1173 Can now run in-place in a clean git checkout.
1174
1175 =item *
1176
1177 Can run the test case under C<valgrind>.
1178
1179 =item *
1180
1181 Can apply user supplied patches and fixes to the source checkout before
1182 building.
1183
1184 =item *
1185
1186 Now has fixups to enable building several more historical ranges of bleadperl,
1187 which can be useful for pinpointing the origins of bugs or behaviour changes.
1188
1189 =back
1190
1191 =head3 L<find2perl>
1192
1193 =over 4
1194
1195 =item *
1196
1197 L<find2perl> now handles C<?> wildcards correctly.  [perl #113054]
1198
1199 =back
1200
1201 =head3 L<perlbug>
1202
1203 =over 4
1204
1205 =item *
1206
1207 F<perlbug> now has a C<-p> option for attaching patches with a bug report.
1208
1209 =item *
1210
1211 L<perlbug> has been modified to supply the report template with CRLF line
1212 endings on Windows.
1213 [L<perl #121277|https://rt.perl.org/Public/Bug/Display.html?id=121277>]
1214
1215 =item *
1216
1217 L<perlbug> now makes as few assumptions as possible about the encoding of the
1218 report.  This will likely change in the future to assume UTF-8 by default but
1219 allow a user override.
1220
1221 =back
1222
1223 =head1 Configuration and Compilation
1224
1225 =over 4
1226
1227 =item *
1228
1229 The F<Makefile.PL> for L<SDBM_File> now generates a better F<Makefile>, which
1230 avoids a race condition during parallel makes, which could cause the build to
1231 fail.  This is the last known parallel make problem (on *nix platforms), and
1232 therefore we believe that a parallel make should now always be error free.
1233
1234 =item *
1235
1236 F<installperl> and F<installman>'s option handling has been refactored to use
1237 L<Getopt::Long>. Both are used by the F<Makefile> C<install> targets, and
1238 are not installed, so these changes are only likely to affect custom
1239 installation scripts.
1240
1241 =over 4
1242
1243 =item *
1244
1245 Single letter options now also have long names.
1246
1247 =item *
1248
1249 Invalid options are now rejected.
1250
1251 =item *
1252
1253 Command line arguments that are not options are now rejected.
1254
1255 =item *
1256
1257 Each now has a C<--help> option to display the usage message.
1258
1259 =back
1260
1261 The behaviour for all valid documented invocations is unchanged.
1262
1263 =item *
1264
1265 Where possible, the build now avoids recursive invocations of F<make> when
1266 building pure-Perl extensions, without removing any parallelism from the
1267 build. Currently around 80 extensions can be processed directly by the
1268 F<make_ext.pl> tool, meaning that 80 invocations of F<make> and 160
1269 invocations of F<miniperl> are no longer made.
1270
1271 =item *
1272
1273 The build system now works correctly when compiling under GCC or Clang with
1274 link-time optimization enabled (the C<-flto> option). [perl #113022]
1275
1276 =item *
1277
1278 Distinct library basenames with C<d_libname_unique>.
1279
1280 When compiling perl with this option, the library files for XS modules are
1281 named something "unique" -- for example, Hash/Util/Util.so becomes
1282 Hash/Util/PL_Hash__Util.so.  This behavior is similar to what currently
1283 happens on VMS, and serves as groundwork for the Android port.
1284
1285 =item *
1286
1287 C<sysroot> option to indicate the logical root directory under gcc and clang.
1288
1289 When building with this option set, both Configure and the compilers search
1290 for all headers and libraries under this new sysroot, instead of /.
1291
1292 This is a huge time saver if cross-compiling, but can also help
1293 on native builds if your toolchain's files have non-standard locations.
1294
1295 =item *
1296
1297 The cross-compilation model has been renovated.
1298 There's several new options, and some backwards-incompatible changes:
1299
1300 We now build binaries for miniperl and generate_uudmap to be used on the host,
1301 rather than running every miniperl call on the target; this means that, short
1302 of 'make test', we no longer need access to the target system once Configure is
1303 done.  You can provide already-built binaries through the C<hostperl> and
1304 C<hostgenerate> options to Configure.
1305
1306 Additionally, if targeting an EBCDIC platform from an ASCII host,
1307 or viceversa, you'll need to run Configure with C<-Uhostgenerate>, to
1308 indicate that generate_uudmap should be run on the target.
1309
1310 Finally, there's also a way of having Configure end early, right after
1311 building the host binaries, by cross-compiling without specifying a
1312 C<targethost>.
1313
1314 The incompatible changes include no longer using xconfig.h, xlib, or
1315 Cross.pm, so canned config files and Makefiles will have to be updated.
1316
1317 =item *
1318
1319 Related to the above, there is now a way of specifying the location of sh
1320 (or equivalent) on the target system: C<targetsh>.
1321
1322 For example, Android has its sh in /system/bin/sh, so if cross-compiling
1323 from a more normal Unixy system with sh in /bin/sh, "targetsh" would end
1324 up as /system/bin/sh, and "sh" as /bin/sh.
1325
1326 =item *
1327
1328 By default, B<gcc> 4.9 does some optimizations that break perl.  The B<-fwrapv>
1329 option disables those optimizations (and probably others), so for B<gcc> 4.3
1330 and later (since the there might be similar problems lurking on older versions
1331 too, but B<-fwrapv> was broken before 4.3, and the optimizations probably won't
1332 go away), F<Configure> now adds B<-fwrapv> unless the user requests
1333 B<-fno-wrapv>, which disables B<-fwrapv>, or B<-fsanitize=undefined>, which
1334 turns the overflows B<-fwrapv> ignores into runtime errors.
1335 [L<perl #121505|https://rt.perl.org/Public/Bug/Display.html?id=121505>]
1336
1337 =back
1338
1339 =head1 Testing
1340
1341 =over 4
1342
1343 =item *
1344
1345 The C<test.valgrind> make target now allows tests to be run in parallel.
1346 This target allows Perl's test suite to be run under Valgrind, which detects
1347 certain sorts of C programming errors, though at significant cost in running
1348 time. On suitable hardware, allowing parallel execution claws back a lot of
1349 that additional cost. [perl #121431]
1350
1351 =item *
1352
1353 Various tests in F<t/porting/> are no longer skipped when the perl
1354 F<.git> directory is outside the perl tree and pointed to by
1355 C<$GIT_DIR>. [perl #120505]
1356
1357 =item *
1358
1359 The test suite no longer fails when the user's interactive shell maintains a
1360 C<$PWD> environment variable, but the F</bin/sh> used for running tests
1361 doesn't.
1362
1363 =back
1364
1365 =head1 Platform Support
1366
1367 =head2 New Platforms
1368
1369 =over 4
1370
1371 =item Android
1372
1373 Perl can now be built for Android, either natively or through
1374 cross-compilation, for all three currently available architectures (ARM,
1375 MIPS, and x86), on a wide range of versions.
1376
1377 =item Bitrig
1378
1379 Compile support has been added for Bitrig, a fork of OpenBSD.
1380
1381 =item FreeMiNT
1382
1383 Support has been added for FreeMiNT, a free open-source OS for the Atari ST
1384 system and its successors, based on the original MiNT that was officially
1385 adopted by Atari.
1386
1387 =item Synology
1388
1389 Synology ships its NAS boxes with a lean Linux distribution (DSM) on relative
1390 cheap CPU's (like the Marvell Kirkwood mv6282 - ARMv5tel or Freescale QorIQ
1391 P1022 ppc - e500v2) not meant for workstations or development. These boxes
1392 should build now. The basic problems are the non-standard location for tools.
1393
1394 =back
1395
1396 =head2 Discontinued Platforms
1397
1398 =over 4
1399
1400 =item C<sfio>
1401
1402 Code related to supporting the C<sfio> I/O system has been removed.
1403
1404 Perl 5.004 added support to use the native API of C<sfio>, AT&T's Safe/Fast
1405 I/O library. This code still built with v5.8.0, albeit with many regression
1406 tests failing, but was inadvertently broken before the v5.8.1 release,
1407 meaning that it has not worked on any version of Perl released since then.
1408 In over a decade we have received no bug reports about this, hence it is clear
1409 that no-one is using this functionality on any version of Perl that is still
1410 supported to any degree.
1411
1412 =item AT&T 3b1
1413
1414 Configure support for the 3b1, also known as the AT&T Unix PC (and the similar
1415 AT&T 7300), has been removed.
1416
1417 =item DG/UX
1418
1419 DG/UX was a Unix sold by Data General. The last release was in April 2001.
1420 It only runs on Data General's own hardware.
1421
1422 =back
1423
1424 =head2 Platform-Specific Notes
1425
1426 =over 4
1427
1428 =item Cygwin
1429
1430 =over 4
1431
1432 =item *
1433
1434 recv() on a connected handle would populate the returned sender
1435 address with whatever happened to be in the working buffer.  recv()
1436 now uses a workaround similar to the Win32 recv() wrapper and returns
1437 an empty string when recvfrom(2) doesn't modify the supplied address
1438 length. [perl #118843]
1439
1440 =item *
1441
1442 Fixed a build error in cygwin.c on Cygwin 1.7.28.
1443
1444 Tests now handle the errors that occur when C<cygserver> isn't
1445 running.
1446
1447 =back
1448
1449 =item GNU/Hurd
1450
1451 The BSD compatibility library C<libbsd> is no longer required for builds.
1452
1453 =item Linux
1454
1455 The hints file now looks for C<libgdbm_compat> only if C<libgdbm> itself is
1456 also wanted. The former is never useful without the latter, and in some
1457 circumstances, including it could actually prevent building.
1458
1459 =item Mac OS
1460
1461 The build system now honours an C<ld> setting supplied by the user running
1462 F<Configure>.
1463
1464 =item MidnightBSD
1465
1466 C<objformat> was removed from version 0.4-RELEASE of MidnightBSD and had been
1467 deprecated on earlier versions.  This caused the build environment to be
1468 erroneously configured for C<a.out> rather than C<elf>.  This has been now
1469 been corrected.
1470
1471 =item Mixed-endian platforms
1472
1473 The code supporting C<pack> and C<unpack> operations on mixed endian
1474 platforms has been removed. We believe that Perl has long been unable to
1475 build on mixed endian architectures (such as PDP-11s), so we don't think
1476 that this change will affect any platforms which were able to build v5.18.0.
1477
1478 =item VMS
1479
1480 =over 4
1481
1482 =item *
1483
1484 The C<PERL_ENV_TABLES> feature to control the population of %ENV at perl
1485 start-up was broken in Perl 5.16.0 but has now been fixed.
1486
1487 =item *
1488
1489 Skip access checks on remotes in opendir().  [perl #121002]
1490
1491 =item *
1492
1493 A check for glob metacharacters in a path returned by the
1494 L<C<glob()>|perlfunc/glob> operator has been replaced with a check for VMS
1495 wildcard characters.  This saves a significant number of unnecessary
1496 L<C<lstat()>|perlfunc/lstat> calls such that some simple glob operations become
1497 60-80% faster.
1498
1499 =back
1500
1501 =item Win32
1502
1503 =over 4
1504
1505 =item *
1506
1507 C<rename> and C<link> on Win32 now set $! to ENOSPC and EDQUOT when
1508 appropriate.  [perl #119857]
1509
1510 =item *
1511
1512 The BUILD_STATIC and ALL_STATIC makefile options for linking some or (nearly)
1513 all extensions statically (into perl520.dll, and into a separate
1514 perl-static.exe too) were broken for MinGW builds. This has now been fixed.
1515
1516 The ALL_STATIC option has also been improved to include the Encode and Win32
1517 extensions (for both VC++ and MinGW builds).
1518
1519 =item *
1520
1521 Support for building with Visual C++ 2013 has been added.  There are currently
1522 two possible test failures (see L<perlwin32/"Testing Perl on Windows">) which
1523 will hopefully be resolved soon.
1524
1525 =item *
1526
1527 Experimental support for building with Intel C++ Compiler has been added.  The
1528 nmake makefile (win32/Makefile) and the dmake makefile (win32/makefile.mk) can
1529 be used.  A "nmake test" will not pass at this time due to F<cpan/CGI/t/url.t>.
1530
1531 =item *
1532
1533 Killing a process tree with L<perlfunc/kill> and a negative signal, was broken
1534 starting in 5.18.0. In this bug, C<kill> always returned 0 for a negative
1535 signal even for valid PIDs, and no processes were terminated. This has been
1536 fixed [perl #121230].
1537
1538 =item *
1539
1540 The time taken to build perl on Windows has been reduced quite significantly
1541 (time savings in the region of 30-40% are typically seen) by reducing the
1542 number of, usually failing, I/O calls for each L<C<require()>|perlfunc/require>
1543 (for B<miniperl.exe> only).
1544 [L<perl #121119|https://rt.perl.org/Public/Bug/Display.html?id=121119>]
1545
1546 =item *
1547
1548 About 15 minutes of idle sleeping was removed from running C<make test> due to
1549 a bug in which the timeout monitor used for tests could not be cancelled once
1550 the test completes, and the full timeout period elapsed before running the next
1551 test file.
1552 [L<perl #121395|https://rt.perl.org/Public/Bug/Display.html?id=121395>]
1553
1554 =item *
1555
1556 On a perl built without pseudo-fork (pseudo-fork builds were not affected by
1557 this bug), killing a process tree with L<C<kill()>|perlfunc/kill> and a negative
1558 signal resulted in C<kill()> inverting the returned value.  For example, if
1559 C<kill()> killed 1 process tree PID then it returned 0 instead of 1, and if
1560 C<kill()> was passed 2 invalid PIDs then it returned 2 instead of 0.  This has
1561 probably been the case since the process tree kill feature was implemented on
1562 Win32.  It has now been corrected to follow the documented behaviour.
1563 [L<perl #121230|https://rt.perl.org/Public/Bug/Display.html?id=121230>]
1564
1565 =item *
1566
1567 When building a 64-bit perl, an uninitialized memory read in B<miniperl.exe>,
1568 used during the build process, could lead to a 4GB B<wperl.exe> being created.
1569 This has now been fixed.  (Note that B<perl.exe> itself was unaffected, but
1570 obviously B<wperl.exe> would have been completely broken.)
1571 [L<perl #121471|https://rt.perl.org/Public/Bug/Display.html?id=121471>]
1572
1573 =item *
1574
1575 Perl can now be built with B<gcc> version 4.8.1 from L<http://www.mingw.org>.
1576 This was previously broken due to an incorrect definition of DllMain() in one
1577 of perl's source files.  Earlier B<gcc> versions were also affected when using
1578 version 4 of the w32api package.  Versions of B<gcc> available from
1579 L<http://mingw-w64.sourceforge.net/> were not affected.
1580 [L<perl #121643|https://rt.perl.org/Public/Bug/Display.html?id=121643>]
1581
1582 =item *
1583
1584 The test harness now has no failures when perl is built on a FAT drive with the
1585 Windows OS on an NTFS drive.
1586 [L<perl #21442|https://rt.perl.org/Public/Bug/Display.html?id=21442>]
1587
1588 =item *
1589
1590 When cloning the context stack in fork() emulation, Perl_cx_dup()
1591 would crash accessing parameter information for context stack entries
1592 that included no parameters, as with C<&foo;>.
1593 [L<perl #121721|https://rt.perl.org/Public/Bug/Display.html?id=121721>]
1594
1595 =back
1596
1597 =item WinCE
1598
1599 =over 4
1600
1601 =item *
1602
1603 The building of XS modules has largely been restored.  Several still cannot
1604 (yet) be built but it is now possible to build Perl on WinCE with only a couple
1605 of further patches (to L<Socket> and L<ExtUtils::MakeMaker>), hopefully to be
1606 incorporated soon.
1607
1608 =item *
1609
1610 Perl can now be built in one shot with no user intervention on WinCE by running
1611 C<nmake -f Makefile.ce all>.
1612
1613 Support for building with EVC (Embedded Visual C++) 4 has been restored.  Perl
1614 can also be built using Smart Devices for Visual C++ 2005 or 2008.
1615
1616 =back
1617
1618 =back
1619
1620 =head1 Internal Changes
1621
1622 =over 4
1623
1624 =item *
1625
1626 The internal representation has changed for the match variables $1, $2 etc.,
1627 $`, $&, $', ${^PREMATCH}, ${^MATCH} and ${^POSTMATCH}.  It uses slightly less
1628 memory, avoids string comparisons and numeric conversions during lookup, and
1629 uses 23 fewer lines of C.  This change should not affect any external code.
1630
1631 =item *
1632
1633 Arrays now use NULL internally to represent unused slots, instead of
1634 &PL_sv_undef.  &PL_sv_undef is no longer treated as a special value, so
1635 av_store(av, 0, &PL_sv_undef) will cause element 0 of that array to hold a
1636 read-only undefined scalar.  C<$array[0] = anything> will croak and
1637 C<\$array[0]> will compare equal to C<\undef>.
1638
1639 =item *
1640
1641 The SV returned by HeSVKEY_force() now correctly reflects the UTF8ness of the
1642 underlying hash key when that key is not stored as a SV.  [perl #79074]
1643
1644 =item *
1645
1646 Certain rarely used functions and macros available to XS code are now
1647 deprecated.  These are:
1648 C<utf8_to_uvuni_buf> (use C<utf8_to_uvchr_buf> instead),
1649 C<valid_utf8_to_uvuni> (use C<utf8_to_uvchr_buf> instead),
1650 C<NATIVE_TO_NEED> (this did not work properly anyway),
1651 and C<ASCII_TO_NEED>  (this did not work properly anyway).
1652
1653 Starting in this release, almost never does application code need to
1654 distinguish between the platform's character set and Latin1, on which the
1655 lowest 256 characters of Unicode are based.  New code should not use
1656 C<utf8n_to_uvuni> (use C<utf8_to_uvchr_buf> instead),
1657 nor
1658 C<uvuni_to_utf8> (use C<uvchr_to_utf8> instead),
1659
1660 =item *
1661
1662 The Makefile shortcut targets for many rarely (or never) used testing and
1663 profiling targets have been removed, or merged into the only other Makefile
1664 target that uses them.  Specifically, these targets are gone, along with
1665 documentation that referenced them or explained how to use them:
1666
1667     check.third check.utf16 check.utf8 coretest minitest.prep
1668     minitest.utf16 perl.config.dashg perl.config.dashpg
1669     perl.config.gcov perl.gcov perl.gprof perl.gprof.config
1670     perl.pixie perl.pixie.atom perl.pixie.config perl.pixie.irix
1671     perl.third perl.third.config perl.valgrind.config purecovperl
1672     pureperl quantperl test.deparse test.taintwarn test.third
1673     test.torture test.utf16 test.utf8 test_notty.deparse
1674     test_notty.third test_notty.valgrind test_prep.third
1675     test_prep.valgrind torturetest ucheck ucheck.third ucheck.utf16
1676     ucheck.valgrind utest utest.third utest.utf16 utest.valgrind
1677
1678 It's still possible to run the relevant commands by "hand" - no underlying
1679 functionality has been removed.
1680
1681 =item *
1682
1683 It is now possible to keep Perl from initializing locale handling.
1684 For the most part, Perl doesn't pay attention to locale.  (See
1685 L<perllocale>.)  Nonetheless, until now, on startup, it has always
1686 initialized locale handling to the system default, just in case the
1687 program being executed ends up using locales.  (This is one of the first
1688 things a locale-aware program should do, long before Perl knows if it
1689 will actually be needed or not.)  This works well except when Perl is
1690 embedded in another application which wants a locale that isn't the
1691 system default.  Now, if the environment variable
1692 C<PERL_SKIP_LOCALE_INIT> is set at the time Perl is started, this
1693 initialization step is skipped.  Prior to this, on Windows platforms,
1694 the only workaround for this deficiency was to use a hacked-up copy of
1695 internal Perl code.  Applications that need to use older Perls can
1696 discover if the embedded Perl they are using needs the workaround by
1697 testing that the C preprocessor symbol C<HAS_SKIP_LOCALE_INIT> is not
1698 defined.  (RT #38193)
1699
1700 =item *
1701
1702 C<BmRARE> and C<BmPREVIOUS> have been removed.  They were not used anywhere
1703 and are not part of the API.  For XS modules, they are now #defined as 0.
1704
1705 =item *
1706
1707 C<sv_force_normal>, which usually croaks on read-only values, used to allow
1708 read-only values to be modified at compile time.  This has been changed to
1709 croak on read-only values regardless.  This change uncovered several core
1710 bugs.
1711
1712 =item *
1713
1714 Perl's new copy-on-write mechanism  (which is now enabled by default),
1715 allows any C<SvPOK> scalar to be automatically upgraded to a copy-on-write
1716 scalar when copied. A reference count on the string buffer is stored in
1717 the string buffer itself.
1718
1719 For example:
1720
1721     $ perl -MDevel::Peek -e'$a="abc"; $b = $a; Dump $a; Dump $b'
1722     SV = PV(0x260cd80) at 0x2620ad8
1723       REFCNT = 1
1724       FLAGS = (POK,IsCOW,pPOK)
1725       PV = 0x2619bc0 "abc"\0
1726       CUR = 3
1727       LEN = 16
1728       COW_REFCNT = 1
1729     SV = PV(0x260ce30) at 0x2620b20
1730       REFCNT = 1
1731       FLAGS = (POK,IsCOW,pPOK)
1732       PV = 0x2619bc0 "abc"\0
1733       CUR = 3
1734       LEN = 16
1735       COW_REFCNT = 1
1736
1737 Note that both scalars share the same PV buffer and have a COW_REFCNT
1738 greater than zero.
1739
1740 This means that XS code which wishes to modify the C<SvPVX()> buffer of an
1741 SV should call C<SvPV_force()> or similar first, to ensure a valid (and
1742 unshared) buffer, and to call C<SvSETMAGIC()> afterwards. This in fact has
1743 always been the case (for example hash keys were already copy-on-write);
1744 this change just spreads the COW behaviour to a wider variety of SVs.
1745
1746 One important difference is that before 5.18.0, shared hash-key scalars
1747 used to have the C<SvREADONLY> flag set; this is no longer the case.
1748
1749 This new behaviour can still be disabled by running F<Configure> with
1750 B<-Accflags=-DPERL_NO_COW>.  This option will probably be removed in Perl
1751 5.22.
1752
1753 =item *
1754
1755 C<PL_sawampersand> is now a constant.  The switch this variable provided
1756 (to enable/disable the pre-match copy depending on whether C<$&> had been
1757 seen) has been removed and replaced with copy-on-write, eliminating a few
1758 bugs.
1759
1760 The previous behaviour can still be enabled by running F<Configure> with
1761 B<-Accflags=-DPERL_SAWAMPERSAND>.
1762
1763 =item *
1764
1765 The functions C<my_swap>, C<my_htonl> and C<my_ntohl> have been removed.
1766 It is unclear why these functions were ever marked as I<A>, part of the
1767 API. XS code can't call them directly, as it can't rely on them being
1768 compiled. Unsurprisingly, no code on CPAN references them.
1769
1770 =item *
1771
1772 The signature of the C<Perl_re_intuit_start()> regex function has changed;
1773 the function pointer C<intuit> in the regex engine plugin structure
1774 has also changed accordingly. A new parameter, C<strbeg> has been added;
1775 this has the same meaning as the same-named parameter in
1776 C<Perl_regexec_flags>. Previously intuit would try to guess the start of
1777 the string from the passed SV (if any), and would sometimes get it wrong
1778 (e.g. with an overloaded SV).
1779
1780 =item *
1781
1782 XS code may use various macros to change the case of a character or code
1783 point (for example C<toLOWER_utf8()>).  Only a couple of these were
1784 documented until now;
1785 and now they should be used in preference to calling the underlying
1786 functions.  See L<perlapi/Character case changing>.
1787
1788 =item *
1789
1790 The code dealt rather inconsistently with uids and gids. Some
1791 places assumed that they could be safely stored in UVs, others
1792 in IVs, others in ints. Four new macros are introduced:
1793 SvUID(), sv_setuid(), SvGID(), and sv_setgid()
1794
1795 =item *
1796
1797 C<sv_pos_b2u_flags> has been added to the API.  It is similar to C<sv_pos_b2u>,
1798 but supports long strings on 64-bit platforms.
1799
1800 =item *
1801
1802 C<PL_exit_flags> can now be used by perl embedders or other XS code to have
1803 perl C<warn> or C<abort> on an attempted exit. [perl #52000]
1804
1805 =item *
1806
1807 Compiling with C<-Accflags=-PERL_BOOL_AS_CHAR> now allows C99 and C++
1808 compilers to emulate the aliasing of C<bool> to C<char> that perl does for
1809 C89 compilers.  [perl #120314]
1810
1811 =item *
1812
1813 The C<sv> argument in L<perlapi/sv_2pv_flags>, L<perlapi/sv_2iv_flags>,
1814 L<perlapi/sv_2uv_flags>, and L<perlapi/sv_2nv_flags> and their older wrappers
1815 sv_2pv, sv_2iv, sv_2uv, sv_2nv, is now non-NULL. Passing NULL now will crash.
1816 When the non-NULL marker was introduced en masse in 5.9.3 the functions
1817 were marked non-NULL, but since the creation of the SV API in 5.0 alpha 2, if
1818 NULL was passed, the functions returned 0 or false-type values. The code that
1819 supports C<sv> argument being non-NULL dates to 5.0 alpha 2 directly, and
1820 indirectly to Perl 1.0 (pre 5.0 api). The lack of documentation that the
1821 functions accepted a NULL C<sv> was corrected in 5.11.0 and between 5.11.0
1822 and 5.19.5 the functions were marked NULLOK. As an optimization the NULLOK code
1823 has now been removed, and the functions became non-NULL marked again, because
1824 core getter-type macros never pass NULL to these functions and would crash
1825 before ever passing NULL.
1826
1827 The only way a NULL C<sv> can be passed to sv_2*v* functions is if XS code
1828 directly calls sv_2*v*. This is unlikely as XS code uses Sv*V* macros to get
1829 the underlying value out of the SV. One possible situation which leads to
1830 a NULL C<sv> being passed to sv_2*v* functions, is if XS code defines its own
1831 getter type Sv*V* macros, which check for NULL B<before> dereferencing and
1832 checking the SV's flags through public API Sv*OK* macros or directly using
1833 private API C<SvFLAGS>, and if C<sv> is NULL, then calling the sv_2*v functions
1834 with a NULL litteral or passing the C<sv> containing a NULL value.
1835
1836 =item *
1837
1838 newATTRSUB is now a macro
1839
1840 The public API newATTRSUB was previously a macro to the private
1841 function Perl_newATTRSUB. Function Perl_newATTRSUB has been removed. newATTRSUB
1842 is now macro to a different internal function.
1843
1844 =item *
1845
1846 Changes in warnings raised by C<utf8n_to_uvchr()>
1847
1848 This bottom level function decodes the first character of a UTF-8 string
1849 into a code point.  It is accessible to C<XS> level code, but it's
1850 discouraged from using it directly.  There are higher level functions
1851 that call this that should be used instead, such as
1852 L<perlapi/utf8_to_uvchr_buf>.  For completeness though, this documents
1853 some changes to it.  Now, tests for malformations are done before any
1854 tests for other potential issues.  One of those issues involves code
1855 points so large that they have never appeared in any official standard
1856 (the current standard has scaled back the highest acceptable code point
1857 from earlier versions).  It is possible (though not done in CPAN) to
1858 warn and/or forbid these code points, while accepting smaller code
1859 points that are still above the legal Unicode maximum.  The warning
1860 message for this now includes the code point if representable on the
1861 machine.  Previously it always displayed raw bytes, which is what it
1862 still does for non-representable code points.
1863
1864 =item *
1865
1866 Regexp Engine Changes That Affect The Pluggable Regex Engine Interface
1867
1868 Many flags that used to be exposed via regexp.h and used to populate the
1869 extflags member of struct regexp have been removed. These fields were
1870 technically private to Perl's own regexp engine and should not have been
1871 exposed there in the first place.
1872
1873 The affected flags are:
1874
1875     RXf_NOSCAN
1876     RXf_CANY_SEEN
1877     RXf_GPOS_SEEN
1878     RXf_GPOS_FLOAT
1879     RXf_ANCH_BOL
1880     RXf_ANCH_MBOL
1881     RXf_ANCH_SBOL
1882     RXf_ANCH_GPOS
1883
1884 As well as the follow flag masks:
1885
1886     RXf_ANCH_SINGLE
1887     RXf_ANCH
1888
1889 All have been renamed to PREGf_ equivalents and moved to regcomp.h.
1890
1891 The behavior previously achieved by setting one or more of the RXf_ANCH_
1892 flags (via the RXf_ANCH mask) have now been replaced by a *single* flag bit
1893 in extflags:
1894
1895     RXf_IS_ANCHORED
1896
1897 pluggable regex engines which previously used to set these flags should
1898 now set this flag ALONE.
1899
1900 =item *
1901
1902 The Perl core now consistently uses C<av_tindex()> ("the top index of an
1903 array") as a more clearly-named synonym for C<av_len()>.
1904
1905 =item *
1906
1907 The obscure interpreter variable C<PL_timesbuf> is expected to be removed
1908 early in the 5.21.x development series, so that Perl 5.22.0 will not provide
1909 it to XS authors.  While the variable still exists in 5.20.0), we hope that
1910 this advance warning of the deprecation will help anyone who is using that
1911 variable.
1912
1913 =back
1914
1915 =head1 Selected Bug Fixes
1916
1917 =head2 Regular Expressions
1918
1919 =over 4
1920
1921 =item *
1922
1923 Fixed a small number of regexp constructions that could either fail to
1924 match or crash perl when the string being matched against was
1925 allocated above the 2GB line on 32-bit systems. [RT #118175]
1926
1927 =item *
1928
1929 Various memory leaks involving the parsing of the C<(?[...])> regular
1930 expression construct have been fixed.
1931
1932 =item *
1933
1934 C<(?[...])> now allows interpolation of precompiled patterns consisting of
1935 C<(?[...])> with bracketed character classes inside (C<$pat =
1936 S<qr/(?[ [a] ])/;> S</(?[ $pat ])/>>).  Formerly, the brackets would
1937 confuse the regular expression parser.
1938
1939 =item *
1940
1941 The "Quantifier unexpected on zero-length expression" warning message could
1942 appear twice starting in Perl v5.10 for a regular expression also
1943 containing alternations (e.g., "a|b") triggering the trie optimisation.
1944
1945 =item *
1946
1947 Perl v5.18 inadvertently introduced a bug whereby interpolating mixed up-
1948 and down-graded UTF-8 strings in a regex could result in malformed UTF-8
1949 in the pattern: specifically if a downgraded character in the range
1950 C<\x80..\xff> followed a UTF-8 string, e.g.
1951
1952     utf8::upgrade(  my $u = "\x{e5}");
1953     utf8::downgrade(my $d = "\x{e5}");
1954     /$u$d/
1955
1956 [RT #118297]
1957
1958 =item *
1959
1960 In regular expressions containing multiple code blocks, the values of
1961 C<$1>, C<$2>, etc., set by nested regular expression calls would leak from
1962 one block to the next.  Now these variables always refer to the outer
1963 regular expression at the start of an embedded block [perl #117917].
1964
1965 =item *
1966
1967 C</$qr/p> was broken in Perl 5.18.0; the C</p> flag was ignored.  This has been
1968 fixed. [perl #118213]
1969
1970 =item *
1971
1972 Starting in Perl 5.18.0, a construct like C</[#](?{})/x> would have its C<#>
1973 incorrectly interpreted as a comment.  The code block would be skipped,
1974 unparsed.  This has been corrected.
1975
1976 =item *
1977
1978 Starting in Perl 5.001, a regular expression like C</[#$a]/x> or C</[#]$a/x>
1979 would have its C<#> incorrectly interpreted as a comment, so the variable would
1980 not interpolate.  This has been corrected. [perl #45667]
1981
1982 =item *
1983
1984 Perl 5.18.0 inadvertently made dereferenced regular expressions
1985 S<(C<${ qr// }>)> false as booleans.  This has been fixed.
1986
1987 =item *
1988
1989 The use of C<\G> in regular expressions, where it's not at the start of the
1990 pattern, is now slightly less buggy (although it is still somewhat
1991 problematic).
1992
1993 =item *
1994
1995 Where a regular expression included code blocks (C</(?{...})/>), and where the
1996 use of constant overloading triggered a re-compilation of the code block, the
1997 second compilation didn't see its outer lexical scope.  This was a regression
1998 in Perl 5.18.0.
1999
2000 =item *
2001
2002 The string position set by C<pos> could shift if the string changed
2003 representation internally to or from utf8.  This could happen, e.g., with
2004 references to objects with string overloading.
2005
2006 =item *
2007
2008 Taking references to the return values of two C<pos> calls with the same
2009 argument, and then assigning a reference to one and C<undef> to the other,
2010 could result in assertion failures or memory leaks.
2011
2012 =item *
2013
2014 Elements of @- and @+ now update correctly when they refer to non-existent
2015 captures.  Previously, a referenced element (C<$ref = \$-[1]>) could refer to
2016 the wrong match after subsequent matches.
2017
2018 =item *
2019
2020 The code that parses regex backrefs (or ambiguous backref/octals) such as \123
2021 did a simple atoi(), which could wrap round to negative values on long digit
2022 strings and cause segmentation faults.  This has now been fixed.  [perl
2023 #119505]
2024
2025 =item *
2026
2027 Assigning another typeglob to C<*^R> no longer makes the regular expression
2028 engine crash.
2029
2030 =item *
2031
2032 The C<\N> regular expression escape, when used without the curly braces (to
2033 mean C<[^\n]>), was ignoring a following C<*> if followed by whitespace
2034 under /x.  It had been this way since C<\N> to mean C<[^\n]> was introduced
2035 in 5.12.0.
2036
2037 =item *
2038
2039 C<s///>, C<tr///> and C<y///> now work when a wide character is used as the
2040 delimiter.  [perl #120463]
2041
2042 =item *
2043
2044 Some cases of unterminated (?...) sequences in regular expressions (e.g.,
2045 C</(?</>) have been fixed to produce the proper error message instead of
2046 "panic: memory wrap".  Other cases (e.g., C</(?(/>) have yet to be fixed.
2047
2048 =item *
2049
2050 When a reference to a reference to an overloaded object was returned from
2051 a regular expression C<(??{...})> code block, an incorrect implicit
2052 dereference could take place if the inner reference had been returned by
2053 a code block previously.
2054
2055 =item *
2056
2057 A tied variable returned from C<(??{...})> sees the inner values of match
2058 variables (i.e., the $1 etc. from any matches inside the block) in its
2059 FETCH method.  This was not the case if a reference to an overloaded object
2060 was the last thing assigned to the tied variable.  Instead, the match
2061 variables referred to the outer pattern during the FETCH call.
2062
2063 =item *
2064
2065 Fix unexpected tainting via regexp using locale. Previously, under certain
2066 conditions, the use of character classes could cause tainting when it
2067 shouldn't. Some character classes are locale-dependent, but before this
2068 patch, sometimes tainting was happening even for character classes that
2069 don't depend on the locale. [perl #120675]
2070
2071 =item *
2072
2073 Under certain conditions, Perl would throw an error if in an lookbehind
2074 assertion in a regexp, the assertion referred to a named subpattern,
2075 complaining the lookbehind was variable when it wasn't. This has been
2076 fixed. [perl #120600], [perl #120618]. The current fix may be improved
2077 on in the future.
2078
2079 =item *
2080
2081 C<$^R> wasn't available outside of the regular expression that
2082 initialized it.  [perl #121070]
2083
2084 =item *
2085
2086 A large set of fixes and refactoring for re_intuit_start() was merged,
2087 the highlights are:
2088
2089 =over
2090
2091 =item *
2092
2093 Fixed a panic when compiling the regular expression
2094 C</\x{100}[xy]\x{100}{2}/>.
2095
2096 =item *
2097
2098 Fixed a performance regression when performing a global pattern match
2099 against a UTF-8 string.  [perl #120692]
2100
2101 =item *
2102
2103 Fixed another performance issue where matching a regular expression
2104 like C</ab.{1,2}x/> against a long UTF-8 string would unnecessarily
2105 calculate byte offsets for a large portion of the string. [perl
2106 #120692]
2107
2108 =back
2109
2110 =item *
2111
2112 Fixed an alignment error when compiling regular expressions when built
2113 with GCC on HP-UX 64-bit.
2114
2115 =item *
2116
2117 On 64-bit platforms C<pos> can now be set to a value higher than 2**31-1.
2118 [perl #72766]
2119
2120 =back
2121
2122 =head2 Perl 5 Debugger and -d
2123
2124 =over 4
2125
2126 =item *
2127
2128 The debugger's C<man> command been fixed. It was broken in the v5.18.0
2129 release. The C<man> command is aliased to the names C<doc> and C<perldoc> -
2130 all now work again.
2131
2132 =item *
2133
2134 C<@_> is now correctly visible in the debugger, fixing a regression
2135 introduced in v5.18.0's debugger. [RT #118169]
2136
2137 =item *
2138
2139 Under copy-on-write builds (the default as of 5.20.0) C<< ${'_<-e'}[0] >>
2140 no longer gets mangled.  This is the first line of input saved for the
2141 debugger's use for one-liners [perl #118627].
2142
2143 =item *
2144
2145 On non-threaded builds, setting C<${"_E<lt>filename"}> to a reference or
2146 typeglob no longer causes C<__FILE__> and some error messages to produce a
2147 corrupt string, and no longer prevents C<#line> directives in string evals from
2148 providing the source lines to the debugger.  Threaded builds were unaffected.
2149
2150 =item *
2151
2152 Starting with Perl 5.12, line numbers were off by one if the B<-d> switch was
2153 used on the #! line.  Now they are correct.
2154
2155 =item *
2156
2157 C<*DB::DB = sub {} if 0> no longer stops Perl's debugging mode from finding
2158 C<DB::DB> subs declared thereafter.
2159
2160 =item *
2161
2162 C<%{'_<...'}> hashes now set breakpoints on the corresponding C<@{'_<...'}>
2163 rather than whichever array C<@DB::dbline> is aliased to.  [perl #119799]
2164
2165 =item *
2166
2167 Call set-magic when setting $DB::sub.  [perl #121255]
2168
2169 =item *
2170
2171 The debugger's "n" command now respects lvalue subroutines and steps over
2172 them [perl #118839].
2173
2174 =back
2175
2176 =head2 Lexical Subroutines
2177
2178 =over 4
2179
2180 =item *
2181
2182 Lexical constants (C<my sub a() { 42 }>) no longer crash when inlined.
2183
2184 =item *
2185
2186 Parameter prototypes attached to lexical subroutines are now respected when
2187 compiling sub calls without parentheses.  Previously, the prototypes were
2188 honoured only for calls I<with> parentheses. [RT #116735]
2189
2190 =item *
2191
2192 Syntax errors in lexical subroutines in combination with calls to the same
2193 subroutines no longer cause crashes at compile time.
2194
2195 =item *
2196
2197 Deep recursion warnings no longer crash lexical subroutines. [RT #118521]
2198
2199 =item *
2200
2201 The dtrace sub-entry probe now works with lexical subs, instead of
2202 crashing [perl #118305].
2203
2204 =item *
2205
2206 Undefining an inlinable lexical subroutine (C<my sub foo() { 42 } undef
2207 &foo>) would result in a crash if warnings were turned on.
2208
2209 =item *
2210
2211 An undefined lexical sub used as an inherited method no longer crashes.
2212
2213 =item *
2214
2215 The presence of a lexical sub named "CORE" no longer stops the CORE::
2216 prefix from working.
2217
2218 =back
2219
2220 =head2 Everything Else
2221
2222 =over 4
2223
2224 =item *
2225
2226 The OP allocation code now returns correctly aligned memory in all cases
2227 for C<struct pmop>. Previously it could return memory only aligned to a
2228 4-byte boundary, which is not correct for an ithreads build with 64 bit IVs
2229 on some 32 bit platforms. Notably, this caused the build to fail completely
2230 on sparc GNU/Linux. [RT #118055]
2231
2232 =item *
2233
2234 Evaluating large hashes in scalar context is now much faster, as the number
2235 of used chains in the hash is now cached for larger hashes. Smaller hashes
2236 continue not to store it and calculate it when needed, as this saves one IV.
2237 That would be 1 IV overhead for every object built from a hash. [RT #114576]
2238
2239 =item *
2240
2241 Perl v5.16 inadvertently introduced a bug whereby calls to XSUBs that were
2242 not visible at compile time were treated as lvalues and could be assigned
2243 to, even when the subroutine was not an lvalue sub.  This has been fixed.
2244 [RT #117947]
2245
2246 =item *
2247
2248 In Perl v5.18.0 dualvars that had an empty string for the string part but a
2249 non-zero number for the number part starting being treated as true.  In
2250 previous versions they were treated as false, the string representation
2251 taking precedeence.  The old behaviour has been restored. [RT #118159]
2252
2253 =item *
2254
2255 Since Perl v5.12, inlining of constants that override built-in keywords of
2256 the same name had countermanded C<use subs>, causing subsequent mentions of
2257 the constant to use the built-in keyword instead.  This has been fixed.
2258
2259 =item *
2260
2261 The warning produced by C<-l $handle> now applies to IO refs and globs, not
2262 just to glob refs.  That warning is also now UTF8-clean. [RT #117595]
2263
2264 =item *
2265
2266 C<delete local $ENV{nonexistent_env_var}> no longer leaks memory.
2267
2268 =item *
2269
2270 C<sort> and C<require> followed by a keyword prefixed with C<CORE::> now
2271 treat it as a keyword, and not as a subroutine or module name. [RT #24482]
2272
2273 =item *
2274
2275 Through certain conundrums, it is possible to cause the current package to
2276 be freed.  Certain operators (C<bless>, C<reset>, C<open>, C<eval>) could
2277 not cope and would crash.  They have been made more resilient. [RT #117941]
2278
2279 =item *
2280
2281 Aliasing filehandles through glob-to-glob assignment would not update
2282 internal method caches properly if a package of the same name as the
2283 filehandle existed, resulting in filehandle method calls going to the
2284 package instead.  This has been fixed.
2285
2286 =item *
2287
2288 C<./Configure -de -Dusevendorprefix> didn't default [RT #64126]
2289
2290 =item *
2291
2292 The C<Statement unlikely to be reached> warning was listed in
2293 L<perldiag> as an C<exec>-category warning, but was enabled and disabled
2294 by the C<syntax> category.  On the other hand, the C<exec> category
2295 controlled its fatal-ness.  It is now entirely handled by the C<exec>
2296 category.
2297
2298 =item *
2299
2300 The "Replacement list is longer that search list" warning for C<tr///> and
2301 C<y///> no longer occurs in the presence of the C</c> flag. [RT #118047]
2302
2303 =item *
2304
2305 Stringification of NVs are not cached so that the lexical locale controls
2306 stringification of the decimal point [perl #108378] [perl #115800]
2307
2308 =item *
2309
2310 There have been several fixes related to Perl's handling of locales.  perl
2311 #38193 was described above in L</Internal Changes>.
2312 Also fixed is 
2313 #118197, where the radix (decimal point) character had to be an ASCII
2314 character (which doesn't work for some non-Western languages);
2315 and #115808, in which C<POSIX::setlocale()> on failure returned an
2316 C<undef> which didn't warn about not being defined even if those
2317 warnings were enabled.
2318
2319 =item *
2320
2321 Compiling a C<split> operator whose third argument is a named constant
2322 evaulating to 0 no longer causes the constant's value to change.
2323
2324 =item *
2325
2326 A named constant used as the second argument to C<index> no longer gets
2327 coerced to a string if it is a reference, regular expression, dualvar, etc.
2328
2329 =item *
2330
2331 A named constant evaluating to the undefined value used as the second
2332 argument to C<index> no longer produces "uninitialized" warnings at compile
2333 time.  It will still produce them at run time.
2334
2335 =item *
2336
2337 When a scalar was returned from a subroutine in @INC, the referenced scalar
2338 was magically converted into an IO thingy, possibly resulting in "Bizarre
2339 copy" errors if that scalar continued to be used elsewhere.  Now Perl uses
2340 an internal copy of the scalar instead.
2341
2342 =item *
2343
2344 Certain uses of the C<sort> operator are optimised to modify an array in
2345 place, such as C<@a = sort @a>.  During the sorting, the array is made
2346 read-only.  If a sort block should happen to die, then the array remained
2347 read-only even outside the C<sort>.  This has been fixed.
2348
2349 =item *
2350
2351 C<$a> and C<$b> inside a sort block are aliased to the actual arguments to
2352 C<sort>, so they can be modified through those two variables.  This did not
2353 always work, e.g., for lvalue subs and C<$#ary>, and probably many other
2354 operators.  It works now.
2355
2356 =item *
2357
2358 The arguments to C<sort> are now all in list context.  If the C<sort>
2359 itself were called in void or scalar context, then I<some>, but not all, of
2360 the arguments used to be in void or scalar context.
2361
2362 =item *
2363
2364 Subroutine prototypes with Unicode characters above U+00FF were getting
2365 mangled during closure cloning.  This would happen with subroutines closing
2366 over lexical variables declared outside, and with lexical subs.
2367
2368 =item *
2369
2370 C<UNIVERSAL::can> now treats its first argument the same way that method
2371 calls do: Typeglobs and glob references with non-empty IO slots are treated
2372 as handles, and strings are treated as filehandles, rather than packages,
2373 if a handle with that name exists [perl #113932].
2374
2375 =item *
2376
2377 Method calls on typeglobs (e.g., C<< *ARGV->getline >>) used to stringify
2378 the typeglob and then look it up again.  Combined with changes in Perl
2379 5.18.0, this allowed C<< *foo->bar >> to call methods on the "foo" package
2380 (like C<< foo->bar >>).  In some cases it could cause the method to be
2381 called on the wrong handle.  Now a typeglob argument is treated as a
2382 handle (just like C<< (\*foo)->bar >>), or, if its IO slot is empty, an
2383 error is raised.
2384
2385 =item *
2386
2387 Assigning a vstring to a tied variable or to a subroutine argument aliased
2388 to a nonexistent hash or array element now works, without flattening the
2389 vstring into a regular string.
2390
2391 =item *
2392
2393 C<pos>, C<tie>, C<tied> and C<untie> did not work
2394 properly on subroutine arguments aliased to nonexistent
2395 hash and array elements [perl #77814, #27010].
2396
2397 =item *
2398
2399 The C<< => >> fat arrow operator can now quote built-in keywords even if it
2400 occurs on the next line, making it consistent with how it treats other
2401 barewords.
2402
2403 =item *
2404
2405 Autovivifying a subroutine stub via C<\&$glob> started causing crashes in Perl
2406 5.18.0 if the $glob was merely a copy of a real glob, i.e., a scalar that had
2407 had a glob assigned to it.  This has been fixed. [perl #119051]
2408
2409 =item *
2410
2411 Perl used to leak an implementation detail when it came to referencing the
2412 return values of certain operators.  C<for ($a+$b) { warn \$_; warn \$_ }> used
2413 to display two different memory addresses, because the C<\> operator was
2414 copying the variable.  Under threaded builds, it would also happen for
2415 constants (C<for(1) { ... }>).  This has been fixed. [perl #21979, #78194,
2416 #89188, #109746, #114838, #115388]
2417
2418 =item *
2419
2420 The range operator C<..> was returning the same modifiable scalars with each
2421 call, unless it was the only thing in a C<foreach> loop header.  This meant
2422 that changes to values within the list returned would be visible the next time
2423 the operator was executed. [perl #3105]
2424
2425 =item *
2426
2427 Constant folding and subroutine inlining no longer cause operations that would
2428 normally return new modifiable scalars to return read-only values instead.
2429
2430 =item *
2431
2432 Closures of the form C<sub () { $some_variable }> are no longer inlined,
2433 causing changes to the variable to be ignored by callers of the subroutine.
2434 [perl #79908]
2435
2436 =item *
2437
2438 Return values of certain operators such as C<ref> would sometimes be shared
2439 between recursive calls to the same subroutine, causing the inner call to
2440 modify the value returned by C<ref> in the outer call.  This has been fixed.
2441
2442 =item *
2443
2444 C<__PACKAGE__> and constants returning a package name or hash key are now
2445 consistently read-only.  In various previous Perl releases, they have become
2446 mutable under certain circumstances.
2447
2448 =item *
2449
2450 Enabling "used once" warnings no longer causes crashes on stash circularities
2451 created at compile time (C<*Foo::Bar::Foo:: = *Foo::>).
2452
2453 =item *
2454
2455 Undef constants used in hash keys (C<use constant u =E<gt> undef; $h{+u}>) no
2456 longer produce "uninitialized" warnings at compile time.
2457
2458 =item *
2459
2460 Modifying a substitution target inside the substitution replacement no longer
2461 causes crashes.
2462
2463 =item *
2464
2465 The first statement inside a string eval used to use the wrong pragma setting
2466 sometimes during constant folding.  C<eval 'uc chr 0xe0'> would randomly choose
2467 between Unicode, byte, and locale semantics.  This has been fixed.
2468
2469 =item *
2470
2471 The handling of return values of @INC filters (subroutines returned by
2472 subroutines in @INC) has been fixed in various ways.  Previously tied variables
2473 were mishandled, and setting $_ to a reference or typeglob could result in
2474 crashes.
2475
2476 =item *
2477
2478 The C<SvPVbyte> XS function has been fixed to work with tied scalars returning
2479 something other than a string.  It used to return utf8 in those cases where
2480 C<SvPV> would.
2481
2482 =item *
2483
2484 Perl 5.18.0 inadvertently made C<--> and C<++> crash on dereferenced regular
2485 expressions, and stopped C<++> from flattening vstrings.
2486
2487 =item *
2488
2489 C<bless> no longer dies with "Can't bless non-reference value" if its first
2490 argument is a tied reference.
2491
2492 =item *
2493
2494 C<reset> with an argument no longer skips copy-on-write scalars, regular
2495 expressions, typeglob copies, and vstrings.  Also, when encountering those or
2496 read-only values, it no longer skips any array or hash with the same name.
2497
2498 =item *
2499
2500 C<reset> with an argument now skips scalars aliased to typeglobs
2501 (C<for $z (*foo) { reset "z" }>).  Previously it would corrupt memory or crash.
2502
2503 =item *
2504
2505 C<ucfirst> and C<lcfirst> were not respecting the bytes pragma.  This was a
2506 regression from Perl 5.12. [perl #117355]
2507
2508 =item *
2509
2510 Changes to C<UNIVERSAL::DESTROY> now update DESTROY caches in all classes,
2511 instead of causing classes that have already had objects destroyed to continue
2512 using the old sub.  This was a regression in Perl 5.18. [perl #114864]
2513
2514 =item *
2515
2516 All known false-positive occurrences of the deprecation warning "Useless use of
2517 '\'; doesn't escape metacharacter '%c'", added in Perl 5.18.0, have been
2518 removed. [perl #119101]
2519
2520 =item *
2521
2522 The value of $^E is now saved across signal handlers on Windows.  [perl #85104]
2523
2524 =item *
2525
2526 A lexical filehandle (as in C<open my $fh...>) is usually given a name based on
2527 the current package and the name of the variable, e.g. "main::$fh".  Under
2528 recursion, the filehandle was losing the "$fh" part of the name.  This has been
2529 fixed.
2530
2531 =item *
2532
2533 Uninitialized values returned by XSUBs are no longer exempt from uninitialized
2534 warnings.  [perl #118693]
2535
2536 =item *
2537
2538 C<elsif ("")> no longer erroneously produces a warning about void context.
2539 [perl #118753]
2540
2541 =item *
2542
2543 Passing C<undef> to a subroutine now causes @_ to contain the same read-only
2544 undefined scalar that C<undef> returns.  Furthermore, C<exists $_[0]> will now
2545 return true if C<undef> was the first argument.  [perl #7508, #109726]
2546
2547 =item *
2548
2549 Passing a non-existent array element to a subroutine does not usually
2550 autovivify it unless the subroutine modifies its argument.  This did not work
2551 correctly with negative indices and with non-existent elements within the
2552 array.  The element would be vivified immediately.  The delayed vivification
2553 has been extended to work with those.  [perl #118691]
2554
2555 =item *
2556
2557 Assigning references or globs to the scalar returned by $#foo after the @foo
2558 array has been freed no longer causes assertion failures on debugging builds
2559 and memory leaks on regular builds.
2560
2561 =item *
2562
2563 On 64-bit platforms, large ranges like 1..1000000000000 no longer crash, but
2564 eat up all your memory instead.  [perl #119161]
2565
2566 =item *
2567
2568 C<__DATA__> now puts the C<DATA> handle in the right package, even if the
2569 current package has been renamed through glob assignment.
2570
2571 =item *
2572
2573 When C<die>, C<last>, C<next>, C<redo>, C<goto> and C<exit> unwind the scope,
2574 it is possible for C<DESTROY> recursively to call a subroutine or format that
2575 is currently being exited.  It that case, sometimes the lexical variables
2576 inside the sub would start out having values from the outer call, instead of
2577 being undefined as they should.  This has been fixed.  [perl #119311]
2578
2579 =item *
2580
2581 ${^MPEN} is no longer treated as a synonym for ${^MATCH}.
2582
2583 =item *
2584
2585 Perl now tries a little harder to return the correct line number in
2586 C<(caller)[2]>.  [perl #115768]
2587
2588 =item *
2589
2590 Line numbers inside multiline quote-like operators are now reported correctly.
2591 [perl #3643]
2592
2593 =item *
2594
2595 C<#line> directives inside code embedded in quote-like operators are now
2596 respected.
2597
2598 =item *
2599
2600 Line numbers are now correct inside the second here-doc when two here-doc
2601 markers occur on the same line.
2602
2603 =item *
2604
2605 An optimization in Perl 5.18 made incorrect assumptions causing a bad
2606 interaction with the L<Devel::CallParser> CPAN module.  If the module was
2607 loaded then lexical variables declared in separate statements following a
2608 C<my(...)> list might fail to be cleared on scope exit.
2609
2610 =item *
2611
2612 C<&xsub> and C<goto &xsub> calls now allow the called subroutine to autovivify
2613 elements of @_.
2614
2615 =item *
2616
2617 C<&xsub> and C<goto &xsub> no longer crash if *_ has been undefined and has no
2618 ARRAY entry (i.e. @_ does not exist).
2619
2620 =item *
2621
2622 C<&xsub> and C<goto &xsub> now work with tied @_.
2623
2624 =item *
2625
2626 Overlong identifiers no longer cause a buffer overflow (and a crash).  They
2627 started doing so in Perl 5.18.
2628
2629 =item *
2630
2631 The warning "Scalar value @hash{foo} better written as $hash{foo}" now produces
2632 far fewer false positives.  In particular, C<@hash{+function_returning_a_list}>
2633 and C<@hash{ qw "foo bar baz" }> no longer warn.  The same applies to array
2634 slices.  [perl #28380, #114024]
2635
2636 =item *
2637
2638 C<$! = EINVAL; waitpid(0, WNOHANG);> no longer goes into an internal infinite
2639 loop.  [perl #85228]
2640
2641 =item *
2642
2643 A possible segmentation fault in filehandle duplication has been fixed.
2644
2645 =item *
2646
2647 A subroutine in @INC can return a reference to a scalar containing the initial
2648 contents of the file.  However, that scalar was freed prematurely if not
2649 referenced elsewhere, giving random results.
2650
2651 =item *
2652
2653 C<last> no longer returns values that the same statement has accumulated so
2654 far, fixing amongst other things the long-standing bug that C<push @a, last>
2655 would try to return the @a, copying it like a scalar in the process and
2656 resulting in the error, "Bizarre copy of ARRAY in last."  [perl #3112]
2657
2658 =item *
2659
2660 In some cases, closing file handles opened to pipe to or from a process, which
2661 had been duplicated into a standard handle, would call perl's internal waitpid
2662 wrapper with a pid of zero.  With the fix for [perl #85228] this zero pid was
2663 passed to C<waitpid>, possibly blocking the process.  This wait for process
2664 zero no longer occurs.  [perl #119893]
2665
2666 =item *
2667
2668 C<select> used to ignore magic on the fourth (timeout) argument, leading to
2669 effects such as C<select> blocking indefinitely rather than the expected sleep
2670 time.  This has now been fixed.  [perl #120102]
2671
2672 =item *
2673
2674 The class name in C<for my class $foo> is now parsed correctly.  In the case of
2675 the second character of the class name being followed by a digit (e.g. 'a1b')
2676 this used to give the error "Missing $ on loop variable".  [perl #120112]
2677
2678 =item *
2679
2680 Perl 5.18.0 accidentally disallowed C<-bareword> under C<use strict> and
2681 C<use integer>.  This has been fixed.  [perl #120288]
2682
2683 =item *
2684
2685 C<-a> at the start of a line (or a hyphen with any single letter that is
2686 not a filetest operator) no longer produces an erroneous 'Use of "-a"
2687 without parentheses is ambiguous' warning.  [perl #120288]
2688
2689 =item *
2690
2691 Lvalue context is now properly propagated into bare blocks and C<if> and
2692 C<else> blocks in lvalue subroutines.  Previously, arrays and hashes would
2693 sometimes incorrectly be flattened when returned in lvalue list context, or
2694 "Bizarre copy" errors could occur.  [perl #119797]
2695
2696 =item *
2697
2698 Lvalue context is now propagated to the branches of C<||> and C<&&> (and
2699 their alphabetic equivalents, C<or> and C<and>).  This means
2700 C<foreach (pos $x || pos $y) {...}> now allows C<pos> to be modified
2701 through $_.
2702
2703 =item *
2704
2705 C<stat> and C<readline> remember the last handle used; the former
2706 for the special C<_> filehandle, the latter for C<${^LAST_FH}>.
2707 C<eval "*foo if 0"> where *foo was the last handle passed to C<stat>
2708 or C<readline> could cause that handle to be forgotten if the
2709 handle were not opened yet.  This has been fixed.
2710
2711 =item *
2712
2713 Various cases of C<delete $::{a}>, C<delete $::{ENV}> etc. causing a crash
2714 have been fixed.  [perl #54044]
2715
2716 =item *
2717
2718 Setting C<$!> to EACCESS before calling C<require> could affect
2719 C<require>'s behaviour.  This has been fixed.
2720
2721 =item *
2722
2723 The "Can't use \1 to mean $1 in expression" warning message now only occurs
2724 on the right-hand (replacement) part of a substitution.  Formerly it could
2725 happen in code embedded in the left-hand side, or in any other quote-like
2726 operator.
2727
2728 =item *
2729
2730 Blessing into a reference (C<bless $thisref, $thatref>) has long been
2731 disallowed, but magical scalars for the second like C<$/> and those tied
2732 were exempt.  They no longer are.  [perl #119809]
2733
2734 =item *
2735
2736 Blessing into a reference was accidentally allowed in 5.18 if the class
2737 argument were a blessed reference with stale method caches (i.e., whose
2738 class had had subs defined since the last method call).  They are
2739 disallowed once more, as in 5.16.
2740
2741 =item *
2742
2743 C<< $x->{key} >> where $x was declared as C<my Class $x> no longer crashes
2744 if a Class::FIELDS subroutine stub has been declared.
2745
2746 =item *
2747
2748 C<@$obj{'key'}> and C<${$obj}{key}> used to be exempt from compile-time
2749 field checking ("No such class field"; see L<fields>) but no longer are.
2750
2751 =item *
2752
2753 A nonexistent array element with a large index passed to a subroutine that
2754 ties the array and then tries to access the element no longer results in a
2755 crash.
2756
2757 =item *
2758
2759 Declaring a subroutine stub named NEGATIVE_INDICES no longer makes negative
2760 array indices crash when the current package is a tied array class.
2761
2762 =item *
2763
2764 Declaring a C<require>, C<glob>, or C<do> subroutine stub in the
2765 CORE::GLOBAL:: package no longer makes compilation of calls to the
2766 corresponding functions crash.
2767
2768 =item *
2769
2770 Aliasing CORE::GLOBAL:: functions to constants stopped working in Perl 5.10
2771 but has now been fixed.
2772
2773 =item *
2774
2775 When C<`...`> or C<qx/.../> calls a C<readpipe> override, double-quotish
2776 interpolation now happens, as is the case when there is no override.
2777 Previously, the presence of an override would make these quote-like
2778 operators act like C<q{}>, suppressing interpolation.  [perl #115330]
2779
2780 =item *
2781
2782 C<<<<`...`> here-docs (with backticks as the delimiters) now call
2783 C<readpipe> overrides.  [perl #119827]
2784
2785 =item *
2786
2787 C<&CORE::exit()> and C<&CORE::die()> now respect L<vmsish> hints.
2788
2789 =item *
2790
2791 Undefining a glob that triggers a DESTROY method that undefines the same
2792 glob is now safe.  It used to produce "Attempt to free unreferenced glob
2793 pointer" warnings and leak memory.
2794
2795 =item *
2796
2797 If subroutine redefinition (C<eval 'sub foo{}'> or C<newXS> for XS code)
2798 triggers a DESTROY method on the sub that is being redefined, and that
2799 method assigns a subroutine to the same slot (C<*foo = sub {}>), C<$_[0]>
2800 is no longer left pointing to a freed scalar.  Now DESTROY is delayed until
2801 the new subroutine has been installed.
2802
2803 =item *
2804
2805 On Windows, perl no longer calls CloseHandle() on a socket handle.  This makes
2806 debugging easier on Windows by removing certain irrelevant bad handle
2807 exceptions.  It also fixes a race condition that made socket functions randomly
2808 fail in a Perl process with multiple OS threads, and possible test failures in
2809 F<dist/IO/t/cachepropagate-tcp.t>.  [perl #120091/118059]
2810
2811 =item *
2812
2813 Strange vars like ties, overloads, or stringified refs (and in recent
2814 perls, pure NOK vars) would generally do the wrong thing in formats
2815 when the var is treated as a string and repeatedly chopped, as in
2816 C<< ^<<<~~ >> and similar. This has now been resolved.
2817
2818 =item *
2819
2820 C<< semctl(..., SETVAL, ...) >> would set the semaphore to the top
2821 32-bits of the supplied integer instead of the bottom 32-bits on
2822 64-bit big-endian systems. [perl #120635]
2823
2824 =item *
2825
2826 C<< readdir() >> now only sets C<$!> on error.  C<$!> is no longer set
2827 to C<EBADF> when then terminating C<undef> is read from the directory
2828 unless the system call sets C<$!>. [perl #118651]
2829
2830 =item *
2831
2832 C<&CORE::glob> no longer causes an intermittent crash due to perl's stack
2833 getting corrupted. [perl #119993]
2834
2835 =item *
2836
2837 C<open> with layers that load modules (e.g., "<:encoding(utf8)") no longer
2838 runs the risk of crashing due to stack corruption.
2839
2840 =item *
2841
2842 Perl 5.18 broke autoloading via C<< ->SUPER::foo >> method calls by looking
2843 up AUTOLOAD from the current package rather than the current package's
2844 superclass.  This has been fixed. [perl #120694]
2845
2846 =item *
2847
2848 A longstanding bug causing C<do {} until CONSTANT>, where the constant
2849 holds a true value, to read unallocated memory has been resolved.  This
2850 would usually happen after a syntax error.  In past versions of Perl it has
2851 crashed intermittently. [perl #72406]
2852
2853 =item *
2854
2855 Fix HP-UX C<$!> failure. HP-UX strerror() returns an empty string for an
2856 unknown error code.  This caused an assertion to fail under DEBUGGING
2857 builds.  Now instead, the returned string for C<"$!"> contains text
2858 indicating the code is for an unknown error.
2859
2860 =item *
2861
2862 Individually-tied elements of @INC (as in C<tie $INC[0]...>) are now
2863 handled correctly.  Formerly, whether a sub returned by such a tied element
2864 would be treated as a sub depended on whether a FETCH had occurred
2865 previously.
2866
2867 =item *
2868
2869 C<getc> on a byte-sized handle after the same C<getc> operator had been
2870 used on a utf8 handle used to treat the bytes as utf8, resulting in erratic
2871 behavior (e.g., malformed UTF-8 warnings).
2872
2873 =item *
2874
2875 An initial C<{> at the beginning of a format argument line was always
2876 interpreted as the beginning of a block prior to v5.18.  In Perl v5.18, it
2877 started being treated as an ambiguous token.  The parser would guess
2878 whether it was supposed to be an anonymous hash constructor or a block
2879 based on the contents.  Now the previous behavious has been restored.
2880 [perl #119973]
2881
2882 =item *
2883
2884 In Perl v5.18 C<undef *_; goto &sub> and C<local *_; goto &sub> started
2885 crashing.  This has been fixed. [perl #119949]
2886
2887 =item *
2888
2889 Backticks (C< `` > or C< qx// >) combined with multiple threads on
2890 Win32 could result in output sent to stdout on one thread being
2891 captured by backticks of an external command in another thread.
2892
2893 This could occur for pseudo-forked processes too, as Win32's
2894 pseudo-fork is implemented in terms of threads.  [perl #77672]
2895
2896 =item *
2897
2898 C<< open $fh, ">+", undef >> no longer leaks memory when TMPDIR is set
2899 but points to a directory a temporary file cannot be created in.  [perl
2900 #120951]
2901
2902 =item *
2903
2904 C< for ( $h{k} || '' ) > no longer auto-vivifies C<$h{k}>.  [perl
2905 #120374]
2906
2907 =item *
2908
2909 On Windows machines, Perl now emulates the POSIX use of the environment
2910 for locale initialization.  Previously, the environment was ignored.
2911 See L<perllocale/ENVIRONMENT>.
2912
2913 =item *
2914
2915 Fixed a crash when destroying a self-referencing GLOB.  [perl #121242]
2916
2917 =back
2918
2919 =head1 Known Problems
2920
2921 =over 4
2922
2923 =item *
2924
2925 The following modules are known to have test failures with this version of
2926 Perl.  Patches have been submitted, so there will hopefully be new releases
2927 soon:
2928
2929 XXX Go through this list just before the release of 5.20 and remove any
2930 modules that have been fixed.
2931
2932 =over
2933
2934 =item *
2935
2936 L<Data::Structure::Util> version 0.15
2937
2938 =item *
2939
2940 L<Data::Util> version 0.62
2941
2942 =item *
2943
2944 L<HTML::StripScripts> version 1.05
2945
2946 =item *
2947
2948 L<LaTeX::Encode> version 0.08
2949
2950 =item *
2951
2952 L<Mail::SpamAssassin> version 3.3.2
2953
2954 =item *
2955
2956 L<RDF::Trine>.  The test failures are actually due to a bug in
2957 L<XML::LibXML> version 2.0108.  A patch to XML::LibXML has been submitted.
2958
2959 =back
2960
2961 =back
2962
2963 =head1 Acknowledgements
2964
2965 XXX Generate this with:
2966
2967   perl Porting/acknowledgements.pl v5.19.12..HEAD
2968
2969 =head1 Reporting Bugs
2970
2971 If you find what you think is a bug, you might check the articles recently
2972 posted to the comp.lang.perl.misc newsgroup and the perl bug database at
2973 http://rt.perl.org/perlbug/ .  There may also be information at
2974 http://www.perl.org/ , the Perl Home Page.
2975
2976 If you believe you have an unreported bug, please run the L<perlbug> program
2977 included with your release.  Be sure to trim your bug down to a tiny but
2978 sufficient test case.  Your bug report, along with the output of C<perl -V>,
2979 will be sent off to perlbug@perl.org to be analysed by the Perl porting team.
2980
2981 If the bug you are reporting has security implications, which make it
2982 inappropriate to send to a publicly archived mailing list, then please send it
2983 to perl5-security-report@perl.org.  This points to a closed subscription
2984 unarchived mailing list, which includes all the core committers, who will be
2985 able to help assess the impact of issues, figure out a resolution, and help
2986 co-ordinate the release of patches to mitigate or fix the problem across all
2987 platforms on which Perl is supported.  Please only use this address for
2988 security issues in the Perl core, not for modules independently distributed on
2989 CPAN.
2990
2991 =head1 SEE ALSO
2992
2993 The F<Changes> file for an explanation of how to view exhaustive details on
2994 what changed.
2995
2996 The F<INSTALL> file for how to build Perl.
2997
2998 The F<README> file for general stuff.
2999
3000 The F<Artistic> and F<Copying> files for copyright information.
3001
3002 =cut