1PERL5220DELTA(1)       Perl Programmers Reference Guide       PERL5220DELTA(1)
2
3
4

NAME

6       perl5220delta - what is new for perl v5.22.0
7

DESCRIPTION

9       This document describes differences between the 5.20.0 release and the
10       5.22.0 release.
11
12       If you are upgrading from an earlier release such as 5.18.0, first read
13       perl5200delta, which describes differences between 5.18.0 and 5.20.0.
14

Core Enhancements

16   New bitwise operators
17       A new experimental facility has been added that makes the four standard
18       bitwise operators ("& | ^ ~") treat their operands consistently as
19       numbers, and introduces four new dotted operators ("&. |. ^. ~.") that
20       treat their operands consistently as strings.  The same applies to the
21       assignment variants ("&= |= ^= &.= |.= ^.=").
22
23       To use this, enable the "bitwise" feature and disable the
24       "experimental::bitwise" warnings category.  See "Bitwise String
25       Operators" in perlop for details.  [perl #123466]
26       <https://rt.perl.org/Ticket/Display.html?id=123466>.
27
28   New double-diamond operator
29       "<<>>" is like "<>" but uses three-argument "open" to open each file in
30       @ARGV.  This means that each element of @ARGV will be treated as an
31       actual file name, and "|foo" won't be treated as a pipe open.
32
33   New "\b" boundaries in regular expressions
34       "qr/\b{gcb}/"
35
36       "gcb" stands for Grapheme Cluster Boundary.  It is a Unicode property
37       that finds the boundary between sequences of characters that look like
38       a single character to a native speaker of a language.  Perl has long
39       had the ability to deal with these through the "\X" regular escape
40       sequence.  Now, there is an alternative way of handling these.  See
41       "\b{}, \b, \B{}, \B" in perlrebackslash for details.
42
43       "qr/\b{wb}/"
44
45       "wb" stands for Word Boundary.  It is a Unicode property that finds the
46       boundary between words.  This is similar to the plain "\b" (without
47       braces) but is more suitable for natural language processing.  It
48       knows, for example, that apostrophes can occur in the middle of words.
49       See "\b{}, \b, \B{}, \B" in perlrebackslash for details.
50
51       "qr/\b{sb}/"
52
53       "sb" stands for Sentence Boundary.  It is a Unicode property to aid in
54       parsing natural language sentences.  See "\b{}, \b, \B{}, \B" in
55       perlrebackslash for details.
56
57   Non-Capturing Regular Expression Flag
58       Regular expressions now support a "/n" flag that disables capturing and
59       filling in $1, $2, etc inside of groups:
60
61         "hello" =~ /(hi|hello)/n; # $1 is not set
62
63       This is equivalent to putting "?:" at the beginning of every capturing
64       group.
65
66       See "n" in perlre for more information.
67
68   "use re 'strict'"
69       This applies stricter syntax rules to regular expression patterns
70       compiled within its scope. This will hopefully alert you to typos and
71       other unintentional behavior that backwards-compatibility issues
72       prevent us from reporting in normal regular expression compilations.
73       Because the behavior of this is subject to change in future Perl
74       releases as we gain experience, using this pragma will raise a warning
75       of category "experimental::re_strict".  See 'strict' in re.
76
77   Unicode 7.0 (with correction) is now supported
78       For details on what is in this release, see
79       <http://www.unicode.org/versions/Unicode7.0.0/>.  The version of
80       Unicode 7.0 that comes with Perl includes a correction dealing with
81       glyph shaping in Arabic (see
82       <http://www.unicode.org/errata/#current_errata>).
83
84   "use locale" can restrict which locale categories are affected
85       It is now possible to pass a parameter to "use locale" to specify a
86       subset of locale categories to be locale-aware, with the remaining ones
87       unaffected.  See "The "use locale" pragma" in perllocale for details.
88
89   Perl now supports POSIX 2008 locale currency additions
90       On platforms that are able to handle POSIX.1-2008, the hash returned by
91       "POSIX::localeconv()" includes the international currency fields added
92       by that version of the POSIX standard.  These are "int_n_cs_precedes",
93       "int_n_sep_by_space", "int_n_sign_posn", "int_p_cs_precedes",
94       "int_p_sep_by_space", and "int_p_sign_posn".
95
96   Better heuristics on older platforms for determining locale UTF-8ness
97       On platforms that implement neither the C99 standard nor the POSIX 2001
98       standard, determining if the current locale is UTF-8 or not depends on
99       heuristics.  These are improved in this release.
100
101   Aliasing via reference
102       Variables and subroutines can now be aliased by assigning to a
103       reference:
104
105           \$c = \$d;
106           \&x = \&y;
107
108       Aliasing can also be accomplished by using a backslash before a
109       "foreach" iterator variable; this is perhaps the most useful idiom this
110       feature provides:
111
112           foreach \%hash (@array_of_hash_refs) { ... }
113
114       This feature is experimental and must be enabled via
115       "use feature 'refaliasing'".  It will warn unless the
116       "experimental::refaliasing" warnings category is disabled.
117
118       See "Assigning to References" in perlref
119
120   "prototype" with no arguments
121       "prototype()" with no arguments now infers $_.  [perl #123514]
122       <https://rt.perl.org/Ticket/Display.html?id=123514>.
123
124   New ":const" subroutine attribute
125       The "const" attribute can be applied to an anonymous subroutine.  It
126       causes the new sub to be executed immediately whenever one is created
127       (i.e. when the "sub" expression is evaluated).  Its value is captured
128       and used to create a new constant subroutine that is returned.  This
129       feature is experimental.  See "Constant Functions" in perlsub.
130
131   "fileno" now works on directory handles
132       When the relevant support is available in the operating system, the
133       "fileno" builtin now works on directory handles, yielding the
134       underlying file descriptor in the same way as for filehandles. On
135       operating systems without such support, "fileno" on a directory handle
136       continues to return the undefined value, as before, but also sets $! to
137       indicate that the operation is not supported.
138
139       Currently, this uses either a "dd_fd" member in the OS "DIR" structure,
140       or a dirfd(3) function as specified by POSIX.1-2008.
141
142   List form of pipe open implemented for Win32
143       The list form of pipe:
144
145         open my $fh, "-|", "program", @arguments;
146
147       is now implemented on Win32.  It has the same limitations as "system
148       LIST" on Win32, since the Win32 API doesn't accept program arguments as
149       a list.
150
151   Assignment to list repetition
152       "(...) x ..." can now be used within a list that is assigned to, as
153       long as the left-hand side is a valid lvalue.  This allows
154       "(undef,undef,$foo) = that_function()" to be written as
155       "((undef)x2, $foo) = that_function()".
156
157   Infinity and NaN (not-a-number) handling improved
158       Floating point values are able to hold the special values infinity,
159       negative infinity, and NaN (not-a-number).  Now we more robustly
160       recognize and propagate the value in computations, and on output
161       normalize them to the strings "Inf", "-Inf", and "NaN".
162
163       See also the POSIX enhancements.
164
165   Floating point parsing has been improved
166       Parsing and printing of floating point values has been improved.
167
168       As a completely new feature, hexadecimal floating point literals (like
169       "0x1.23p-4")  are now supported, and they can be output with
170       "printf "%a"". See "Scalar value constructors" in perldata for more
171       details.
172
173   Packing infinity or not-a-number into a character is now fatal
174       Before, when trying to pack infinity or not-a-number into a (signed)
175       character, Perl would warn, and assumed you tried to pack 0xFF; if you
176       gave it as an argument to "chr", "U+FFFD" was returned.
177
178       But now, all such actions ("pack", "chr", and "print '%c'") result in a
179       fatal error.
180
181   Experimental C Backtrace API
182       Perl now supports (via a C level API) retrieving the C level backtrace
183       (similar to what symbolic debuggers like gdb do).
184
185       The backtrace returns the stack trace of the C call frames, with the
186       symbol names (function names), the object names (like "perl"), and if
187       it can, also the source code locations (file:line).
188
189       The supported platforms are Linux and OS X (some *BSD might work at
190       least partly, but they have not yet been tested).
191
192       The feature needs to be enabled with "Configure -Dusecbacktrace".
193
194       See "C backtrace" in perlhacktips for more information.
195

Security

197   Perl is now compiled with "-fstack-protector-strong" if available
198       Perl has been compiled with the anti-stack-smashing option
199       "-fstack-protector" since 5.10.1.  Now Perl uses the newer variant
200       called "-fstack-protector-strong", if available.
201
202   The Safe module could allow outside packages to be replaced
203       Critical bugfix: outside packages could be replaced.  Safe has been
204       patched to 2.38 to address this.
205
206   Perl is now always compiled with "-D_FORTIFY_SOURCE=2" if available
207       The 'code hardening' option called "_FORTIFY_SOURCE", available in gcc
208       4.*, is now always used for compiling Perl, if available.
209
210       Note that this isn't necessarily a huge step since in many platforms
211       the step had already been taken several years ago: many Linux
212       distributions (like Fedora) have been using this option for Perl, and
213       OS X has enforced the same for many years.
214

Incompatible Changes

216   Subroutine signatures moved before attributes
217       The experimental sub signatures feature, as introduced in 5.20, parsed
218       signatures after attributes. In this release, following feedback from
219       users of the experimental feature, the positioning has been moved such
220       that signatures occur after the subroutine name (if any) and before the
221       attribute list (if any).
222
223   "&" and "\&" prototypes accepts only subs
224       The "&" prototype character now accepts only anonymous subs ("sub
225       {...}"), things beginning with "\&", or an explicit "undef".  Formerly
226       it erroneously also allowed references to arrays, hashes, and lists.
227       [perl #4539] <https://rt.perl.org/Ticket/Display.html?id=4539>.  [perl
228       #123062] <https://rt.perl.org/Ticket/Display.html?id=123062>.  [perl
229       #123062] <https://rt.perl.org/Ticket/Display.html?id=123475>.
230
231       In addition, the "\&" prototype was allowing subroutine calls, whereas
232       now it only allows subroutines: &foo is still permitted as an argument,
233       while "&foo()" and "foo()" no longer are.  [perl #77860]
234       <https://rt.perl.org/Ticket/Display.html?id=77860>.
235
236   "use encoding" is now lexical
237       The encoding pragma's effect is now limited to lexical scope.  This
238       pragma is deprecated, but in the meantime, it could adversely affect
239       unrelated modules that are included in the same program; this change
240       fixes that.
241
242   List slices returning empty lists
243       List slices now return an empty list only if the original list was
244       empty (or if there are no indices).  Formerly, a list slice would
245       return an empty list if all indices fell outside the original list; now
246       it returns a list of "undef" values in that case.  [perl #114498]
247       <https://rt.perl.org/Ticket/Display.html?id=114498>.
248
249   "\N{}" with a sequence of multiple spaces is now a fatal error
250       E.g. "\N{TOO  MANY SPACES}" or "\N{TRAILING SPACE }".  This has been
251       deprecated since v5.18.
252
253   "use UNIVERSAL '...'" is now a fatal error
254       Importing functions from "UNIVERSAL" has been deprecated since v5.12,
255       and is now a fatal error.  "use UNIVERSAL" without any arguments is
256       still allowed.
257
258   In double-quotish "\cX", X must now be a printable ASCII character
259       In prior releases, failure to do this raised a deprecation warning.
260
261   Splitting the tokens "(?" and "(*" in regular expressions is now a fatal
262       compilation error.
263       These had been deprecated since v5.18.
264
265   "qr/foo/x" now ignores all Unicode pattern white space
266       The "/x" regular expression modifier allows the pattern to contain
267       white space and comments (both of which are ignored) for improved
268       readability.  Until now, not all the white space characters that
269       Unicode designates for this purpose were handled.  The additional ones
270       now recognized are:
271
272           U+0085 NEXT LINE
273           U+200E LEFT-TO-RIGHT MARK
274           U+200F RIGHT-TO-LEFT MARK
275           U+2028 LINE SEPARATOR
276           U+2029 PARAGRAPH SEPARATOR
277
278       The use of these characters with "/x" outside bracketed character
279       classes and when not preceded by a backslash has raised a deprecation
280       warning since v5.18.  Now they will be ignored.
281
282   Comment lines within "(?[ ])" are now ended only by a "\n"
283       "(?[ ])"  is an experimental feature, introduced in v5.18.  It operates
284       as if "/x" is always enabled.  But there was a difference: comment
285       lines (following a "#" character) were terminated by anything matching
286       "\R" which includes all vertical whitespace, such as form feeds.  For
287       consistency, this is now changed to match what terminates comment lines
288       outside "(?[ ])", namely a "\n" (even if escaped), which is the same as
289       what terminates a heredoc string and formats.
290
291   "(?[...])" operators now follow standard Perl precedence
292       This experimental feature allows set operations in regular expression
293       patterns.  Prior to this, the intersection operator had the same
294       precedence as the other binary operators.  Now it has higher
295       precedence.  This could lead to different outcomes than existing code
296       expects (though the documentation has always noted that this change
297       might happen, recommending fully parenthesizing the expressions).  See
298       "Extended Bracketed Character Classes" in perlrecharclass.
299
300   Omitting "%" and "@" on hash and array names is no longer permitted
301       Really old Perl let you omit the "@" on array names and the "%" on hash
302       names in some spots.  This has issued a deprecation warning since Perl
303       5.000, and is no longer permitted.
304
305   "$!" text is now in English outside the scope of "use locale"
306       Previously, the text, unlike almost everything else, always came out
307       based on the current underlying locale of the program.  (Also affected
308       on some systems is "$^E".)  For programs that are unprepared to handle
309       locale differences, this can cause garbage text to be displayed.  It's
310       better to display text that is translatable via some tool than garbage
311       text which is much harder to figure out.
312
313   "$!" text will be returned in UTF-8 when appropriate
314       The stringification of $! and $^E will have the UTF-8 flag set when the
315       text is actually non-ASCII UTF-8.  This will enable programs that are
316       set up to be locale-aware to properly output messages in the user's
317       native language.  Code that needs to continue the 5.20 and earlier
318       behavior can do the stringification within the scopes of both
319       "use bytes" and "use locale ":messages"".  Within these two scopes, no
320       other Perl operations will be affected by locale; only $! and $^E
321       stringification.  The "bytes" pragma causes the UTF-8 flag to not be
322       set, just as in previous Perl releases.  This resolves [perl #112208]
323       <https://rt.perl.org/Ticket/Display.html?id=112208>.
324
325   Support for "?PATTERN?" without explicit operator has been removed
326       The "m?PATTERN?" construct, which allows matching a regex only once,
327       previously had an alternative form that was written directly with a
328       question mark delimiter, omitting the explicit "m" operator.  This
329       usage has produced a deprecation warning since 5.14.0.  It is now a
330       syntax error, so that the question mark can be available for use in new
331       operators.
332
333   "defined(@array)" and "defined(%hash)" are now fatal errors
334       These have been deprecated since v5.6.1 and have raised deprecation
335       warnings since v5.16.
336
337   Using a hash or an array as a reference are now fatal errors
338       For example, "%foo->{"bar"}" now causes a fatal compilation error.
339       These have been deprecated since before v5.8, and have raised
340       deprecation warnings since then.
341
342   Changes to the "*" prototype
343       The "*" character in a subroutine's prototype used to allow barewords
344       to take precedence over most, but not all, subroutine names.  It was
345       never consistent and exhibited buggy behavior.
346
347       Now it has been changed, so subroutines always take precedence over
348       barewords, which brings it into conformity with similarly prototyped
349       built-in functions:
350
351           sub splat(*) { ... }
352           sub foo { ... }
353           splat(foo); # now always splat(foo())
354           splat(bar); # still splat('bar') as before
355           close(foo); # close(foo())
356           close(bar); # close('bar')
357

Deprecations

359   Setting "${^ENCODING}" to anything but "undef"
360       This variable allows Perl scripts to be written in an encoding other
361       than ASCII or UTF-8.  However, it affects all modules globally, leading
362       to wrong answers and segmentation faults.  New scripts should be
363       written in UTF-8; old scripts should be converted to UTF-8, which is
364       easily done with the piconv utility.
365
366   Use of non-graphic characters in single-character variable names
367       The syntax for single-character variable names is more lenient than for
368       longer variable names, allowing the one-character name to be a
369       punctuation character or even invisible (a non-graphic).  Perl v5.20
370       deprecated the ASCII-range controls as such a name.  Now, all non-
371       graphic characters that formerly were allowed are deprecated.  The
372       practical effect of this occurs only when not under "use utf8", and
373       affects just the C1 controls (code points 0x80 through 0xFF), NO-BREAK
374       SPACE, and SOFT HYPHEN.
375
376   Inlining of "sub () { $var }" with observable side-effects
377       In many cases Perl makes "sub () { $var }" into an inlinable constant
378       subroutine, capturing the value of $var at the time the "sub"
379       expression is evaluated.  This can break the closure behavior in those
380       cases where $var is subsequently modified, since the subroutine won't
381       return the changed value. (Note that this all only applies to anonymous
382       subroutines with an empty prototype ("sub ()").)
383
384       This usage is now deprecated in those cases where the variable could be
385       modified elsewhere.  Perl detects those cases and emits a deprecation
386       warning.  Such code will likely change in the future and stop producing
387       a constant.
388
389       If your variable is only modified in the place where it is declared,
390       then Perl will continue to make the sub inlinable with no warnings.
391
392           sub make_constant {
393               my $var = shift;
394               return sub () { $var }; # fine
395           }
396
397           sub make_constant_deprecated {
398               my $var;
399               $var = shift;
400               return sub () { $var }; # deprecated
401           }
402
403           sub make_constant_deprecated2 {
404               my $var = shift;
405               log_that_value($var); # could modify $var
406               return sub () { $var }; # deprecated
407           }
408
409       In the second example above, detecting that $var is assigned to only
410       once is too hard to detect.  That it happens in a spot other than the
411       "my" declaration is enough for Perl to find it suspicious.
412
413       This deprecation warning happens only for a simple variable for the
414       body of the sub.  (A "BEGIN" block or "use" statement inside the sub is
415       ignored, because it does not become part of the sub's body.)  For more
416       complex cases, such as "sub () { do_something() if 0; $var }" the
417       behavior has changed such that inlining does not happen if the variable
418       is modifiable elsewhere.  Such cases should be rare.
419
420   Use of multiple "/x" regexp modifiers
421       It is now deprecated to say something like any of the following:
422
423           qr/foo/xx;
424           /(?xax:foo)/;
425           use re qw(/amxx);
426
427       That is, now "x" should only occur once in any string of contiguous
428       regular expression pattern modifiers.  We do not believe there are any
429       occurrences of this in all of CPAN.  This is in preparation for a
430       future Perl release having "/xx" permit white-space for readability in
431       bracketed character classes (those enclosed in square brackets:
432       "[...]").
433
434   Using a NO-BREAK space in a character alias for "\N{...}" is now deprecated
435       This non-graphic character is essentially indistinguishable from a
436       regular space, and so should not be allowed.  See "CUSTOM ALIASES" in
437       charnames.
438
439   A literal "{" should now be escaped in a pattern
440       If you want a literal left curly bracket (also called a left brace) in
441       a regular expression pattern, you should now escape it by either
442       preceding it with a backslash ("\{") or enclosing it within square
443       brackets "[{]", or by using "\Q"; otherwise a deprecation warning will
444       be raised.  This was first announced as forthcoming in the v5.16
445       release; it will allow future extensions to the language to happen.
446
447   Making all warnings fatal is discouraged
448       The documentation for fatal warnings notes that "use warnings FATAL =>
449       'all'" is discouraged, and provides stronger language about the risks
450       of fatal warnings in general.
451

Performance Enhancements

453       ·   If a method or class name is known at compile time, a hash is
454           precomputed to speed up run-time method lookup.  Also, compound
455           method names like "SUPER::new" are parsed at compile time, to save
456           having to parse them at run time.
457
458       ·   Array and hash lookups (especially nested ones) that use only
459           constants or simple variables as keys, are now considerably faster.
460           See "Internal Changes" for more details.
461
462       ·   "(...)x1", "("constant")x0" and "($scalar)x0" are now optimised in
463           list context.  If the right-hand argument is a constant 1, the
464           repetition operator disappears.  If the right-hand argument is a
465           constant 0, the whole expression is optimised to the empty list, so
466           long as the left-hand argument is a simple scalar or constant.
467           (That is, "(foo())x0" is not subject to this optimisation.)
468
469       ·   "substr" assignment is now optimised into 4-argument "substr" at
470           the end of a subroutine (or as the argument to "return").
471           Previously, this optimisation only happened in void context.
472
473       ·   In "\L...", "\Q...", etc., the extra "stringify" op is now
474           optimised away, making these just as fast as "lcfirst",
475           "quotemeta", etc.
476
477       ·   Assignment to an empty list is now sometimes faster.  In
478           particular, it never calls "FETCH" on tied arguments on the right-
479           hand side, whereas it used to sometimes.
480
481       ·   There is a performance improvement of up to 20% when "length" is
482           applied to a non-magical, non-tied string, and either "use bytes"
483           is in scope or the string doesn't use UTF-8 internally.
484
485       ·   On most perl builds with 64-bit integers, memory usage for non-
486           magical, non-tied scalars containing only a floating point value
487           has been reduced by between 8 and 32 bytes, depending on OS.
488
489       ·   In "@array = split", the assignment can be optimized away, so that
490           "split" writes directly to the array.  This optimisation was
491           happening only for package arrays other than @_, and only
492           sometimes.  Now this optimisation happens almost all the time.
493
494       ·   "join" is now subject to constant folding.  So for example
495           "join "-", "a", "b"" is converted at compile-time to "a-b".
496           Moreover, "join" with a scalar or constant for the separator and a
497           single-item list to join is simplified to a stringification, and
498           the separator doesn't even get evaluated.
499
500       ·   "qq(@array)" is implemented using two ops: a stringify op and a
501           join op.  If the "qq" contains nothing but a single array, the
502           stringification is optimized away.
503
504       ·   "our $var" and "our($s,@a,%h)" in void context are no longer
505           evaluated at run time.  Even a whole sequence of "our $foo;"
506           statements will simply be skipped over.  The same applies to
507           "state" variables.
508
509       ·   Many internal functions have been refactored to improve performance
510           and reduce their memory footprints.  [perl #121436]
511           <https://rt.perl.org/Ticket/Display.html?id=121436> [perl #121906]
512           <https://rt.perl.org/Ticket/Display.html?id=121906> [perl #121969]
513           <https://rt.perl.org/Ticket/Display.html?id=121969>
514
515       ·   "-T" and "-B" filetests will return sooner when an empty file is
516           detected.  [perl #121489]
517           <https://rt.perl.org/Ticket/Display.html?id=121489>
518
519       ·   Hash lookups where the key is a constant are faster.
520
521       ·   Subroutines with an empty prototype and a body containing just
522           "undef" are now eligible for inlining.  [perl #122728]
523           <https://rt.perl.org/Ticket/Display.html?id=122728>
524
525       ·   Subroutines in packages no longer need to be stored in typeglobs:
526           declaring a subroutine will now put a simple sub reference directly
527           in the stash if possible, saving memory.  The typeglob still
528           notionally exists, so accessing it will cause the stash entry to be
529           upgraded to a typeglob (i.e. this is just an internal
530           implementation detail).  This optimization does not currently apply
531           to XSUBs or exported subroutines, and method calls will undo it,
532           since they cache things in typeglobs.  [perl #120441]
533           <https://rt.perl.org/Ticket/Display.html?id=120441>
534
535       ·   The functions "utf8::native_to_unicode()" and
536           "utf8::unicode_to_native()" (see utf8) are now optimized out on
537           ASCII platforms.  There is now not even a minimal performance hit
538           in writing code portable between ASCII and EBCDIC platforms.
539
540       ·   Win32 Perl uses 8 KB less of per-process memory than before for
541           every perl process, because some data is now memory mapped from
542           disk and shared between processes from the same perl binary.
543

Modules and Pragmata

545   Updated Modules and Pragmata
546       Many of the libraries distributed with perl have been upgraded since
547       v5.20.0.  For a complete list of changes, run:
548
549         corelist --diff 5.20.0 5.22.0
550
551       You can substitute your favorite version in place of 5.20.0, too.
552
553       Some notable changes include:
554
555       ·   Archive::Tar has been upgraded to version 2.04.
556
557           Tests can now be run in parallel.
558
559       ·   attributes has been upgraded to version 0.27.
560
561           The usage of "memEQs" in the XS has been corrected.  [perl #122701]
562           <https://rt.perl.org/Ticket/Display.html?id=122701>
563
564           Avoid reading beyond the end of a buffer. [perl #122629]
565
566       ·   B has been upgraded to version 1.58.
567
568           It provides a new "B::safename" function, based on the existing
569           "B::GV->SAFENAME", that converts "\cOPEN" to "^OPEN".
570
571           Nulled COPs are now of class "B::COP", rather than "B::OP".
572
573           "B::REGEXP" objects now provide a "qr_anoncv" method for accessing
574           the implicit CV associated with "qr//" things containing code
575           blocks, and a "compflags" method that returns the pertinent flags
576           originating from the "qr//blahblah" op.
577
578           "B::PMOP" now provides a "pmregexp" method returning a "B::REGEXP"
579           object.  Two new classes, "B::PADNAME" and "B::PADNAMELIST", have
580           been introduced.
581
582           A bug where, after an ithread creation or psuedofork,
583           special/immortal SVs in the child ithread/psuedoprocess did not
584           have the correct class of "B::SPECIAL", has been fixed.  The "id"
585           and "outid" PADLIST methods have been added.
586
587       ·   B::Concise has been upgraded to version 0.996.
588
589           Null ops that are part of the execution chain are now given
590           sequence numbers.
591
592           Private flags for nulled ops are now dumped with mnemonics as they
593           would be for the non-nulled counterparts.
594
595       ·   B::Deparse has been upgraded to version 1.35.
596
597           It now deparses "+sub : attr { ... }" correctly at the start of a
598           statement.  Without the initial "+", "sub" would be a statement
599           label.
600
601           "BEGIN" blocks are now emitted in the right place most of the time,
602           but the change unfortunately introduced a regression, in that
603           "BEGIN" blocks occurring just before the end of the enclosing block
604           may appear below it instead.
605
606           "B::Deparse" no longer puts erroneous "local" here and there, such
607           as for "LIST = tr/a//d".  [perl #119815]
608
609           Adjacent "use" statements are no longer accidentally nested if one
610           contains a "do" block.  [perl #115066]
611
612           Parenthesised arrays in lists passed to "\" are now correctly
613           deparsed with parentheses (e.g., "\(@a, (@b), @c)" now retains the
614           parentheses around @b), thus preserving the flattening behavior of
615           referenced parenthesised arrays.  Formerly, it only worked for one
616           array: "\(@a)".
617
618           "local our" is now deparsed correctly, with the "our" included.
619
620           "for($foo; !$bar; $baz) {...}" was deparsed without the "!" (or
621           "not").  This has been fixed.
622
623           Core keywords that conflict with lexical subroutines are now
624           deparsed with the "CORE::" prefix.
625
626           "foreach state $x (...) {...}" now deparses correctly with "state"
627           and not "my".
628
629           "our @array = split(...)" now deparses correctly with "our" in
630           those cases where the assignment is optimized away.
631
632           It now deparses "our(LIST)" and typed lexical ("my Dog $spot")
633           correctly.
634
635           Deparse $#_ as that instead of as $#{_}.  [perl #123947]
636           <https://rt.perl.org/Ticket/Display.html?id=123947>
637
638           BEGIN blocks at the end of the enclosing scope are now deparsed in
639           the right place.  [perl #77452]
640
641           BEGIN blocks were sometimes deparsed as __ANON__, but are now
642           always called BEGIN.
643
644           Lexical subroutines are now fully deparsed.  [perl #116553]
645
646           "Anything =~ y///r" with "/r" no longer omits the left-hand
647           operand.
648
649           The op trees that make up regexp code blocks are now deparsed for
650           real.  Formerly, the original string that made up the regular
651           expression was used.  That caused problems with
652           "qr/(?{<<heredoc})/" and multiline code blocks, which were deparsed
653           incorrectly.  [perl #123217] [perl #115256]
654
655           $; at the end of a statement no longer loses its semicolon.  [perl
656           #123357]
657
658           Some cases of subroutine declarations stored in the stash in
659           shorthand form were being omitted.
660
661           Non-ASCII characters are now consistently escaped in strings,
662           instead of some of the time.  (There are still outstanding problems
663           with regular expressions and identifiers that have not been fixed.)
664
665           When prototype sub calls are deparsed with "&" (e.g., under the -P
666           option), "scalar" is now added where appropriate, to force the
667           scalar context implied by the prototype.
668
669           "require(foo())", "do(foo())", "goto(foo())" and similar constructs
670           with loop controls are now deparsed correctly.  The outer
671           parentheses are not optional.
672
673           Whitespace is no longer escaped in regular expressions, because it
674           was getting erroneously escaped within "(?x:...)" sections.
675
676           "sub foo { foo() }" is now deparsed with those mandatory
677           parentheses.
678
679           "/@array/" is now deparsed as a regular expression, and not just
680           @array.
681
682           "/@{-}/", "/@{+}/" and $#{1} are now deparsed with the braces,
683           which are mandatory in these cases.
684
685           In deparsing feature bundles, "B::Deparse" was emitting "no
686           feature;" first instead of "no feature ':all';".  This has been
687           fixed.
688
689           "chdir FH" is now deparsed without quotation marks.
690
691           "\my @a" is now deparsed without parentheses.  (Parenthese would
692           flatten the array.)
693
694           "system" and "exec" followed by a block are now deparsed correctly.
695           Formerly there was an erroneous "do" before the block.
696
697           "use constant QR => qr/.../flags" followed by """ =~ QR" is no
698           longer without the flags.
699
700           Deparsing "BEGIN { undef &foo }" with the -w switch enabled started
701           to emit 'uninitialized' warnings in Perl 5.14.  This has been
702           fixed.
703
704           Deparsing calls to subs with a "(;+)" prototype resulted in an
705           infinite loop.  The "(;$") "(_)" and "(;_)" prototypes were given
706           the wrong precedence, causing "foo($a<$b)" to be deparsed without
707           the parentheses.
708
709           Deparse now provides a defined state sub in inner subs.
710
711       ·   B::Op_private has been added.
712
713           B::Op_private provides detailed information about the flags used in
714           the "op_private" field of perl opcodes.
715
716       ·   bigint, bignum, bigrat have been upgraded to version 0.39.
717
718           Document in CAVEATS that using strings as numbers won't always
719           invoke the big number overloading, and how to invoke it.
720           [rt.perl.org #123064]
721
722       ·   Carp has been upgraded to version 1.36.
723
724           "Carp::Heavy" now ignores version mismatches with Carp if Carp is
725           newer than 1.12, since "Carp::Heavy"'s guts were merged into Carp
726           at that point.  [perl #121574]
727           <https://rt.perl.org/Ticket/Display.html?id=121574>
728
729           Carp now handles non-ASCII platforms better.
730
731           Off-by-one error fix for Perl < 5.14.
732
733       ·   constant has been upgraded to version 1.33.
734
735           It now accepts fully-qualified constant names, allowing constants
736           to be defined in packages other than the caller.
737
738       ·   CPAN has been upgraded to version 2.11.
739
740           Add support for "Cwd::getdcwd()" and introduce workaround for a
741           misbehavior seen on Strawberry Perl 5.20.1.
742
743           Fix "chdir()" after building dependencies bug.
744
745           Introduce experimental support for plugins/hooks.
746
747           Integrate the "App::Cpan" sources.
748
749           Do not check recursion on optional dependencies.
750
751           Sanity check META.yml to contain a hash.  [cpan #95271]
752           <https://rt.cpan.org/Ticket/Display.html?id=95271>
753
754       ·   CPAN::Meta::Requirements has been upgraded to version 2.132.
755
756           Works around limitations in "version::vpp" detecting v-string magic
757           and adds support for forthcoming ExtUtils::MakeMaker bootstrap
758           version.pm for Perls older than 5.10.0.
759
760       ·   Data::Dumper has been upgraded to version 2.158.
761
762           Fixes CVE-2014-4330 by adding a configuration variable/option to
763           limit recursion when dumping deep data structures.
764
765           Changes to resolve Coverity issues.  XS dumps incorrectly stored
766           the name of code references stored in a GLOB.  [perl #122070]
767           <https://rt.perl.org/Ticket/Display.html?id=122070>
768
769       ·   DynaLoader has been upgraded to version 1.32.
770
771           Remove "dl_nonlazy" global if unused in Dynaloader. [perl #122926]
772
773       ·   Encode has been upgraded to version 2.72.
774
775           "piconv" now has better error handling when the encoding name is
776           nonexistent, and a build breakage when upgrading Encode in
777           perl-5.8.2 and earlier has been fixed.
778
779           Building in C++ mode on Windows now works.
780
781       ·   Errno has been upgraded to version 1.23.
782
783           Add "-P" to the preprocessor command-line on GCC 5.  GCC added
784           extra line directives, breaking parsing of error code definitions.
785           [rt.perl.org #123784]
786
787       ·   experimental has been upgraded to version 0.013.
788
789           Hardcodes features for Perls older than 5.15.7.
790
791       ·   ExtUtils::CBuilder has been upgraded to version 0.280221.
792
793           Fixes a regression on Android.  [perl #122675]
794           <https://rt.perl.org/Ticket/Display.html?id=122675>
795
796       ·   ExtUtils::Manifest has been upgraded to version 1.70.
797
798           Fixes a bug with "maniread()"'s handling of quoted filenames and
799           improves "manifind()" to follow symlinks.  [perl #122415]
800           <https://rt.perl.org/Ticket/Display.html?id=122415>
801
802       ·   ExtUtils::ParseXS has been upgraded to version 3.28.
803
804           Only declare "file" unused if we actually define it.  Improve
805           generated "RETVAL" code generation to avoid repeated references to
806           ST(0).  [perl #123278] Broaden and document the "/OBJ$/" to
807           "/REF$/" typemap optimization for the "DESTROY" method.  [perl
808           #123418]
809
810       ·   Fcntl has been upgraded to version 1.13.
811
812           Add support for the Linux pipe buffer size "fcntl()" commands.
813
814       ·   File::Find has been upgraded to version 1.29.
815
816           "find()" and "finddepth()" will now warn if passed inappropriate or
817           misspelled options.
818
819       ·   File::Glob has been upgraded to version 1.24.
820
821           Avoid "SvIV()" expanding to call "get_sv()" three times in a few
822           places. [perl #123606]
823
824       ·   HTTP::Tiny has been upgraded to version 0.054.
825
826           "keep_alive" is now fork-safe and thread-safe.
827
828       ·   IO has been upgraded to version 1.35.
829
830           The XS implementation has been fixed for the sake of older Perls.
831
832       ·   IO::Socket has been upgraded to version 1.38.
833
834           Document the limitations of the "connected()" method.  [perl
835           #123096]
836
837       ·   IO::Socket::IP has been upgraded to version 0.37.
838
839           A better fix for subclassing "connect()".  [cpan #95983]
840           <https://rt.cpan.org/Ticket/Display.html?id=95983> [cpan #97050]
841           <https://rt.cpan.org/Ticket/Display.html?id=97050>
842
843           Implements Timeout for "connect()".  [cpan #92075]
844           <https://rt.cpan.org/Ticket/Display.html?id=92075>
845
846       ·   The libnet collection of modules has been upgraded to version 3.05.
847
848           Support for IPv6 and SSL to "Net::FTP", "Net::NNTP", "Net::POP3"
849           and "Net::SMTP".  Improvements in "Net::SMTP" authentication.
850
851       ·   Locale::Codes has been upgraded to version 3.34.
852
853           Fixed a bug in the scripts used to extract data from spreadsheets
854           that prevented the SHP currency code from being found.  [cpan
855           #94229] <https://rt.cpan.org/Ticket/Display.html?id=94229>
856
857           New codes have been added.
858
859       ·   Math::BigInt has been upgraded to version 1.9997.
860
861           Synchronize POD changes from the CPAN release.
862           "Math::BigFloat->blog(x)" would sometimes return "blog(2*x)" when
863           the accuracy was greater than 70 digits.  The result of
864           "Math::BigFloat->bdiv()" in list context now satisfies "x =
865           quotient * divisor + remainder".
866
867           Correct handling of subclasses.  [cpan #96254]
868           <https://rt.cpan.org/Ticket/Display.html?id=96254> [cpan #96329]
869           <https://rt.cpan.org/Ticket/Display.html?id=96329>
870
871       ·   Module::Metadata has been upgraded to version 1.000026.
872
873           Support installations on older perls with an ExtUtils::MakeMaker
874           earlier than 6.63_03
875
876       ·   overload has been upgraded to version 1.26.
877
878           A redundant "ref $sub" check has been removed.
879
880       ·   The PathTools module collection has been upgraded to version 3.56.
881
882           A warning from the gcc compiler is now avoided when building the
883           XS.
884
885           Don't turn leading "//" into "/" on Cygwin. [perl #122635]
886
887       ·   perl5db.pl has been upgraded to version 1.49.
888
889           The debugger would cause an assertion failure.  [perl #124127]
890           <https://rt.perl.org/Ticket/Display.html?id=124127>
891
892           "fork()" in the debugger under "tmux" will now create a new window
893           for the forked process. [perl #121333]
894           <https://rt.perl.org/Ticket/Display.html?id=121333>
895
896           The debugger now saves the current working directory on startup and
897           restores it when you restart your program with "R" or "rerun".
898           [perl #121509] <https://rt.perl.org/Ticket/Display.html?id=121509>
899
900       ·   PerlIO::scalar has been upgraded to version 0.22.
901
902           Reading from a position well past the end of the scalar now
903           correctly returns end of file.  [perl #123443]
904
905           Seeking to a negative position still fails, but no longer leaves
906           the file position set to a negation location.
907
908           "eof()" on a "PerlIO::scalar" handle now properly returns true when
909           the file position is past the 2GB mark on 32-bit systems.
910
911           Attempting to write at file positions impossible for the platform
912           now fail early rather than wrapping at 4GB.
913
914       ·   Pod::Perldoc has been upgraded to version 3.25.
915
916           Filehandles opened for reading or writing now have
917           ":encoding(UTF-8)" set.  [cpan #98019]
918           <https://rt.cpan.org/Ticket/Display.html?id=98019>
919
920       ·   POSIX has been upgraded to version 1.53.
921
922           The C99 math functions and constants (for example "acosh", "isinf",
923           "isnan", "round", "trunc"; "M_E", "M_SQRT2", "M_PI") have been
924           added.
925
926           "POSIX::tmpnam()" now produces a deprecation warning.  [perl
927           #122005]
928
929       ·   Safe has been upgraded to version 2.39.
930
931           "reval" was not propagating void context properly.
932
933       ·   Scalar-List-Utils has been upgraded to version 1.41.
934
935           A new module, Sub::Util, has been added, containing functions
936           related to CODE refs, including "subname" (inspired by
937           "Sub::Identity") and "set_subname" (copied and renamed from
938           "Sub::Name").  The use of "GetMagic" in "List::Util::reduce()" has
939           also been fixed.  [cpan #63211]
940           <https://rt.cpan.org/Ticket/Display.html?id=63211>
941
942       ·   SDBM_File has been upgraded to version 1.13.
943
944           Simplified the build process.  [perl #123413]
945
946       ·   Time::Piece has been upgraded to version 1.29.
947
948           When pretty printing negative "Time::Seconds", the "minus" is no
949           longer lost.
950
951       ·   Unicode::Collate has been upgraded to version 1.12.
952
953           Version 0.67's improved discontiguous contractions is invalidated
954           by default and is supported as a parameter "long_contraction".
955
956       ·   Unicode::Normalize has been upgraded to version 1.18.
957
958           The XSUB implementation has been removed in favor of pure Perl.
959
960       ·   Unicode::UCD has been upgraded to version 0.61.
961
962           A new function property_values() has been added to return a given
963           property's possible values.
964
965           A new function charprop() has been added to return the value of a
966           given property for a given code point.
967
968           A new function charprops_all() has been added to return the values
969           of all Unicode properties for a given code point.
970
971           A bug has been fixed so that propaliases() returns the correct
972           short and long names for the Perl extensions where it was
973           incorrect.
974
975           A bug has been fixed so that prop_value_aliases() returns "undef"
976           instead of a wrong result for properties that are Perl extensions.
977
978           This module now works on EBCDIC platforms.
979
980       ·   utf8 has been upgraded to version 1.17
981
982           A mismatch between the documentation and the code in
983           "utf8::downgrade()" was fixed in favor of the documentation. The
984           optional second argument is now correctly treated as a perl boolean
985           (true/false semantics) and not as an integer.
986
987       ·   version has been upgraded to version 0.9909.
988
989           Numerous changes.  See the Changes file in the CPAN distribution
990           for details.
991
992       ·   Win32 has been upgraded to version 0.51.
993
994           "GetOSName()" now supports Windows 8.1, and building in C++ mode
995           now works.
996
997       ·   Win32API::File has been upgraded to version 0.1202
998
999           Building in C++ mode now works.
1000
1001       ·   XSLoader has been upgraded to version 0.20.
1002
1003           Allow XSLoader to load modules from a different namespace.  [perl
1004           #122455]
1005
1006   Removed Modules and Pragmata
1007       The following modules (and associated modules) have been removed from
1008       the core perl distribution:
1009
1010       ·   CGI
1011
1012       ·   Module::Build
1013

Documentation

1015   New Documentation
1016       perlunicook
1017
1018       This document, by Tom Christiansen, provides examples of handling
1019       Unicode in Perl.
1020
1021   Changes to Existing Documentation
1022       perlaix
1023
1024       ·   A note on long doubles has been added.
1025
1026       perlapi
1027
1028       ·   Note that "SvSetSV" doesn't do set magic.
1029
1030       ·   "sv_usepvn_flags" - fix documentation to mention the use of "Newx"
1031           instead of "malloc".
1032
1033           [perl #121869] <https://rt.perl.org/Ticket/Display.html?id=121869>
1034
1035       ·   Clarify where "NUL" may be embedded or is required to terminate a
1036           string.
1037
1038       ·   Some documentation that was previously missing due to formatting
1039           errors is now included.
1040
1041       ·   Entries are now organized into groups rather than by the file where
1042           they are found.
1043
1044       ·   Alphabetical sorting of entries is now done consistently
1045           (automatically by the POD generator) to make entries easier to find
1046           when scanning.
1047
1048       perldata
1049
1050       ·   The syntax of single-character variable names has been brought up-
1051           to-date and more fully explained.
1052
1053       ·   Hexadecimal floating point numbers are described, as are infinity
1054           and NaN.
1055
1056       perlebcdic
1057
1058       ·   This document has been significantly updated in the light of recent
1059           improvements to EBCDIC support.
1060
1061       perlfilter
1062
1063       ·   Added a LIMITATIONS section.
1064
1065       perlfunc
1066
1067       ·   Mention that "study()" is currently a no-op.
1068
1069       ·   Calling "delete" or "exists" on array values is now described as
1070           "strongly discouraged" rather than "deprecated".
1071
1072       ·   Improve documentation of "our".
1073
1074       ·   "-l" now notes that it will return false if symlinks aren't
1075           supported by the file system.  [perl #121523]
1076           <https://rt.perl.org/Ticket/Display.html?id=121523>
1077
1078       ·   Note that "exec LIST" and "system LIST" may fall back to the shell
1079           on Win32. Only the indirect-object syntax "exec PROGRAM LIST" and
1080           "system PROGRAM LIST" will reliably avoid using the shell.
1081
1082           This has also been noted in perlport.
1083
1084           [perl #122046] <https://rt.perl.org/Ticket/Display.html?id=122046>
1085
1086       perlguts
1087
1088       ·   The OOK example has been updated to account for COW changes and a
1089           change in the storage of the offset.
1090
1091       ·   Details on C level symbols and libperl.t added.
1092
1093       ·   Information on Unicode handling has been added
1094
1095       ·   Information on EBCDIC handling has been added
1096
1097       perlhack
1098
1099       ·   A note has been added about running on platforms with non-ASCII
1100           character sets
1101
1102       ·   A note has been added about performance testing
1103
1104       perlhacktips
1105
1106       ·   Documentation has been added illustrating the perils of assuming
1107           that there is no change to the contents of static memory pointed to
1108           by the return values of Perl's wrappers for C library functions.
1109
1110       ·   Replacements for "tmpfile", "atoi", "strtol", and "strtoul" are now
1111           recommended.
1112
1113       ·   Updated documentation for the "test.valgrind" "make" target.  [perl
1114           #121431] <https://rt.perl.org/Ticket/Display.html?id=121431>
1115
1116       ·   Information is given about writing test files portably to non-ASCII
1117           platforms.
1118
1119       ·   A note has been added about how to get a C language stack
1120           backtrace.
1121
1122       perlhpux
1123
1124       ·   Note that the message "Redeclaration of "sendpath" with a different
1125           storage class specifier" is harmless.
1126
1127       perllocale
1128
1129       ·   Updated for the enhancements in v5.22, along with some
1130           clarifications.
1131
1132       perlmodstyle
1133
1134       ·   Instead of pointing to the module list, we are now pointing to
1135           PrePAN <http://prepan.org/>.
1136
1137       perlop
1138
1139       ·   Updated for the enhancements in v5.22, along with some
1140           clarifications.
1141
1142       perlpodspec
1143
1144       ·   The specification of the pod language is changing so that the
1145           default encoding of pods that aren't in UTF-8 (unless otherwise
1146           indicated) is CP1252 instead of ISO 8859-1 (Latin1).
1147
1148       perlpolicy
1149
1150       ·   We now have a code of conduct for the p5p mailing list, as
1151           documented in "STANDARDS OF CONDUCT" in perlpolicy.
1152
1153       ·   The conditions for marking an experimental feature as non-
1154           experimental are now set out.
1155
1156       ·   Clarification has been made as to what sorts of changes are
1157           permissible in maintenance releases.
1158
1159       perlport
1160
1161       ·   Out-of-date VMS-specific information has been fixed and/or
1162           simplified.
1163
1164       ·   Notes about EBCDIC have been added.
1165
1166       perlre
1167
1168       ·   The description of the "/x" modifier has been clarified to note
1169           that comments cannot be continued onto the next line by escaping
1170           them; and there is now a list of all the characters that are
1171           considered whitespace by this modifier.
1172
1173       ·   The new "/n" modifier is described.
1174
1175       ·   A note has been added on how to make bracketed character class
1176           ranges portable to non-ASCII machines.
1177
1178       perlrebackslash
1179
1180       ·   Added documentation of "\b{sb}", "\b{wb}", "\b{gcb}", and "\b{g}".
1181
1182       perlrecharclass
1183
1184       ·   Clarifications have been added to "Character Ranges" in
1185           perlrecharclass to the effect "[A-Z]", "[a-z]", "[0-9]" and any
1186           subranges thereof in regular expression bracketed character classes
1187           are guaranteed to match exactly what a naive English speaker would
1188           expect them to match, even on platforms (such as EBCDIC) where perl
1189           has to do extra work to accomplish this.
1190
1191       ·   The documentation of Bracketed Character Classes has been expanded
1192           to cover the improvements in "qr/[\N{named sequence}]/" (see under
1193           "Selected Bug Fixes").
1194
1195       perlref
1196
1197       ·   A new section has been added Assigning to References
1198
1199       perlsec
1200
1201       ·   Comments added on algorithmic complexity and tied hashes.
1202
1203       perlsyn
1204
1205       ·   An ambiguity in the documentation of the "..." statement has been
1206           corrected.  [perl #122661]
1207           <https://rt.perl.org/Ticket/Display.html?id=122661>
1208
1209       ·   The empty conditional in "for" and "while" is now documented in
1210           perlsyn.
1211
1212       perlunicode
1213
1214       ·   This has had extensive revisions to bring it up-to-date with
1215           current Unicode support and to make it more readable.  Notable is
1216           that Unicode 7.0 changed what it should do with non-characters.
1217           Perl retains the old way of handling for reasons of backward
1218           compatibility.  See "Noncharacter code points" in perlunicode.
1219
1220       perluniintro
1221
1222       ·   Advice for how to make sure your strings and regular expression
1223           patterns are interpreted as Unicode has been updated.
1224
1225       perlvar
1226
1227       ·   $] is no longer listed as being deprecated.  Instead, discussion
1228           has been added on the advantages and disadvantages of using it
1229           versus $^V.  $OLD_PERL_VERSION was re-added to the documentation as
1230           the long form of $].
1231
1232       ·   "${^ENCODING}" is now marked as deprecated.
1233
1234       ·   The entry for "%^H" has been clarified to indicate it can only
1235           handle simple values.
1236
1237       perlvms
1238
1239       ·   Out-of-date and/or incorrect material has been removed.
1240
1241       ·   Updated documentation on environment and shell interaction in VMS.
1242
1243       perlxs
1244
1245       ·   Added a discussion of locale issues in XS code.
1246

Diagnostics

1248       The following additions or changes have been made to diagnostic output,
1249       including warnings and fatal error messages.  For the complete list of
1250       diagnostic messages, see perldiag.
1251
1252   New Diagnostics
1253       New Errors
1254
1255       ·   Bad symbol for scalar
1256
1257           (P) An internal request asked to add a scalar entry to something
1258           that wasn't a symbol table entry.
1259
1260       ·   Can't use a hash as a reference
1261
1262           (F) You tried to use a hash as a reference, as in "%foo->{"bar"}"
1263           or "%$ref->{"hello"}".  Versions of perl <= 5.6.1 used to allow
1264           this syntax, but shouldn't have.
1265
1266       ·   Can't use an array as a reference
1267
1268           (F) You tried to use an array as a reference, as in "@foo->[23]" or
1269           "@$ref->[99]".  Versions of perl <= 5.6.1 used to allow this
1270           syntax, but shouldn't have.
1271
1272       ·   Can't use 'defined(@array)' (Maybe you should just omit the
1273           defined()?)
1274
1275           (F) "defined()" is not useful on arrays because it checks for an
1276           undefined scalar value.  If you want to see if the array is empty,
1277           just use "if (@array) { # not empty }" for example.
1278
1279       ·   Can't use 'defined(%hash)' (Maybe you should just omit the
1280           defined()?)
1281
1282           (F) "defined()" is not usually right on hashes.
1283
1284           Although "defined %hash" is false on a plain not-yet-used hash, it
1285           becomes true in several non-obvious circumstances, including
1286           iterators, weak references, stash names, even remaining true after
1287           "undef %hash".  These things make "defined %hash" fairly useless in
1288           practice, so it now generates a fatal error.
1289
1290           If a check for non-empty is what you wanted then just put it in
1291           boolean context (see "Scalar values" in perldata):
1292
1293               if (%hash) {
1294                  # not empty
1295               }
1296
1297           If you had "defined %Foo::Bar::QUUX" to check whether such a
1298           package variable exists then that's never really been reliable, and
1299           isn't a good way to enquire about the features of a package, or
1300           whether it's loaded, etc.
1301
1302       ·   Cannot chr %f
1303
1304           (F) You passed an invalid number (like an infinity or not-a-number)
1305           to "chr".
1306
1307       ·   Cannot compress %f in pack
1308
1309           (F) You tried converting an infinity or not-a-number to an unsigned
1310           character, which makes no sense.
1311
1312       ·   Cannot pack %f with '%c'
1313
1314           (F) You tried converting an infinity or not-a-number to a
1315           character, which makes no sense.
1316
1317       ·   Cannot print %f with '%c'
1318
1319           (F) You tried printing an infinity or not-a-number as a character
1320           (%c), which makes no sense.  Maybe you meant '%s', or just
1321           stringifying it?
1322
1323       ·   charnames alias definitions may not contain a sequence of multiple
1324           spaces
1325
1326           (F) You defined a character name which had multiple space
1327           characters in a row.  Change them to single spaces.  Usually these
1328           names are defined in the ":alias" import argument to "use
1329           charnames", but they could be defined by a translator installed
1330           into $^H{charnames}.  See "CUSTOM ALIASES" in charnames.
1331
1332       ·   charnames alias definitions may not contain trailing white-space
1333
1334           (F) You defined a character name which ended in a space character.
1335           Remove the trailing space(s).  Usually these names are defined in
1336           the ":alias" import argument to "use charnames", but they could be
1337           defined by a translator installed into $^H{charnames}.  See "CUSTOM
1338           ALIASES" in charnames.
1339
1340       ·   :const is not permitted on named subroutines
1341
1342           (F) The "const" attribute causes an anonymous subroutine to be run
1343           and its value captured at the time that it is cloned.  Named
1344           subroutines are not cloned like this, so the attribute does not
1345           make sense on them.
1346
1347       ·   Hexadecimal float: internal error
1348
1349           (F) Something went horribly bad in hexadecimal float handling.
1350
1351       ·   Hexadecimal float: unsupported long double format
1352
1353           (F) You have configured Perl to use long doubles but the internals
1354           of the long double format are unknown, therefore the hexadecimal
1355           float output is impossible.
1356
1357       ·   Illegal suidscript
1358
1359           (F) The script run under suidperl was somehow illegal.
1360
1361       ·   In '(?...)', the '(' and '?' must be adjacent in regex; marked by
1362           <-- HERE in m/%s/
1363
1364           (F) The two-character sequence "(?" in this context in a regular
1365           expression pattern should be an indivisible token, with nothing
1366           intervening between the "(" and the "?", but you separated them.
1367
1368       ·   In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked
1369           by <-- HERE in m/%s/
1370
1371           (F) The two-character sequence "(*" in this context in a regular
1372           expression pattern should be an indivisible token, with nothing
1373           intervening between the "(" and the "*", but you separated them.
1374
1375       ·   Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/
1376
1377           (F) The pattern looks like a {min,max} quantifier, but the min or
1378           max could not be parsed as a valid number: either it has leading
1379           zeroes, or it represents too big a number to cope with.  The
1380           <-- HERE shows where in the regular expression the problem was
1381           discovered.  See perlre.
1382
1383       ·   '%s' is an unknown bound type in regex
1384
1385           (F) You used "\b{...}" or "\B{...}" and the "..." is not known to
1386           Perl.  The current valid ones are given in "\b{}, \b, \B{}, \B" in
1387           perlrebackslash.
1388
1389       ·   Missing or undefined argument to require
1390
1391           (F) You tried to call "require" with no argument or with an
1392           undefined value as an argument.  "require" expects either a package
1393           name or a file-specification as an argument.  See "require" in
1394           perlfunc.
1395
1396           Formerly, "require" with no argument or "undef" warned about a Null
1397           filename.
1398
1399       New Warnings
1400
1401       ·   \C is deprecated in regex
1402
1403           (D deprecated) The "/\C/" character class was deprecated in v5.20,
1404           and now emits a warning. It is intended that it will become an
1405           error in v5.24.  This character class matches a single byte even if
1406           it appears within a multi-byte character, breaks encapsulation, and
1407           can corrupt UTF-8 strings.
1408
1409       ·   "%s" is more clearly written simply as "%s" in regex; marked by <--
1410           HERE in m/%s/
1411
1412           (W regexp) (only under "use re 'strict'" or within "(?[...])")
1413
1414           You specified a character that has the given plainer way of writing
1415           it, and which is also portable to platforms running with different
1416           character sets.
1417
1418       ·   Argument "%s" treated as 0 in increment (++)
1419
1420           (W numeric) The indicated string was fed as an argument to the "++"
1421           operator which expects either a number or a string matching
1422           "/^[a-zA-Z]*[0-9]*\z/".  See "Auto-increment and Auto-decrement" in
1423           perlop for details.
1424
1425       ·   Both or neither range ends should be Unicode in regex; marked by
1426           <-- HERE in m/%s/
1427
1428           (W regexp) (only under "use re 'strict'" or within "(?[...])")
1429
1430           In a bracketed character class in a regular expression pattern, you
1431           had a range which has exactly one end of it specified using "\N{}",
1432           and the other end is specified using a non-portable mechanism.
1433           Perl treats the range as a Unicode range, that is, all the
1434           characters in it are considered to be the Unicode characters, and
1435           which may be different code points on some platforms Perl runs on.
1436           For example, "[\N{U+06}-\x08]" is treated as if you had instead
1437           said "[\N{U+06}-\N{U+08}]", that is it matches the characters whose
1438           code points in Unicode are 6, 7, and 8.  But that "\x08" might
1439           indicate that you meant something different, so the warning gets
1440           raised.
1441
1442       ·   Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".
1443
1444           (W locale) You are 1) running under ""use locale""; 2) the current
1445           locale is not a UTF-8 one; 3) you tried to do the designated case-
1446           change operation on the specified Unicode character; and 4) the
1447           result of this operation would mix Unicode and locale rules, which
1448           likely conflict.
1449
1450           The warnings category "locale" is new.
1451
1452       ·   :const is experimental
1453
1454           (S experimental::const_attr) The "const" attribute is experimental.
1455           If you want to use the feature, disable the warning with "no
1456           warnings 'experimental::const_attr'", but know that in doing so you
1457           are taking the risk that your code may break in a future Perl
1458           version.
1459
1460       ·   gmtime(%f) failed
1461
1462           (W overflow) You called "gmtime" with a number that it could not
1463           handle: too large, too small, or NaN.  The returned value is
1464           "undef".
1465
1466       ·   Hexadecimal float: exponent overflow
1467
1468           (W overflow) The hexadecimal floating point has larger exponent
1469           than the floating point supports.
1470
1471       ·   Hexadecimal float: exponent underflow
1472
1473           (W overflow) The hexadecimal floating point has smaller exponent
1474           than the floating point supports.
1475
1476       ·   Hexadecimal float: mantissa overflow
1477
1478           (W overflow) The hexadecimal floating point literal had more bits
1479           in the mantissa (the part between the "0x" and the exponent, also
1480           known as the fraction or the significand) than the floating point
1481           supports.
1482
1483       ·   Hexadecimal float: precision loss
1484
1485           (W overflow) The hexadecimal floating point had internally more
1486           digits than could be output.  This can be caused by unsupported
1487           long double formats, or by 64-bit integers not being available
1488           (needed to retrieve the digits under some configurations).
1489
1490       ·   Locale '%s' may not work well.%s
1491
1492           (W locale) You are using the named locale, which is a non-UTF-8
1493           one, and which perl has determined is not fully compatible with
1494           what it can handle.  The second %s gives a reason.
1495
1496           The warnings category "locale" is new.
1497
1498       ·   localtime(%f) failed
1499
1500           (W overflow) You called "localtime" with a number that it could not
1501           handle: too large, too small, or NaN.  The returned value is
1502           "undef".
1503
1504       ·   Negative repeat count does nothing
1505
1506           (W numeric) You tried to execute the "x" repetition operator fewer
1507           than 0 times, which doesn't make sense.
1508
1509       ·   NO-BREAK SPACE in a charnames alias definition is deprecated
1510
1511           (D deprecated) You defined a character name which contained a no-
1512           break space character.  Change it to a regular space.  Usually
1513           these names are defined in the ":alias" import argument to "use
1514           charnames", but they could be defined by a translator installed
1515           into $^H{charnames}.  See "CUSTOM ALIASES" in charnames.
1516
1517       ·   Non-finite repeat count does nothing
1518
1519           (W numeric) You tried to execute the "x" repetition operator "Inf"
1520           (or "-Inf") or NaN times, which doesn't make sense.
1521
1522       ·   PerlIO layer ':win32' is experimental
1523
1524           (S experimental::win32_perlio) The ":win32" PerlIO layer is
1525           experimental.  If you want to take the risk of using this layer,
1526           simply disable this warning:
1527
1528               no warnings "experimental::win32_perlio";
1529
1530       ·   Ranges of ASCII printables should be some subset of "0-9", "A-Z",
1531           or "a-z" in regex; marked by <-- HERE in m/%s/
1532
1533           (W regexp) (only under "use re 'strict'" or within "(?[...])")
1534
1535           Stricter rules help to find typos and other errors.  Perhaps you
1536           didn't even intend a range here, if the "-" was meant to be some
1537           other character, or should have been escaped (like "\-").  If you
1538           did intend a range, the one that was used is not portable between
1539           ASCII and EBCDIC platforms, and doesn't have an obvious meaning to
1540           a casual reader.
1541
1542            [3-7]    # OK; Obvious and portable
1543            [d-g]    # OK; Obvious and portable
1544            [A-Y]    # OK; Obvious and portable
1545            [A-z]    # WRONG; Not portable; not clear what is meant
1546            [a-Z]    # WRONG; Not portable; not clear what is meant
1547            [%-.]    # WRONG; Not portable; not clear what is meant
1548            [\x41-Z] # WRONG; Not portable; not obvious to non-geek
1549
1550           (You can force portability by specifying a Unicode range, which
1551           means that the endpoints are specified by "\N{...}", but the
1552           meaning may still not be obvious.)  The stricter rules require that
1553           ranges that start or stop with an ASCII character that is not a
1554           control have all their endpoints be a literal character, and not
1555           some escape sequence (like "\x41"), and the ranges must be all
1556           digits, or all uppercase letters, or all lowercase letters.
1557
1558       ·   Ranges of digits should be from the same group in regex; marked by
1559           <-- HERE in m/%s/
1560
1561           (W regexp) (only under "use re 'strict'" or within "(?[...])")
1562
1563           Stricter rules help to find typos and other errors.  You included a
1564           range, and at least one of the end points is a decimal digit.
1565           Under the stricter rules, when this happens, both end points should
1566           be digits in the same group of 10 consecutive digits.
1567
1568       ·   Redundant argument in %s
1569
1570           (W redundant) You called a function with more arguments than were
1571           needed, as indicated by information within other arguments you
1572           supplied (e.g. a printf format). Currently only emitted when a
1573           printf-type format required fewer arguments than were supplied, but
1574           might be used in the future for e.g. "pack" in perlfunc.
1575
1576           The warnings category "redundant" is new. See also [perl #121025]
1577           <https://rt.perl.org/Ticket/Display.html?id=121025>.
1578
1579       ·   Replacement list is longer than search list
1580
1581           This is not a new diagnostic, but in earlier releases was
1582           accidentally not displayed if the transliteration contained wide
1583           characters.  This is now fixed, so that you may see this diagnostic
1584           in places where you previously didn't (but should have).
1585
1586       ·   Use of \b{} for non-UTF-8 locale is wrong.  Assuming a UTF-8 locale
1587
1588           (W locale) You are matching a regular expression using locale
1589           rules, and a Unicode boundary is being matched, but the locale is
1590           not a Unicode one.  This doesn't make sense.  Perl will continue,
1591           assuming a Unicode (UTF-8) locale, but the results could well be
1592           wrong except if the locale happens to be ISO-8859-1 (Latin1) where
1593           this message is spurious and can be ignored.
1594
1595           The warnings category "locale" is new.
1596
1597       ·   Using /u for '%s' instead of /%s in regex; marked by <-- HERE in
1598           m/%s/
1599
1600           (W regexp) You used a Unicode boundary ("\b{...}" or "\B{...}") in
1601           a portion of a regular expression where the character set modifiers
1602           "/a" or "/aa" are in effect.  These two modifiers indicate an ASCII
1603           interpretation, and this doesn't make sense for a Unicode
1604           definition.  The generated regular expression will compile so that
1605           the boundary uses all of Unicode.  No other portion of the regular
1606           expression is affected.
1607
1608       ·   The bitwise feature is experimental
1609
1610           (S experimental::bitwise) This warning is emitted if you use
1611           bitwise operators ("& | ^ ~ &. |. ^. ~.") with the "bitwise"
1612           feature enabled.  Simply suppress the warning if you want to use
1613           the feature, but know that in doing so you are taking the risk of
1614           using an experimental feature which may change or be removed in a
1615           future Perl version:
1616
1617               no warnings "experimental::bitwise";
1618               use feature "bitwise";
1619               $x |.= $y;
1620
1621       ·   Unescaped left brace in regex is deprecated, passed through in
1622           regex; marked by <-- HERE in m/%s/
1623
1624           (D deprecated, regexp) You used a literal "{" character in a
1625           regular expression pattern. You should change to use "\{" instead,
1626           because a future version of Perl (tentatively v5.26) will consider
1627           this to be a syntax error.  If the pattern delimiters are also
1628           braces, any matching right brace ("}") should also be escaped to
1629           avoid confusing the parser, for example,
1630
1631               qr{abc\{def\}ghi}
1632
1633       ·   Use of literal non-graphic characters in variable names is
1634           deprecated
1635
1636           (D deprecated) Using literal non-graphic (including control)
1637           characters in the source to refer to the ^FOO variables, like $^X
1638           and "${^GLOBAL_PHASE}" is now deprecated.
1639
1640       ·   Useless use of attribute "const"
1641
1642           (W misc) The "const" attribute has no effect except on anonymous
1643           closure prototypes.  You applied it to a subroutine via
1644           attributes.pm.  This is only useful inside an attribute handler for
1645           an anonymous subroutine.
1646
1647       ·   Useless use of /d modifier in transliteration operator
1648
1649           This is not a new diagnostic, but in earlier releases was
1650           accidentally not displayed if the transliteration contained wide
1651           characters.  This is now fixed, so that you may see this diagnostic
1652           in places where you previously didn't (but should have).
1653
1654       ·   "use re 'strict'" is experimental
1655
1656           (S experimental::re_strict) The things that are different when a
1657           regular expression pattern is compiled under 'strict' are subject
1658           to change in future Perl releases in incompatible ways; there are
1659           also proposals to change how to enable strict checking instead of
1660           using this subpragma.  This means that a pattern that compiles
1661           today may not in a future Perl release.  This warning is to alert
1662           you to that risk.
1663
1664       ·   Warning: unable to close filehandle properly: %s
1665
1666           Warning: unable to close filehandle %s properly: %s
1667
1668           (S io) Previously, perl silently ignored any errors when doing an
1669           implicit close of a filehandle, i.e. where the reference count of
1670           the filehandle reached zero and the user's code hadn't already
1671           called "close()"; e.g.
1672
1673               {
1674                   open my $fh, '>', $file  or die "open: '$file': $!\n";
1675                   print $fh, $data  or die;
1676               } # implicit close here
1677
1678           In a situation such as disk full, due to buffering, the error may
1679           only be detected during the final close, so not checking the result
1680           of the close is dangerous.
1681
1682           So perl now warns in such situations.
1683
1684       ·   Wide character (U+%X) in %s
1685
1686           (W locale) While in a single-byte locale (i.e., a non-UTF-8 one), a
1687           multi-byte character was encountered.   Perl considers this
1688           character to be the specified Unicode code point.  Combining
1689           non-UTF-8 locales and Unicode is dangerous.  Almost certainly some
1690           characters will have two different representations.  For example,
1691           in the ISO 8859-7 (Greek) locale, the code point 0xC3 represents a
1692           Capital Gamma.  But so also does 0x393.  This will make string
1693           comparisons unreliable.
1694
1695           You likely need to figure out how this multi-byte character got
1696           mixed up with your single-byte locale (or perhaps you thought you
1697           had a UTF-8 locale, but Perl disagrees).
1698
1699           The warnings category "locale" is new.
1700
1701   Changes to Existing Diagnostics
1702       ·   <> should be quotes
1703
1704           This warning has been changed to <> at require-statement should be
1705           quotes to make the issue more identifiable.
1706
1707       ·   Argument "%s" isn't numeric%s
1708
1709           The perldiag entry for this warning has added this clarifying note:
1710
1711            Note that for the Inf and NaN (infinity and not-a-number) the
1712            definition of "numeric" is somewhat unusual: the strings themselves
1713            (like "Inf") are considered numeric, and anything following them is
1714            considered non-numeric.
1715
1716       ·   Global symbol "%s" requires explicit package name
1717
1718           This message has had '(did you forget to declare "my %s"?)'
1719           appended to it, to make it more helpful to new Perl programmers.
1720           [perl #121638] <https://rt.perl.org/Ticket/Display.html?id=121638>
1721
1722       ·   '"my" variable &foo::bar can't be in a package' has been reworded
1723           to say 'subroutine' instead of 'variable'.
1724
1725       ·   \N{} in character class restricted to one character in regex;
1726           marked by <-- HERE in m/%s/
1727
1728           This message has had character class changed to inverted character
1729           class or as a range end-point is to reflect improvements in
1730           "qr/[\N{named sequence}]/" (see under "Selected Bug Fixes").
1731
1732       ·   panic: frexp
1733
1734           This message has had ': %f' appended to it, to show what the
1735           offending floating point number is.
1736
1737       ·   Possible precedence problem on bitwise %c operator reworded as
1738           Possible precedence problem on bitwise %s operator.
1739
1740       ·   Unsuccessful %s on filename containing newline
1741
1742           This warning is now only produced when the newline is at the end of
1743           the filename.
1744
1745       ·   "Variable %s will not stay shared" has been changed to say
1746           "Subroutine" when it is actually a lexical sub that will not stay
1747           shared.
1748
1749       ·   Variable length lookbehind not implemented in regex m/%s/
1750
1751           The perldiag entry for this warning has had information about
1752           Unicode behavior added.
1753
1754   Diagnostic Removals
1755       ·   "Ambiguous use of -foo resolved as -&foo()"
1756
1757           There is actually no ambiguity here, and this impedes the use of
1758           negated constants; e.g., "-Inf".
1759
1760       ·   "Constant is not a FOO reference"
1761
1762           Compile-time checking of constant dereferencing (e.g.,
1763           "my_constant->()") has been removed, since it was not taking
1764           overloading into account.  [perl #69456]
1765           <https://rt.perl.org/Ticket/Display.html?id=69456> [perl #122607]
1766           <https://rt.perl.org/Ticket/Display.html?id=122607>
1767

Utility Changes

1769   find2perl, s2p and a2p removal
1770       ·   The x2p/ directory has been removed from the Perl core.
1771
1772           This removes find2perl, s2p and a2p. They have all been released to
1773           CPAN as separate distributions ("App::find2perl", "App::s2p",
1774           "App::a2p").
1775
1776   h2ph
1777       ·   h2ph now handles hexadecimal constants in the compiler's predefined
1778           macro definitions, as visible in $Config{cppsymbols}.  [perl
1779           #123784] <https://rt.perl.org/Ticket/Display.html?id=123784>.
1780
1781   encguess
1782       ·   No longer depends on non-core modules.
1783

Configuration and Compilation

1785       ·   Configure now checks for "lrintl()", "lroundl()", "llrintl()", and
1786           "llroundl()".
1787
1788       ·   Configure with "-Dmksymlinks" should now be faster.  [perl #122002]
1789           <https://rt.perl.org/Ticket/Display.html?id=122002>.
1790
1791       ·   The "pthreads" and "cl" libraries will be linked by default if
1792           present.  This allows XS modules that require threading to work on
1793           non-threaded perls. Note that you must still pass "-Dusethreads" if
1794           you want a threaded perl.
1795
1796       ·   To get more precision and range for floating point numbers one can
1797           now use the GCC quadmath library which implements the quadruple
1798           precision floating point numbers on x86 and IA-64 platforms.  See
1799           INSTALL for details.
1800
1801       ·   MurmurHash64A and MurmurHash64B can now be configured as the
1802           internal hash function.
1803
1804       ·   "make test.valgrind" now supports parallel testing.
1805
1806           For example:
1807
1808               TEST_JOBS=9 make test.valgrind
1809
1810           See "valgrind" in perlhacktips for more information.
1811
1812           [perl #121431] <https://rt.perl.org/Ticket/Display.html?id=121431>
1813
1814       ·   The MAD (Misc Attribute Decoration) build option has been removed
1815
1816           This was an unmaintained attempt at preserving the Perl parse tree
1817           more faithfully so that automatic conversion of Perl 5 to Perl 6
1818           would have been easier.
1819
1820           This build-time configuration option had been unmaintained for
1821           years, and had probably seriously diverged on both Perl 5 and Perl
1822           6 sides.
1823
1824       ·   A new compilation flag, "-DPERL_OP_PARENT" is available. For
1825           details, see the discussion below at "Internal Changes".
1826
1827       ·   Pathtools no longer tries to load XS on miniperl. This speeds up
1828           building perl slightly.
1829

Testing

1831       ·   t/porting/re_context.t has been added to test that utf8 and its
1832           dependencies only use the subset of the "$1..$n" capture vars that
1833           "Perl_save_re_context()" is hard-coded to localize, because that
1834           function has no efficient way of determining at runtime what vars
1835           to localize.
1836
1837       ·   Tests for performance issues have been added in the file
1838           t/perf/taint.t.
1839
1840       ·   Some regular expression tests are written in such a way that they
1841           will run very slowly if certain optimizations break. These tests
1842           have been moved into new files, t/re/speed.t and t/re/speed_thr.t,
1843           and are run with a "watchdog()".
1844
1845       ·   "test.pl" now allows "plan skip_all => $reason", to make it more
1846           compatible with "Test::More".
1847
1848       ·   A new test script, op/infnan.t, has been added to test if infinity
1849           and NaN are working correctly.  See "Infinity and NaN (not-a-
1850           number) handling improved".
1851

Platform Support

1853   Regained Platforms
1854       IRIX and Tru64 platforms are working again.
1855           Some "make test" failures remain: [perl #123977]
1856           <https://rt.perl.org/Ticket/Display.html?id=123977> and [perl
1857           #125298] <https://rt.perl.org/Ticket/Display.html?id=125298> for
1858           IRIX; [perl #124212]
1859           <https://rt.perl.org/Ticket/Display.html?id=124212>, [cpan #99605]
1860           <https://rt.cpan.org/Public/Bug/Display.html?id=99605>, and [cpan
1861           #104836] <https://rt.cpan.org/Ticket/Display.html?id=104836> for
1862           Tru64.
1863
1864       z/OS running EBCDIC Code Page 1047
1865           Core perl now works on this EBCDIC platform.  Earlier perls also
1866           worked, but, even though support wasn't officially withdrawn,
1867           recent perls would not compile and run well.  Perl 5.20 would work,
1868           but had many bugs which have now been fixed.  Many CPAN modules
1869           that ship with Perl still fail tests, including "Pod::Simple".
1870           However the version of "Pod::Simple" currently on CPAN should work;
1871           it was fixed too late to include in Perl 5.22.  Work is under way
1872           to fix many of the still-broken CPAN modules, which likely will be
1873           installed on CPAN when completed, so that you may not have to wait
1874           until Perl 5.24 to get a working version.
1875
1876   Discontinued Platforms
1877       NeXTSTEP/OPENSTEP
1878           NeXTSTEP was a proprietary operating system bundled with NeXT's
1879           workstations in the early to mid 90s; OPENSTEP was an API
1880           specification that provided a NeXTSTEP-like environment on a non-
1881           NeXTSTEP system.  Both are now long dead, so support for building
1882           Perl on them has been removed.
1883
1884   Platform-Specific Notes
1885       EBCDIC
1886           Special handling is required of the perl interpreter on EBCDIC
1887           platforms to get "qr/[i-j]/" to match only "i" and "j", since there
1888           are 7 characters between the code points for "i" and "j".  This
1889           special handling had only been invoked when both ends of the range
1890           are literals.  Now it is also invoked if any of the "\N{...}" forms
1891           for specifying a character by name or Unicode code point is used
1892           instead of a literal.  See "Character Ranges" in perlrecharclass.
1893
1894       HP-UX
1895           The archname now distinguishes use64bitint from use64bitall.
1896
1897       Android
1898           Build support has been improved for cross-compiling in general and
1899           for Android in particular.
1900
1901       VMS
1902           ·   When spawning a subprocess without waiting, the return value is
1903               now the correct PID.
1904
1905           ·   Fix a prototype so linking doesn't fail under the VMS C++
1906               compiler.
1907
1908           ·   "finite", "finitel", and "isfinite" detection has been added to
1909               "configure.com", environment handling has had some minor
1910               changes, and a fix for legacy feature checking status.
1911
1912       Win32
1913           ·   miniperl.exe is now built with "-fno-strict-aliasing", allowing
1914               64-bit builds to complete on GCC 4.8.  [perl #123976]
1915               <https://rt.perl.org/Ticket/Display.html?id=123976>
1916
1917           ·   "nmake minitest" now works on Win32.  Due to dependency issues
1918               you need to build "nmake test-prep" first, and a small number
1919               of the tests fail.  [perl #123394]
1920               <https://rt.perl.org/Ticket/Display.html?id=123394>
1921
1922           ·   Perl can now be built in C++ mode on Windows by setting the
1923               makefile macro "USE_CPLUSPLUS" to the value "define".
1924
1925           ·   The list form of piped open has been implemented for Win32.
1926               Note: unlike "system LIST" this does not fall back to the
1927               shell.  [perl #121159]
1928               <https://rt.perl.org/Ticket/Display.html?id=121159>
1929
1930           ·   New "DebugSymbols" and "DebugFull" configuration options added
1931               to Windows makefiles.
1932
1933           ·   Previously, compiling XS modules (including CPAN ones) using
1934               Visual C++ for Win64 resulted in around a dozen warnings per
1935               file from hv_func.h.  These warnings have been silenced.
1936
1937           ·   Support for building without PerlIO has been removed from the
1938               Windows makefiles.  Non-PerlIO builds were all but deprecated
1939               in Perl 5.18.0 and are already not supported by Configure on
1940               POSIX systems.
1941
1942           ·   Between 2 and 6 milliseconds and seven I/O calls have been
1943               saved per attempt to open a perl module for each path in @INC.
1944
1945           ·   Intel C builds are now always built with C99 mode on.
1946
1947           ·   %I64d is now being used instead of %lld for MinGW.
1948
1949           ·   In the experimental ":win32" layer, a crash in "open" was
1950               fixed. Also opening /dev/null (which works under Win32 Perl's
1951               default ":unix" layer) was implemented for ":win32".  [perl
1952               #122224] <https://rt.perl.org/Ticket/Display.html?id=122224>
1953
1954           ·   A new makefile option, "USE_LONG_DOUBLE", has been added to the
1955               Windows dmake makefile for gcc builds only.  Set this to
1956               "define" if you want perl to use long doubles to give more
1957               accuracy and range for floating point numbers.
1958
1959       OpenBSD
1960           On OpenBSD, Perl will now default to using the system "malloc" due
1961           to the security features it provides. Perl's own malloc wrapper has
1962           been in use since v5.14 due to performance reasons, but the OpenBSD
1963           project believes the tradeoff is worth it and would prefer that
1964           users who need the speed specifically ask for it.
1965
1966           [perl #122000] <https://rt.perl.org/Ticket/Display.html?id=122000>.
1967
1968       Solaris
1969           ·   We now look for the Sun Studio compiler in both /opt/solstudio*
1970               and /opt/solarisstudio*.
1971
1972           ·   Builds on Solaris 10 with "-Dusedtrace" would fail early since
1973               make didn't follow implied dependencies to build
1974               "perldtrace.h".  Added an explicit dependency to "depend".
1975               [perl #120120]
1976               <https://rt.perl.org/Ticket/Display.html?id=120120>
1977
1978           ·   C99 options have been cleaned up; hints look for "solstudio" as
1979               well as "SUNWspro"; and support for native "setenv" has been
1980               added.
1981

Internal Changes

1983       ·   Experimental support has been added to allow ops in the optree to
1984           locate their parent, if any. This is enabled by the non-default
1985           build option "-DPERL_OP_PARENT". It is envisaged that this will
1986           eventually become enabled by default, so XS code which directly
1987           accesses the "op_sibling" field of ops should be updated to be
1988           future-proofed.
1989
1990           On "PERL_OP_PARENT" builds, the "op_sibling" field has been renamed
1991           "op_sibparent" and a new flag, "op_moresib", added. On the last op
1992           in a sibling chain, "op_moresib" is false and "op_sibparent" points
1993           to the parent (if any) rather than being "NULL".
1994
1995           To make existing code work transparently whether using
1996           "PERL_OP_PARENT" or not, a number of new macros and functions have
1997           been added that should be used, rather than directly manipulating
1998           "op_sibling".
1999
2000           For the case of just reading "op_sibling" to determine the next
2001           sibling, two new macros have been added. A simple scan through a
2002           sibling chain like this:
2003
2004               for (; kid->op_sibling; kid = kid->op_sibling) { ... }
2005
2006           should now be written as:
2007
2008               for (; OpHAS_SIBLING(kid); kid = OpSIBLING(kid)) { ... }
2009
2010           For altering optrees, a general-purpose function
2011           "op_sibling_splice()" has been added, which allows for manipulation
2012           of a chain of sibling ops.  By analogy with the Perl function
2013           "splice()", it allows you to cut out zero or more ops from a
2014           sibling chain and replace them with zero or more new ops.  It
2015           transparently handles all the updating of sibling, parent, op_last
2016           pointers etc.
2017
2018           If you need to manipulate ops at a lower level, then three new
2019           macros, "OpMORESIB_set", "OpLASTSIB_set" and "OpMAYBESIB_set" are
2020           intended to be a low-level portable way to set "op_sibling" /
2021           "op_sibparent" while also updating "op_moresib".  The first sets
2022           the sibling pointer to a new sibling, the second makes the op the
2023           last sibling, and the third conditionally does the first or second
2024           action.  Note that unlike "op_sibling_splice()" these macros won't
2025           maintain consistency in the parent at the same time (e.g. by
2026           updating "op_first" and "op_last" where appropriate).
2027
2028           A C-level "Perl_op_parent()" function and a Perl-level
2029           "B::OP::parent()" method have been added. The C function only
2030           exists under "PERL_OP_PARENT" builds (using it is build-time error
2031           on vanilla perls).  "B::OP::parent()" exists always, but on a
2032           vanilla build it always returns "NULL". Under "PERL_OP_PARENT",
2033           they return the parent of the current op, if any. The variable
2034           $B::OP::does_parent allows you to determine whether "B" supports
2035           retrieving an op's parent.
2036
2037           "PERL_OP_PARENT" was introduced in 5.21.2, but the interface was
2038           changed considerably in 5.21.11. If you updated your code before
2039           the 5.21.11 changes, it may require further revision. The main
2040           changes after 5.21.2 were:
2041
2042           ·   The "OP_SIBLING" and "OP_HAS_SIBLING" macros have been renamed
2043               "OpSIBLING" and "OpHAS_SIBLING" for consistency with other op-
2044               manipulating macros.
2045
2046           ·   The "op_lastsib" field has been renamed "op_moresib", and its
2047               meaning inverted.
2048
2049           ·   The macro "OpSIBLING_set" has been removed, and has been
2050               superseded by "OpMORESIB_set" et al.
2051
2052           ·   The "op_sibling_splice()" function now accepts a null "parent"
2053               argument where the splicing doesn't affect the first or last
2054               ops in the sibling chain
2055
2056       ·   Macros have been created to allow XS code to better manipulate the
2057           POSIX locale category "LC_NUMERIC".  See "Locale-related functions
2058           and macros" in perlapi.
2059
2060       ·   The previous "atoi" et al replacement function, "grok_atou", has
2061           now been superseded by "grok_atoUV".  See perlclib for details.
2062
2063       ·   A new function, "Perl_sv_get_backrefs()", has been added which
2064           allows you retrieve the weak references, if any, which point at an
2065           SV.
2066
2067       ·   The "screaminstr()" function has been removed. Although marked as
2068           public API, it was undocumented and had no usage in CPAN modules.
2069           Calling it has been fatal since 5.17.0.
2070
2071       ·   The "newDEFSVOP()", "block_start()", "block_end()" and "intro_my()"
2072           functions have been added to the API.
2073
2074       ·   The internal "convert" function in op.c has been renamed
2075           "op_convert_list" and added to the API.
2076
2077       ·   The "sv_magic()" function no longer forbids "ext" magic on read-
2078           only values.  After all, perl can't know whether the custom magic
2079           will modify the SV or not.  [perl #123103]
2080           <https://rt.perl.org/Ticket/Display.html?id=123103>.
2081
2082       ·   Accessing "CvPADLIST" in perlapi on an XSUB is now forbidden.
2083
2084           The "CvPADLIST" field has been reused for a different internal
2085           purpose for XSUBs. So in particular, you can no longer rely on it
2086           being NULL as a test of whether a CV is an XSUB. Use "CvISXSUB()"
2087           instead.
2088
2089       ·   SVs of type "SVt_NV" are now sometimes bodiless when the build
2090           configuration and platform allow it: specifically, when "sizeof(NV)
2091           <= sizeof(IV)". "Bodiless" means that the NV value is stored
2092           directly in the head of an SV, without requiring a separate body to
2093           be allocated. This trick has already been used for IVs since 5.9.2
2094           (though in the case of IVs, it is always used, regardless of
2095           platform and build configuration).
2096
2097       ·   The $DB::single, $DB::signal and $DB::trace variables now have set-
2098           and get-magic that stores their values as IVs, and those IVs are
2099           used when testing their values in "pp_dbstate()".  This prevents
2100           perl from recursing infinitely if an overloaded object is assigned
2101           to any of those variables.  [perl #122445]
2102           <https://rt.perl.org/Ticket/Display.html?id=122445>.
2103
2104       ·   "Perl_tmps_grow()", which is marked as public API but is
2105           undocumented, has been removed from the public API. This change
2106           does not affect XS code that uses the "EXTEND_MORTAL" macro to pre-
2107           extend the mortal stack.
2108
2109       ·   Perl's internals no longer sets or uses the "SVs_PADMY" flag.
2110           "SvPADMY()" now returns a true value for anything not marked
2111           "PADTMP" and "SVs_PADMY" is now defined as 0.
2112
2113       ·   The macros "SETsv" and "SETsvUN" have been removed. They were no
2114           longer used in the core since commit 6f1401dc2a five years ago, and
2115           have not been found present on CPAN.
2116
2117       ·   The "SvFAKE" bit (unused on HVs) got informally reserved by David
2118           Mitchell for future work on vtables.
2119
2120       ·   The "sv_catpvn_flags()" function accepts "SV_CATBYTES" and
2121           "SV_CATUTF8" flags, which specify whether the appended string is
2122           bytes or UTF-8, respectively. (These flags have in fact been
2123           present since 5.16.0, but were formerly not regarded as part of the
2124           API.)
2125
2126       ·   A new opcode class, "METHOP", has been introduced. It holds
2127           information used at runtime to improve the performance of
2128           class/object method calls.
2129
2130           "OP_METHOD" and "OP_METHOD_NAMED" have changed from being
2131           "UNOP/SVOP" to being "METHOP".
2132
2133       ·   "cv_name()" is a new API function that can be passed a CV or GV.
2134           It returns an SV containing the name of the subroutine, for use in
2135           diagnostics.
2136
2137           [perl #116735] <https://rt.perl.org/Ticket/Display.html?id=116735>
2138           [perl #120441] <https://rt.perl.org/Ticket/Display.html?id=120441>
2139
2140       ·   "cv_set_call_checker_flags()" is a new API function that works like
2141           "cv_set_call_checker()", except that it allows the caller to
2142           specify whether the call checker requires a full GV for reporting
2143           the subroutine's name, or whether it could be passed a CV instead.
2144           Whatever value is passed will be acceptable to "cv_name()".
2145           "cv_set_call_checker()" guarantees there will be a GV, but it may
2146           have to create one on the fly, which is inefficient.  [perl
2147           #116735] <https://rt.perl.org/Ticket/Display.html?id=116735>
2148
2149       ·   "CvGV" (which is not part of the API) is now a more complex macro,
2150           which may call a function and reify a GV.  For those cases where it
2151           has been used as a boolean, "CvHASGV" has been added, which will
2152           return true for CVs that notionally have GVs, but without reifying
2153           the GV.  "CvGV" also returns a GV now for lexical subs.  [perl
2154           #120441] <https://rt.perl.org/Ticket/Display.html?id=120441>
2155
2156       ·   The "sync_locale" in perlapi function has been added to the public
2157           API.  Changing the program's locale should be avoided by XS code.
2158           Nevertheless, certain non-Perl libraries called from XS need to do
2159           so, such as "Gtk".  When this happens, Perl needs to be told that
2160           the locale has changed.  Use this function to do so, before
2161           returning to Perl.
2162
2163       ·   The defines and labels for the flags in the "op_private" field of
2164           OPs are now auto-generated from data in regen/op_private.  The
2165           noticeable effect of this is that some of the flag output of
2166           "Concise" might differ slightly, and the flag output of "perl -Dx"
2167           may differ considerably (they both use the same set of labels now).
2168           Also, debugging builds now have a new assertion in "op_free()" to
2169           ensure that the op doesn't have any unrecognized flags set in
2170           "op_private".
2171
2172       ·   The deprecated variable "PL_sv_objcount" has been removed.
2173
2174       ·   Perl now tries to keep the locale category "LC_NUMERIC" set to "C"
2175           except around operations that need it to be set to the program's
2176           underlying locale.  This protects the many XS modules that cannot
2177           cope with the decimal radix character not being a dot.  Prior to
2178           this release, Perl initialized this category to "C", but a call to
2179           "POSIX::setlocale()" would change it.  Now such a call will change
2180           the underlying locale of the "LC_NUMERIC" category for the program,
2181           but the locale exposed to XS code will remain "C".  There are new
2182           macros to manipulate the LC_NUMERIC locale, including
2183           "STORE_LC_NUMERIC_SET_TO_NEEDED" and
2184           "STORE_LC_NUMERIC_FORCE_TO_UNDERLYING".  See "Locale-related
2185           functions and macros" in perlapi.
2186
2187       ·   A new macro "isUTF8_CHAR" has been written which efficiently
2188           determines if the string given by its parameters begins with a
2189           well-formed UTF-8 encoded character.
2190
2191       ·   The following private API functions had their context parameter
2192           removed: "Perl_cast_ulong",  "Perl_cast_i32", "Perl_cast_iv",
2193           "Perl_cast_uv", "Perl_cv_const_sv", "Perl_mg_find",
2194           "Perl_mg_findext", "Perl_mg_magical", "Perl_mini_mktime",
2195           "Perl_my_dirfd", "Perl_sv_backoff", "Perl_utf8_hop".
2196
2197           Note that the prefix-less versions of those functions that are part
2198           of the public API, such as "cast_i32()", remain unaffected.
2199
2200       ·   The "PADNAME" and "PADNAMELIST" types are now separate types, and
2201           no longer simply aliases for SV and AV.  [perl #123223]
2202           <https://rt.perl.org/Ticket/Display.html?id=123223>.
2203
2204       ·   Pad names are now always UTF-8.  The "PadnameUTF8" macro always
2205           returns true.  Previously, this was effectively the case already,
2206           but any support for two different internal representations of pad
2207           names has now been removed.
2208
2209       ·   A new op class, "UNOP_AUX", has been added. This is a subclass of
2210           "UNOP" with an "op_aux" field added, which points to an array of
2211           unions of UV, SV* etc. It is intended for where an op needs to
2212           store more data than a simple "op_sv" or whatever. Currently the
2213           only op of this type is "OP_MULTIDEREF" (see next item).
2214
2215       ·   A new op has been added, "OP_MULTIDEREF", which performs one or
2216           more nested array and hash lookups where the key is a constant or
2217           simple variable. For example the expression $a[0]{$k}[$i], which
2218           previously involved ten "rv2Xv", "Xelem", "gvsv" and "const" ops is
2219           now performed by a single "multideref" op. It can also handle
2220           "local", "exists" and "delete". A non-simple index expression, such
2221           as "[$i+1]" is still done using "aelem"/"helem", and single-level
2222           array lookup with a small constant index is still done using
2223           "aelemfast".
2224

Selected Bug Fixes

2226       ·   "close" now sets $!
2227
2228           When an I/O error occurs, the fact that there has been an error is
2229           recorded in the handle.  "close" returns false for such a handle.
2230           Previously, the value of $! would be untouched by "close", so the
2231           common convention of writing "close $fh or die $!" did not work
2232           reliably.  Now the handle records the value of $!, too, and "close"
2233           restores it.
2234
2235       ·   "no re" now can turn off everything that "use re" enables
2236
2237           Previously, running "no re" would turn off only a few things. Now
2238           it can turn off all the enabled things. For example, the only way
2239           to stop debugging, once enabled, was to exit the enclosing block;
2240           that is now fixed.
2241
2242       ·   "pack("D", $x)" and "pack("F", $x)" now zero the padding on x86
2243           long double builds.  Under some build options on GCC 4.8 and later,
2244           they used to either overwrite the zero-initialized padding, or
2245           bypass the initialized buffer entirely.  This caused op/pack.t to
2246           fail.  [perl #123971]
2247           <https://rt.perl.org/Ticket/Display.html?id=123971>
2248
2249       ·   Extending an array cloned from a parent thread could result in
2250           "Modification of a read-only value attempted" errors when
2251           attempting to modify the new elements.  [perl #124127]
2252           <https://rt.perl.org/Ticket/Display.html?id=124127>
2253
2254       ·   An assertion failure and subsequent crash with "*x=<y>" has been
2255           fixed.  [perl #123790]
2256           <https://rt.perl.org/Ticket/Display.html?id=123790>
2257
2258       ·   A possible crashing/looping bug related to compiling lexical subs
2259           has been fixed.  [perl #124099]
2260           <https://rt.perl.org/Ticket/Display.html?id=124099>
2261
2262       ·   UTF-8 now works correctly in function names, in unquoted HERE-
2263           document terminators, and in variable names used as array indexes.
2264           [perl #124113] <https://rt.perl.org/Ticket/Display.html?id=124113>
2265
2266       ·   Repeated global pattern matches in scalar context on large tainted
2267           strings were exponentially slow depending on the current match
2268           position in the string.  [perl #123202]
2269           <https://rt.perl.org/Ticket/Display.html?id=123202>
2270
2271       ·   Various crashes due to the parser getting confused by syntax errors
2272           have been fixed.  [perl #123801]
2273           <https://rt.perl.org/Ticket/Display.html?id=123801> [perl #123802]
2274           <https://rt.perl.org/Ticket/Display.html?id=123802> [perl #123955]
2275           <https://rt.perl.org/Ticket/Display.html?id=123955> [perl #123995]
2276           <https://rt.perl.org/Ticket/Display.html?id=123995>
2277
2278       ·   "split" in the scope of lexical $_ has been fixed not to fail
2279           assertions.  [perl #123763]
2280           <https://rt.perl.org/Ticket/Display.html?id=123763>
2281
2282       ·   "my $x : attr" syntax inside various list operators no longer fails
2283           assertions.  [perl #123817]
2284           <https://rt.perl.org/Ticket/Display.html?id=123817>
2285
2286       ·   An "@" sign in quotes followed by a non-ASCII digit (which is not a
2287           valid identifier) would cause the parser to crash, instead of
2288           simply trying the "@" as literal.  This has been fixed.  [perl
2289           #123963] <https://rt.perl.org/Ticket/Display.html?id=123963>
2290
2291       ·   "*bar::=*foo::=*glob_with_hash" has been crashing since Perl 5.14,
2292           but no longer does.  [perl #123847]
2293           <https://rt.perl.org/Ticket/Display.html?id=123847>
2294
2295       ·   "foreach" in scalar context was not pushing an item on to the
2296           stack, resulting in bugs.
2297           ("print 4, scalar do { foreach(@x){} } + 1" would print 5.)  It has
2298           been fixed to return "undef".  [perl #124004]
2299           <https://rt.perl.org/Ticket/Display.html?id=124004>
2300
2301       ·   Several cases of data used to store environment variable contents
2302           in core C code being potentially overwritten before being used have
2303           been fixed.  [perl #123748]
2304           <https://rt.perl.org/Ticket/Display.html?id=123748>
2305
2306       ·   Some patterns starting with "/.*..../" matched against long strings
2307           have been slow since v5.8, and some of the form "/.*..../i" have
2308           been slow since v5.18. They are now all fast again.  [perl #123743]
2309           <https://rt.perl.org/Ticket/Display.html?id=123743>.
2310
2311       ·   The original visible value of $/ is now preserved when it is set to
2312           an invalid value.  Previously if you set $/ to a reference to an
2313           array, for example, perl would produce a runtime error and not set
2314           "PL_rs", but Perl code that checked $/ would see the array
2315           reference.  [perl #123218]
2316           <https://rt.perl.org/Ticket/Display.html?id=123218>.
2317
2318       ·   In a regular expression pattern, a POSIX class, like "[:ascii:]",
2319           must be inside a bracketed character class, like "qr/[[:ascii:]]/".
2320           A warning is issued when something looking like a POSIX class is
2321           not inside a bracketed class.  That warning wasn't getting
2322           generated when the POSIX class was negated: "[:^ascii:]".  This is
2323           now fixed.
2324
2325       ·   Perl 5.14.0 introduced a bug whereby "eval { LABEL: }" would crash.
2326           This has been fixed.  [perl #123652]
2327           <https://rt.perl.org/Ticket/Display.html?id=123652>.
2328
2329       ·   Various crashes due to the parser getting confused by syntax errors
2330           have been fixed.  [perl #123617]
2331           <https://rt.perl.org/Ticket/Display.html?id=123617>.  [perl
2332           #123737] <https://rt.perl.org/Ticket/Display.html?id=123737>.
2333           [perl #123753] <https://rt.perl.org/Ticket/Display.html?id=123753>.
2334           [perl #123677] <https://rt.perl.org/Ticket/Display.html?id=123677>.
2335
2336       ·   Code like "/$a[/" used to read the next line of input and treat it
2337           as though it came immediately after the opening bracket.  Some
2338           invalid code consequently would parse and run, but some code caused
2339           crashes, so this is now disallowed.  [perl #123712]
2340           <https://rt.perl.org/Ticket/Display.html?id=123712>.
2341
2342       ·   Fix argument underflow for "pack".  [perl #123874]
2343           <https://rt.perl.org/Ticket/Display.html?id=123874>.
2344
2345       ·   Fix handling of non-strict "\x{}". Now "\x{}" is equivalent to
2346           "\x{0}" instead of faulting.
2347
2348       ·   "stat -t" is now no longer treated as stackable, just like "-t
2349           stat".  [perl #123816]
2350           <https://rt.perl.org/Ticket/Display.html?id=123816>.
2351
2352       ·   The following no longer causes a SEGV: "qr{x+(y(?0))*}".
2353
2354       ·   Fixed infinite loop in parsing backrefs in regexp patterns.
2355
2356       ·   Several minor bug fixes in behavior of Infinity and NaN, including
2357           warnings when stringifying Infinity-like or NaN-like strings. For
2358           example, "NaNcy" doesn't numify to NaN anymore.
2359
2360       ·   A bug in regular expression patterns that could lead to segfaults
2361           and other crashes has been fixed.  This occurred only in patterns
2362           compiled with "/i" while taking into account the current POSIX
2363           locale (which usually means they have to be compiled within the
2364           scope of "use locale"), and there must be a string of at least 128
2365           consecutive bytes to match.  [perl #123539]
2366           <https://rt.perl.org/Ticket/Display.html?id=123539>.
2367
2368       ·   "s///g" now works on very long strings (where there are more than 2
2369           billion iterations) instead of dying with 'Substitution loop'.
2370           [perl #103260] <https://rt.perl.org/Ticket/Display.html?id=103260>.
2371           [perl #123071] <https://rt.perl.org/Ticket/Display.html?id=123071>.
2372
2373       ·   "gmtime" no longer crashes with not-a-number values.  [perl
2374           #123495] <https://rt.perl.org/Ticket/Display.html?id=123495>.
2375
2376       ·   "\()" (a reference to an empty list), and "y///" with lexical $_ in
2377           scope, could both do a bad write past the end of the stack.  They
2378           have both been fixed to extend the stack first.
2379
2380       ·   "prototype()" with no arguments used to read the previous item on
2381           the stack, so "print "foo", prototype()" would print foo's
2382           prototype.  It has been fixed to infer $_ instead.  [perl #123514]
2383           <https://rt.perl.org/Ticket/Display.html?id=123514>.
2384
2385       ·   Some cases of lexical state subs declared inside predeclared subs
2386           could crash, for example when evalling a string including the name
2387           of an outer variable, but no longer do.
2388
2389       ·   Some cases of nested lexical state subs inside anonymous subs could
2390           cause 'Bizarre copy' errors or possibly even crashes.
2391
2392       ·   When trying to emit warnings, perl's default debugger (perl5db.pl)
2393           was sometimes giving 'Undefined subroutine &DB::db_warn called'
2394           instead.  This bug, which started to occur in Perl 5.18, has been
2395           fixed.  [perl #123553]
2396           <https://rt.perl.org/Ticket/Display.html?id=123553>.
2397
2398       ·   Certain syntax errors in substitutions, such as "s/${<>{})//",
2399           would crash, and had done so since Perl 5.10.  (In some cases the
2400           crash did not start happening till 5.16.)  The crash has, of
2401           course, been fixed.  [perl #123542]
2402           <https://rt.perl.org/Ticket/Display.html?id=123542>.
2403
2404       ·   Fix a couple of string grow size calculation overflows; in
2405           particular, a repeat expression like "33 x ~3" could cause a large
2406           buffer overflow since the new output buffer size was not correctly
2407           handled by "SvGROW()".  An expression like this now properly
2408           produces a memory wrap panic.  [perl #123554]
2409           <https://rt.perl.org/Ticket/Display.html?id=123554>.
2410
2411       ·   "formline("@...", "a");" would crash.  The "FF_CHECKNL" case in
2412           "pp_formline()" didn't set the pointer used to mark the chop
2413           position, which led to the "FF_MORE" case crashing with a
2414           segmentation fault.  This has been fixed.  [perl #123538]
2415           <https://rt.perl.org/Ticket/Display.html?id=123538>.
2416
2417       ·   A possible buffer overrun and crash when parsing a literal pattern
2418           during regular expression compilation has been fixed.  [perl
2419           #123604] <https://rt.perl.org/Ticket/Display.html?id=123604>.
2420
2421       ·   "fchmod()" and "futimes()" now set $! when they fail due to being
2422           passed a closed file handle.  [perl #122703]
2423           <https://rt.perl.org/Ticket/Display.html?id=122703>.
2424
2425       ·   "op_free()" and "scalarvoid()" no longer crash due to a stack
2426           overflow when freeing a deeply recursive op tree.  [perl #108276]
2427           <https://rt.perl.org/Ticket/Display.html?id=108276>.
2428
2429       ·   In Perl 5.20.0, $^N accidentally had the internal UTF-8 flag turned
2430           off if accessed from a code block within a regular expression,
2431           effectively UTF-8-encoding the value.  This has been fixed.  [perl
2432           #123135] <https://rt.perl.org/Ticket/Display.html?id=123135>.
2433
2434       ·   A failed "semctl" call no longer overwrites existing items on the
2435           stack, which means that "(semctl(-1,0,0,0))[0]" no longer gives an
2436           "uninitialized" warning.
2437
2438       ·   "else{foo()}" with no space before "foo" is now better at assigning
2439           the right line number to that statement.  [perl #122695]
2440           <https://rt.perl.org/Ticket/Display.html?id=122695>.
2441
2442       ·   Sometimes the assignment in "@array = split" gets optimised so that
2443           "split" itself writes directly to the array.  This caused a bug,
2444           preventing this assignment from being used in lvalue context.  So
2445           "(@a=split//,"foo")=bar()" was an error.  (This bug probably goes
2446           back to Perl 3, when the optimisation was added.) It has now been
2447           fixed.  [perl #123057]
2448           <https://rt.perl.org/Ticket/Display.html?id=123057>.
2449
2450       ·   When an argument list fails the checks specified by a subroutine
2451           signature (which is still an experimental feature), the resulting
2452           error messages now give the file and line number of the caller, not
2453           of the called subroutine.  [perl #121374]
2454           <https://rt.perl.org/Ticket/Display.html?id=121374>.
2455
2456       ·   The flip-flop operators (".." and "..." in scalar context) used to
2457           maintain a separate state for each recursion level (the number of
2458           times the enclosing sub was called recursively), contrary to the
2459           documentation.  Now each closure has one internal state for each
2460           flip-flop.  [perl #122829]
2461           <https://rt.perl.org/Ticket/Display.html?id=122829>.
2462
2463       ·   The flip-flop operator (".." in scalar context) would return the
2464           same scalar each time, unless the containing subroutine was called
2465           recursively.  Now it always returns a new scalar.  [perl #122829]
2466           <https://rt.perl.org/Ticket/Display.html?id=122829>.
2467
2468       ·   "use", "no", statement labels, special blocks ("BEGIN") and pod are
2469           now permitted as the first thing in a "map" or "grep" block, the
2470           block after "print" or "say" (or other functions) returning a
2471           handle, and within "${...}", "@{...}", etc.  [perl #122782]
2472           <https://rt.perl.org/Ticket/Display.html?id=122782>.
2473
2474       ·   The repetition operator "x" now propagates lvalue context to its
2475           left-hand argument when used in contexts like "foreach".  That
2476           allows "for(($#that_array)x2) { ... }" to work as expected if the
2477           loop modifies $_.
2478
2479       ·   "(...) x ..." in scalar context used to corrupt the stack if one
2480           operand was an object with "x" overloading, causing erratic
2481           behavior.  [perl #121827]
2482           <https://rt.perl.org/Ticket/Display.html?id=121827>.
2483
2484       ·   Assignment to a lexical scalar is often optimised away; for example
2485           in "my $x; $x = $y + $z", the assign operator is optimised away and
2486           the add operator writes its result directly to $x.  Various bugs
2487           related to this optimisation have been fixed.  Certain operators on
2488           the right-hand side would sometimes fail to assign the value at all
2489           or assign the wrong value, or would call STORE twice or not at all
2490           on tied variables.  The operators affected were "$foo++", "$foo--",
2491           and "-$foo" under "use integer", "chomp", "chr" and "setpgrp".
2492
2493       ·   List assignments were sometimes buggy if the same scalar ended up
2494           on both sides of the assignment due to use of "tied", "values" or
2495           "each".  The result would be the wrong value getting assigned.
2496
2497       ·   "setpgrp($nonzero)" (with one argument) was accidentally changed in
2498           5.16 to mean setpgrp(0).  This has been fixed.
2499
2500       ·   "__SUB__" could return the wrong value or even corrupt memory under
2501           the debugger (the "-d" switch) and in subs containing "eval
2502           $string".
2503
2504       ·   When "sub () { $var }" becomes inlinable, it now returns a
2505           different scalar each time, just as a non-inlinable sub would,
2506           though Perl still optimises the copy away in cases where it would
2507           make no observable difference.
2508
2509       ·   "my sub f () { $var }" and "sub () : attr { $var }" are no longer
2510           eligible for inlining.  The former would crash; the latter would
2511           just throw the attributes away.  An exception is made for the
2512           little-known ":method" attribute, which does nothing much.
2513
2514       ·   Inlining of subs with an empty prototype is now more consistent
2515           than before. Previously, a sub with multiple statements, of which
2516           all but the last were optimised away, would be inlinable only if it
2517           were an anonymous sub containing a string "eval" or "state"
2518           declaration or closing over an outer lexical variable (or any
2519           anonymous sub under the debugger).  Now any sub that gets folded to
2520           a single constant after statements have been optimised away is
2521           eligible for inlining.  This applies to things like "sub () {
2522           jabber() if DEBUG; 42 }".
2523
2524           Some subroutines with an explicit "return" were being made
2525           inlinable, contrary to the documentation,  Now "return" always
2526           prevents inlining.
2527
2528       ·   On some systems, such as VMS, "crypt" can return a non-ASCII
2529           string.  If a scalar assigned to had contained a UTF-8 string
2530           previously, then "crypt" would not turn off the UTF-8 flag, thus
2531           corrupting the return value.  This would happen with
2532           "$lexical = crypt ...".
2533
2534       ·   "crypt" no longer calls "FETCH" twice on a tied first argument.
2535
2536       ·   An unterminated here-doc on the last line of a quote-like operator
2537           ("qq[${ <<END }]", "/(?{ <<END })/") no longer causes a double
2538           free.  It started doing so in 5.18.
2539
2540       ·   "index()" and "rindex()" no longer crash when used on strings over
2541           2GB in size.  [perl #121562]
2542           <https://rt.perl.org/Ticket/Display.html?id=121562>.
2543
2544       ·   A small, previously intentional, memory leak in
2545           "PERL_SYS_INIT"/"PERL_SYS_INIT3" on Win32 builds was fixed. This
2546           might affect embedders who repeatedly create and destroy perl
2547           engines within the same process.
2548
2549       ·   "POSIX::localeconv()" now returns the data for the program's
2550           underlying locale even when called from outside the scope of
2551           "use locale".
2552
2553       ·   "POSIX::localeconv()" now works properly on platforms which don't
2554           have "LC_NUMERIC" and/or "LC_MONETARY", or for which Perl has been
2555           compiled to disregard either or both of these locale categories.
2556           In such circumstances, there are now no entries for the
2557           corresponding values in the hash returned by "localeconv()".
2558
2559       ·   "POSIX::localeconv()" now marks appropriately the values it returns
2560           as UTF-8 or not.  Previously they were always returned as bytes,
2561           even if they were supposed to be encoded as UTF-8.
2562
2563       ·   On Microsoft Windows, within the scope of "use locale", the
2564           following POSIX character classes gave results for many locales
2565           that did not conform to the POSIX standard: "[[:alnum:]]",
2566           "[[:alpha:]]", "[[:blank:]]", "[[:digit:]]", "[[:graph:]]",
2567           "[[:lower:]]", "[[:print:]]", "[[:punct:]]", "[[:upper:]]",
2568           "[[:word:]]", and "[[:xdigit:]]".  This was because the underlying
2569           Microsoft implementation does not follow the standard.  Perl now
2570           takes special precautions to correct for this.
2571
2572       ·   Many issues have been detected by Coverity
2573           <http://www.coverity.com/> and fixed.
2574
2575       ·   "system()" and friends should now work properly on more Android
2576           builds.
2577
2578           Due to an oversight, the value specified through "-Dtargetsh" to
2579           Configure would end up being ignored by some of the build process.
2580           This caused perls cross-compiled for Android to end up with
2581           defective versions of "system()", "exec()" and backticks: the
2582           commands would end up looking for "/bin/sh" instead of
2583           "/system/bin/sh", and so would fail for the vast majority of
2584           devices, leaving $! as "ENOENT".
2585
2586       ·   "qr(...\(...\)...)", "qr[...\[...\]...]", and "qr{...\{...\}...}"
2587           now work.  Previously it was impossible to escape these three left-
2588           characters with a backslash within a regular expression pattern
2589           where otherwise they would be considered metacharacters, and the
2590           pattern opening delimiter was the character, and the closing
2591           delimiter was its mirror character.
2592
2593       ·   "s///e" on tainted UTF-8 strings corrupted "pos()". This bug,
2594           introduced in 5.20, is now fixed.  [perl #122148]
2595           <https://rt.perl.org/Ticket/Display.html?id=122148>.
2596
2597       ·   A non-word boundary in a regular expression ("\B") did not always
2598           match the end of the string; in particular "q{} =~ /\B/" did not
2599           match. This bug, introduced in perl 5.14, is now fixed.  [perl
2600           #122090] <https://rt.perl.org/Ticket/Display.html?id=122090>.
2601
2602       ·   "" P" =~ /(?=.*P)P/" should match, but did not. This is now fixed.
2603           [perl #122171] <https://rt.perl.org/Ticket/Display.html?id=122171>.
2604
2605       ·   Failing to compile "use Foo" in an "eval" could leave a spurious
2606           "BEGIN" subroutine definition, which would produce a "Subroutine
2607           BEGIN redefined" warning on the next use of "use", or other "BEGIN"
2608           block.  [perl #122107]
2609           <https://rt.perl.org/Ticket/Display.html?id=122107>.
2610
2611       ·   "method { BLOCK } ARGS" syntax now correctly parses the arguments
2612           if they begin with an opening brace.  [perl #46947]
2613           <https://rt.perl.org/Ticket/Display.html?id=46947>.
2614
2615       ·   External libraries and Perl may have different ideas of what the
2616           locale is.  This is problematic when parsing version strings if the
2617           locale's numeric separator has been changed.  Version parsing has
2618           been patched to ensure it handles the locales correctly.  [perl
2619           #121930] <https://rt.perl.org/Ticket/Display.html?id=121930>.
2620
2621       ·   A bug has been fixed where zero-length assertions and code blocks
2622           inside of a regex could cause "pos" to see an incorrect value.
2623           [perl #122460] <https://rt.perl.org/Ticket/Display.html?id=122460>.
2624
2625       ·   Dereferencing of constants now works correctly for typeglob
2626           constants.  Previously the glob was stringified and its name looked
2627           up.  Now the glob itself is used.  [perl #69456]
2628           <https://rt.perl.org/Ticket/Display.html?id=69456>
2629
2630       ·   When parsing a sigil ("$" "@" "%" "&)" followed by braces, the
2631           parser no longer tries to guess whether it is a block or a hash
2632           constructor (causing a syntax error when it guesses the latter),
2633           since it can only be a block.
2634
2635       ·   "undef $reference" now frees the referent immediately, instead of
2636           hanging on to it until the next statement.  [perl #122556]
2637           <https://rt.perl.org/Ticket/Display.html?id=122556>
2638
2639       ·   Various cases where the name of a sub is used (autoload,
2640           overloading, error messages) used to crash for lexical subs, but
2641           have been fixed.
2642
2643       ·   Bareword lookup now tries to avoid vivifying packages if it turns
2644           out the bareword is not going to be a subroutine name.
2645
2646       ·   Compilation of anonymous constants (e.g., "sub () { 3 }") no longer
2647           deletes any subroutine named "__ANON__" in the current package.
2648           Not only was "*__ANON__{CODE}" cleared, but there was a memory
2649           leak, too.  This bug goes back to Perl 5.8.0.
2650
2651       ·   Stub declarations like "sub f;" and "sub f ();" no longer wipe out
2652           constants of the same name declared by "use constant".  This bug
2653           was introduced in Perl 5.10.0.
2654
2655       ·   "qr/[\N{named sequence}]/" now works properly in many instances.
2656
2657           Some names known to "\N{...}" refer to a sequence of multiple
2658           characters, instead of the usual single character.  Bracketed
2659           character classes generally only match single characters, but now
2660           special handling has been added so that they can match named
2661           sequences, but not if the class is inverted or the sequence is
2662           specified as the beginning or end of a range.  In these cases, the
2663           only behavior change from before is a slight rewording of the fatal
2664           error message given when this class is part of a "?[...])"
2665           construct.  When the "[...]"  stands alone, the same non-fatal
2666           warning as before is raised, and only the first character in the
2667           sequence is used, again just as before.
2668
2669       ·   Tainted constants evaluated at compile time no longer cause
2670           unrelated statements to become tainted.  [perl #122669]
2671           <https://rt.perl.org/Ticket/Display.html?id=122669>
2672
2673       ·   "open $$fh, ...", which vivifies a handle with a name like
2674           "main::_GEN_0", was not giving the handle the right reference
2675           count, so a double free could happen.
2676
2677       ·   When deciding that a bareword was a method name, the parser would
2678           get confused if an "our" sub with the same name existed, and look
2679           up the method in the package of the "our" sub, instead of the
2680           package of the invocant.
2681
2682       ·   The parser no longer gets confused by "\U=" within a double-quoted
2683           string.  It used to produce a syntax error, but now compiles it
2684           correctly.  [perl #80368]
2685           <https://rt.perl.org/Ticket/Display.html?id=80368>
2686
2687       ·   It has always been the intention for the "-B" and "-T" file test
2688           operators to treat UTF-8 encoded files as text.  (perlfunc has been
2689           updated to say this.)  Previously, it was possible for some files
2690           to be considered UTF-8 that actually weren't valid UTF-8.  This is
2691           now fixed.  The operators now work on EBCDIC platforms as well.
2692
2693       ·   Under some conditions warning messages raised during regular
2694           expression pattern compilation were being output more than once.
2695           This has now been fixed.
2696
2697       ·   Perl 5.20.0 introduced a regression in which a UTF-8 encoded
2698           regular expression pattern that contains a single ASCII lowercase
2699           letter did not match its uppercase counterpart. That has been fixed
2700           in both 5.20.1 and 5.22.0.  [perl #122655]
2701           <https://rt.perl.org/Ticket/Display.html?id=122655>
2702
2703       ·   Constant folding could incorrectly suppress warnings if lexical
2704           warnings ("use warnings" or "no warnings") were not in effect and
2705           $^W were false at compile time and true at run time.
2706
2707       ·   Loading Unicode tables during a regular expression match could
2708           cause assertion failures under debugging builds if the previous
2709           match used the very same regular expression.  [perl #122747]
2710           <https://rt.perl.org/Ticket/Display.html?id=122747>
2711
2712       ·   Thread cloning used to work incorrectly for lexical subs, possibly
2713           causing crashes or double frees on exit.
2714
2715       ·   Since Perl 5.14.0, deleting $SomePackage::{__ANON__} and then
2716           undefining an anonymous subroutine could corrupt things internally,
2717           resulting in Devel::Peek crashing or B.pm giving nonsensical data.
2718           This has been fixed.
2719
2720       ·   "(caller $n)[3]" now reports names of lexical subs, instead of
2721           treating them as "(unknown)".
2722
2723       ·   "sort subname LIST" now supports using a lexical sub as the
2724           comparison routine.
2725
2726       ·   Aliasing (e.g., via "*x = *y") could confuse list assignments that
2727           mention the two names for the same variable on either side, causing
2728           wrong values to be assigned.  [perl #15667]
2729           <https://rt.perl.org/Ticket/Display.html?id=15667>
2730
2731       ·   Long here-doc terminators could cause a bad read on short lines of
2732           input.  This has been fixed.  It is doubtful that any crash could
2733           have occurred.  This bug goes back to when here-docs were
2734           introduced in Perl 3.000 twenty-five years ago.
2735
2736       ·   An optimization in "split" to treat "split /^/" like "split /^/m"
2737           had the unfortunate side-effect of also treating "split /\A/" like
2738           "split /^/m", which it should not.  This has been fixed.  (Note,
2739           however, that "split /^x/" does not behave like "split /^x/m",
2740           which is also considered to be a bug and will be fixed in a future
2741           version.)  [perl #122761]
2742           <https://rt.perl.org/Ticket/Display.html?id=122761>
2743
2744       ·   The little-known "my Class $var" syntax (see fields and attributes)
2745           could get confused in the scope of "use utf8" if "Class" were a
2746           constant whose value contained Latin-1 characters.
2747
2748       ·   Locking and unlocking values via Hash::Util or
2749           "Internals::SvREADONLY" no longer has any effect on values that
2750           were read-only to begin with.  Previously, unlocking such values
2751           could result in crashes, hangs or other erratic behavior.
2752
2753       ·   Some unterminated "(?(...)...)" constructs in regular expressions
2754           would either crash or give erroneous error messages.  "/(?(1)/" is
2755           one such example.
2756
2757       ·   "pack "w", $tied" no longer calls FETCH twice.
2758
2759       ·   List assignments like "($x, $z) = (1, $y)" now work correctly if $x
2760           and $y have been aliased by "foreach".
2761
2762       ·   Some patterns including code blocks with syntax errors, such as
2763           "/ (?{(^{})/", would hang or fail assertions on debugging builds.
2764           Now they produce errors.
2765
2766       ·   An assertion failure when parsing "sort" with debugging enabled has
2767           been fixed.  [perl #122771]
2768           <https://rt.perl.org/Ticket/Display.html?id=122771>.
2769
2770       ·   "*a = *b; @a = split //, $b[1]" could do a bad read and produce
2771           junk results.
2772
2773       ·   In "() = @array = split", the "() =" at the beginning no longer
2774           confuses the optimizer into assuming a limit of 1.
2775
2776       ·   Fatal warnings no longer prevent the output of syntax errors.
2777           [perl #122966] <https://rt.perl.org/Ticket/Display.html?id=122966>.
2778
2779       ·   Fixed a NaN double-to-long-double conversion error on VMS. For
2780           quiet NaNs (and only on Itanium, not Alpha) negative infinity
2781           instead of NaN was produced.
2782
2783       ·   Fixed the issue that caused "make distclean" to incorrectly leave
2784           some files behind.  [perl #122820]
2785           <https://rt.perl.org/Ticket/Display.html?id=122820>.
2786
2787       ·   AIX now sets the length in "getsockopt" correctly.  [perl #120835]
2788           <https://rt.perl.org/Ticket/Display.html?id=120835>.  [cpan #91183]
2789           <https://rt.cpan.org/Ticket/Display.html?id=91183>.  [cpan #85570]
2790           <https://rt.cpan.org/Ticket/Display.html?id=85570>.
2791
2792       ·   The optimization phase of a regexp compilation could run "forever"
2793           and exhaust all memory under certain circumstances; now fixed.
2794           [perl #122283] <https://rt.perl.org/Ticket/Display.html?id=122283>.
2795
2796       ·   The test script t/op/crypt.t now uses the SHA-256 algorithm if the
2797           default one is disabled, rather than giving failures.  [perl
2798           #121591] <https://rt.perl.org/Ticket/Display.html?id=121591>.
2799
2800       ·   Fixed an off-by-one error when setting the size of a shared array.
2801           [perl #122950] <https://rt.perl.org/Ticket/Display.html?id=122950>.
2802
2803       ·   Fixed a bug that could cause perl to enter an infinite loop during
2804           compilation. In particular, a while(1) within a sublist, e.g.
2805
2806               sub foo { () = ($a, my $b, ($c, do { while(1) {} })) }
2807
2808           The bug was introduced in 5.20.0 [perl #122995]
2809           <https://rt.perl.org/Ticket/Display.html?id=122995>.
2810
2811       ·   On Win32, if a variable was "local"-ized in a pseudo-process that
2812           later forked, restoring the original value in the child pseudo-
2813           process caused memory corruption and a crash in the child pseudo-
2814           process (and therefore the OS process).  [perl #40565]
2815           <https://rt.perl.org/Ticket/Display.html?id=40565>.
2816
2817       ·   Calling "write" on a format with a "^**" field could produce a
2818           panic in "sv_chop()" if there were insufficient arguments or if the
2819           variable used to fill the field was empty.  [perl #123245]
2820           <https://rt.perl.org/Ticket/Display.html?id=123245>.
2821
2822       ·   Non-ASCII lexical sub names now appear without trailing junk when
2823           they appear in error messages.
2824
2825       ·   The "\@" subroutine prototype no longer flattens parenthesized
2826           arrays (taking a reference to each element), but takes a reference
2827           to the array itself.  [perl #47363]
2828           <https://rt.perl.org/Ticket/Display.html?id=47363>.
2829
2830       ·   A block containing nothing except a C-style "for" loop could
2831           corrupt the stack, causing lists outside the block to lose elements
2832           or have elements overwritten.  This could happen with "map {
2833           for(...){...} } ..." and with lists containing "do { for(...){...}
2834           }".  [perl #123286]
2835           <https://rt.perl.org/Ticket/Display.html?id=123286>.
2836
2837       ·   "scalar()" now propagates lvalue context, so that
2838           "for(scalar($#foo)) { ... }" can modify $#foo through $_.
2839
2840       ·   "qr/@array(?{block})/" no longer dies with "Bizarre copy of ARRAY".
2841           [perl #123344] <https://rt.perl.org/Ticket/Display.html?id=123344>.
2842
2843       ·   "eval '$variable'" in nested named subroutines would sometimes look
2844           up a global variable even with a lexical variable in scope.
2845
2846       ·   In perl 5.20.0, "sort CORE::fake" where 'fake' is anything other
2847           than a keyword, started chopping off the last 6 characters and
2848           treating the result as a sort sub name.  The previous behavior of
2849           treating "CORE::fake" as a sort sub name has been restored.  [perl
2850           #123410] <https://rt.perl.org/Ticket/Display.html?id=123410>.
2851
2852       ·   Outside of "use utf8", a single-character Latin-1 lexical variable
2853           is disallowed.  The error message for it, "Can't use global
2854           $foo...", was giving garbage instead of the variable name.
2855
2856       ·   "readline" on a nonexistent handle was causing "${^LAST_FH}" to
2857           produce a reference to an undefined scalar (or fail an assertion).
2858           Now "${^LAST_FH}" ends up undefined.
2859
2860       ·   "(...) x ..." in void context now applies scalar context to the
2861           left-hand argument, instead of the context the current sub was
2862           called in.  [perl #123020]
2863           <https://rt.perl.org/Ticket/Display.html?id=123020>.
2864

Known Problems

2866       ·   "pack"-ing a NaN on a perl compiled with Visual C 6 does not behave
2867           properly, leading to a test failure in t/op/infnan.t.  [perl
2868           125203] <https://rt.perl.org/Ticket/Display.html?id=125203>
2869
2870       ·   A goal is for Perl to be able to be recompiled to work reasonably
2871           well on any Unicode version.  In Perl 5.22, though, the earliest
2872           such version is Unicode 5.1 (current is 7.0).
2873
2874       ·   EBCDIC platforms
2875
2876           ·   The "cmp" (and hence "sort") operators do not necessarily give
2877               the correct results when both operands are UTF-EBCDIC encoded
2878               strings and there is a mixture of ASCII and/or control
2879               characters, along with other characters.
2880
2881           ·   Ranges containing "\N{...}" in the "tr///" (and "y///")
2882               transliteration operators are treated differently than the
2883               equivalent ranges in regular expression patterns.  They should,
2884               but don't, cause the values in the ranges to all be treated as
2885               Unicode code points, and not native ones.  ("Version 8 Regular
2886               Expressions" in perlre gives details as to how it should work.)
2887
2888           ·   Encode and encoding are mostly broken.
2889
2890           ·   Many CPAN modules that are shipped with core show failing
2891               tests.
2892
2893           ·   "pack"/"unpack" with "U0" format may not work properly.
2894
2895       ·   The following modules are known to have test failures with this
2896           version of Perl.  In many cases, patches have been submitted, so
2897           there will hopefully be new releases soon:
2898
2899           ·   B::Generate version 1.50
2900
2901           ·   B::Utils version 0.25
2902
2903           ·   Coro version 6.42
2904
2905           ·   Dancer version 1.3130
2906
2907           ·   Data::Alias version 1.18
2908
2909           ·   Data::Dump::Streamer version 2.38
2910
2911           ·   Data::Util version 0.63
2912
2913           ·   Devel::Spy version 0.07
2914
2915           ·   invoker version 0.34
2916
2917           ·   Lexical::Var version 0.009
2918
2919           ·   LWP::ConsoleLogger version 0.000018
2920
2921           ·   Mason version 2.22
2922
2923           ·   NgxQueue version 0.02
2924
2925           ·   Padre version 1.00
2926
2927           ·   Parse::Keyword 0.08
2928

Obituary

2930       Brian McCauley died on May 8, 2015.  He was a frequent poster to
2931       Usenet, Perl Monks, and other Perl forums, and made several CPAN
2932       contributions under the nick NOBULL, including to the Perl FAQ.  He
2933       attended almost every YAPC::Europe, and indeed, helped organise
2934       YAPC::Europe 2006 and the QA Hackathon 2009.  His wit and his delight
2935       in intricate systems were particularly apparent in his love of board
2936       games; many Perl mongers will have fond memories of playing Fluxx and
2937       other games with Brian.  He will be missed.
2938

Acknowledgements

2940       Perl 5.22.0 represents approximately 12 months of development since
2941       Perl 5.20.0 and contains approximately 590,000 lines of changes across
2942       2,400 files from 94 authors.
2943
2944       Excluding auto-generated files, documentation and release tools, there
2945       were approximately 370,000 lines of changes to 1,500 .pm, .t, .c and .h
2946       files.
2947
2948       Perl continues to flourish into its third decade thanks to a vibrant
2949       community of users and developers. The following people are known to
2950       have contributed the improvements that became Perl 5.22.0:
2951
2952       Aaron Crane, Abhijit Menon-Sen, Abigail, Alberto Simo~es, Alex Solovey,
2953       Alex Vandiver, Alexandr Ciornii, Alexandre (Midnite) Jousset, Andreas
2954       Koenig, Andreas Voegele, Andrew Fresh, Andy Dougherty, Anthony Heading,
2955       Aristotle Pagaltzis, brian d foy, Brian Fraser, Chad Granum, Chris
2956       'BinGOs' Williams, Craig A. Berry, Dagfinn Ilmari Mannsaaker, Daniel
2957       Dragan, Darin McBride, Dave Rolsky, David Golden, David Mitchell, David
2958       Wheeler, Dmitri Tikhonov, Doug Bell, E. Choroba, Ed J, Eric Herman,
2959       Father Chrysostomos, George Greer, Glenn D. Golden, Graham Knop,
2960       H.Merijn Brand, Herbert Breunung, Hugo van der Sanden, James E Keenan,
2961       James McCoy, James Raspass, Jan Dubois, Jarkko Hietaniemi, Jasmine
2962       Ngan, Jerry D. Hedden, Jim Cromie, John Goodyear, kafka, Karen
2963       Etheridge, Karl Williamson, Kent Fredric, kmx, Lajos Veres, Leon
2964       Timmermans, Lukas Mai, Mathieu Arnold, Matthew Horsfall, Max Maischein,
2965       Michael Bunk, Nicholas Clark, Niels Thykier, Niko Tyni, Norman Koch,
2966       Olivier Mengue, Peter John Acklam, Peter Martini, Petr PisaX, Philippe
2967       Bruhat (BooK), Pierre Bogossian, Rafael Garcia-Suarez, Randy Stauner,
2968       Reini Urban, Ricardo Signes, Rob Hoelz, Rostislav Skudnov, Sawyer X,
2969       Shirakata Kentaro, Shlomi Fish, Sisyphus, Slaven Rezic, Smylers,
2970       Steffen Mueller, Steve Hay, Sullivan Beck, syber, Tadeusz SoXnierz,
2971       Thomas Sibley, Todd Rinaldo, Tony Cook, Vincent Pit, Vladimir Marek,
2972       Yaroslav Kuzmin, Yves Orton, AEvar Arnfjoerd` Bjarmason.
2973
2974       The list above is almost certainly incomplete as it is automatically
2975       generated from version control history. In particular, it does not
2976       include the names of the (very much appreciated) contributors who
2977       reported issues to the Perl bug tracker.
2978
2979       Many of the changes included in this version originated in the CPAN
2980       modules included in Perl's core. We're grateful to the entire CPAN
2981       community for helping Perl to flourish.
2982
2983       For a more complete list of all of Perl's historical contributors,
2984       please see the AUTHORS file in the Perl source distribution.
2985

Reporting Bugs

2987       If you find what you think is a bug, you might check the articles
2988       recently posted to the comp.lang.perl.misc newsgroup and the perl bug
2989       database at <https://rt.perl.org/>.  There may also be information at
2990       <http://www.perl.org/>, the Perl Home Page.
2991
2992       If you believe you have an unreported bug, please run the perlbug
2993       program included with your release.  Be sure to trim your bug down to a
2994       tiny but sufficient test case.  Your bug report, along with the output
2995       of "perl -V", will be sent off to perlbug@perl.org to be analysed by
2996       the Perl porting team.
2997
2998       If the bug you are reporting has security implications, which make it
2999       inappropriate to send to a publicly archived mailing list, then please
3000       send it to perl5-security-report@perl.org.  This points to a closed
3001       subscription unarchived mailing list, which includes all the core
3002       committers, who will be able to help assess the impact of issues,
3003       figure out a resolution, and help co-ordinate the release of patches to
3004       mitigate or fix the problem across all platforms on which Perl is
3005       supported.  Please only use this address for security issues in the
3006       Perl core, not for modules independently distributed on CPAN.
3007

SEE ALSO

3009       The Changes file for an explanation of how to view exhaustive details
3010       on what changed.
3011
3012       The INSTALL file for how to build Perl.
3013
3014       The README file for general stuff.
3015
3016       The Artistic and Copying files for copyright information.
3017
3018
3019
3020perl v5.28.2                      2018-03-01                  PERL5220DELTA(1)
Impressum