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.  [GH #14348]
26       <https://github.com/Perl/perl5/issues/14348>.
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 $_.  [GH #14376]
122       <https://github.com/Perl/perl5/issues/14376>.
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       [GH #2776] <https://github.com/Perl/perl5/issues/2776>.  [GH #14186]
228       <https://github.com/Perl/perl5/issues/14186>.  [GH #14353]
229       <https://github.com/Perl/perl5/issues/14353>.
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.  [GH #10633]
234       <https://github.com/Perl/perl5/issues/10633>.
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.  [GH #12335]
247       <https://github.com/Perl/perl5/issues/12335>.
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 [GH #12035]
323       <https://github.com/Perl/perl5/issues/12035>.
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.  [GH #13659]
511           <https://github.com/Perl/perl5/issues/13659> [GH #13856]
512           <https://github.com/Perl/perl5/issues/13856> [GH #13874]
513           <https://github.com/Perl/perl5/issues/13874>
514
515       •   "-T" and "-B" filetests will return sooner when an empty file is
516           detected.  [GH #13686] <https://github.com/Perl/perl5/issues/13686>
517
518       •   Hash lookups where the key is a constant are faster.
519
520       •   Subroutines with an empty prototype and a body containing just
521           "undef" are now eligible for inlining.  [GH #14077]
522           <https://github.com/Perl/perl5/issues/14077>
523
524       •   Subroutines in packages no longer need to be stored in typeglobs:
525           declaring a subroutine will now put a simple sub reference directly
526           in the stash if possible, saving memory.  The typeglob still
527           notionally exists, so accessing it will cause the stash entry to be
528           upgraded to a typeglob (i.e. this is just an internal
529           implementation detail).  This optimization does not currently apply
530           to XSUBs or exported subroutines, and method calls will undo it,
531           since they cache things in typeglobs.  [GH #13392]
532           <https://github.com/Perl/perl5/issues/13392>
533
534       •   The functions "utf8::native_to_unicode()" and
535           "utf8::unicode_to_native()" (see utf8) are now optimized out on
536           ASCII platforms.  There is now not even a minimal performance hit
537           in writing code portable between ASCII and EBCDIC platforms.
538
539       •   Win32 Perl uses 8 KB less of per-process memory than before for
540           every perl process, because some data is now memory mapped from
541           disk and shared between processes from the same perl binary.
542

Modules and Pragmata

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

Documentation

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

Diagnostics

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

Utility Changes

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

Configuration and Compilation

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

Testing

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

Platform Support

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

Internal Changes

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

Selected Bug Fixes

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

Known Problems

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

Obituary

2919       Brian McCauley died on May 8, 2015.  He was a frequent poster to
2920       Usenet, Perl Monks, and other Perl forums, and made several CPAN
2921       contributions under the nick NOBULL, including to the Perl FAQ.  He
2922       attended almost every YAPC::Europe, and indeed, helped organise
2923       YAPC::Europe 2006 and the QA Hackathon 2009.  His wit and his delight
2924       in intricate systems were particularly apparent in his love of board
2925       games; many Perl mongers will have fond memories of playing Fluxx and
2926       other games with Brian.  He will be missed.
2927

Acknowledgements

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

Reporting Bugs

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

SEE ALSO

2998       The Changes file for an explanation of how to view exhaustive details
2999       on what changed.
3000
3001       The INSTALL file for how to build Perl.
3002
3003       The README file for general stuff.
3004
3005       The Artistic and Copying files for copyright information.
3006
3007
3008
3009perl v5.36.0                      2022-08-30                  PERL5220DELTA(1)
Impressum