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