Commit | Line | Data |
---|---|---|
2cfe9b50 RS |
1 | =encoding utf8 |
2 | ||
3 | =head1 NAME | |
4 | ||
5 | perl5220delta - what is new for perl v5.22.0 | |
6 | ||
7 | =head1 DESCRIPTION | |
8 | ||
9 | This document describes differences between the 5.20.0 release and the 5.22.0 | |
10 | release. | |
11 | ||
12 | If you are upgrading from an earlier release such as 5.18.0, first read | |
13 | L<perl5200delta>, which describes differences between 5.18.0 and 5.20.0. | |
14 | ||
15 | =head1 Core Enhancements | |
16 | ||
17 | =head2 New bitwise operators | |
18 | ||
19 | A new experimental facility has been added that makes the four standard | |
20 | bitwise operators (C<& | ^ ~>) treat their operands consistently as | |
21 | numbers, and introduces four new dotted operators (C<&. |. ^. ~.>) that | |
22 | treat their operands consistently as strings. The same applies to the | |
23 | assignment variants (C<&= |= ^= &.= |.= ^.=>). | |
24 | ||
25 | To use this, enable the "bitwise" feature and disable the | |
26 | "experimental::bitwise" warnings category. See L<perlop/Bitwise String | |
27 | Operators> for details. | |
28 | L<[perl #123466]|https://rt.perl.org/Ticket/Display.html?id=123466>. | |
29 | ||
30 | =head2 New double-diamond operator | |
31 | ||
32 | C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open | |
33 | each file in C<@ARGV>. This means that each element of C<@ARGV> will be treated | |
34 | as an actual file name, and C<"|foo"> won't be treated as a pipe open. | |
35 | ||
36 | =head2 New C<\b> boundaries in regular expressions | |
37 | ||
38 | =head3 C<qr/\b{gcb}/> | |
39 | ||
40 | C<gcb> stands for Grapheme Cluster Boundary. It is a Unicode property | |
41 | that finds the boundary between sequences of characters that look like a | |
42 | single character to a native speaker of a language. Perl has long had | |
43 | the ability to deal with these through the C<\X> regular escape | |
44 | sequence. Now, there is an alternative way of handling these. See | |
45 | L<perlrebackslash/\b{}, \b, \B{}, \B> for details. | |
46 | ||
47 | =head3 C<qr/\b{wb}/> | |
48 | ||
49 | C<wb> stands for Word Boundary. It is a Unicode property | |
50 | that finds the boundary between words. This is similar to the plain | |
51 | C<\b> (without braces) but is more suitable for natural language | |
52 | processing. It knows, for example, that apostrophes can occur in the | |
53 | middle of words. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. | |
54 | ||
55 | =head3 C<qr/\b{sb}/> | |
56 | ||
57 | C<sb> stands for Sentence Boundary. It is a Unicode property | |
58 | to aid in parsing natural language sentences. | |
59 | See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. | |
60 | ||
61 | =head2 Non-Capturing Regular Expression Flag | |
62 | ||
63 | Regular expressions now support a C</n> flag that disables capturing | |
64 | and filling in C<$1>, C<$2>, etc inside of groups: | |
65 | ||
66 | "hello" =~ /(hi|hello)/n; # $1 is not set | |
67 | ||
68 | This is equivalent to putting C<?:> at the beginning of every capturing group. | |
69 | ||
70 | See L<perlre/"n"> for more information. | |
71 | ||
72 | =head2 C<use re 'strict'> | |
73 | ||
74 | This applies stricter syntax rules to regular expression patterns | |
75 | compiled within its scope. This will hopefully alert you to typos and | |
76 | other unintentional behavior that backwards-compatibility issues prevent | |
77 | us from reporting in normal regular expression compilations. Because the | |
78 | behavior of this is subject to change in future Perl releases as we gain | |
79 | experience, using this pragma will raise a warning of category | |
80 | C<experimental::re_strict>. | |
81 | See L<'strict' in re|re/'strict' mode>. | |
82 | ||
83 | =head2 Unicode 7.0 (with correction) is now supported | |
84 | ||
85 | For details on what is in this release, see | |
86 | L<http://www.unicode.org/versions/Unicode7.0.0/>. | |
87 | The version of Unicode 7.0 that comes with Perl includes | |
88 | a correction dealing with glyph shaping in Arabic | |
89 | (see L<http://www.unicode.org/errata/#current_errata>). | |
90 | ||
91 | ||
92 | =head2 S<C<use locale>> can restrict which locale categories are affected | |
93 | ||
94 | It is now possible to pass a parameter to S<C<use locale>> to specify | |
95 | a subset of locale categories to be locale-aware, with the remaining | |
96 | ones unaffected. See L<perllocale/The "use locale" pragma> for details. | |
97 | ||
98 | =head2 Perl now supports POSIX 2008 locale currency additions | |
99 | ||
100 | On platforms that are able to handle POSIX.1-2008, the | |
101 | hash returned by | |
102 | L<C<POSIX::localeconv()>|perllocale/The localeconv function> | |
103 | includes the international currency fields added by that version of the | |
104 | POSIX standard. These are | |
105 | C<int_n_cs_precedes>, | |
106 | C<int_n_sep_by_space>, | |
107 | C<int_n_sign_posn>, | |
108 | C<int_p_cs_precedes>, | |
109 | C<int_p_sep_by_space>, | |
110 | and | |
111 | C<int_p_sign_posn>. | |
112 | ||
113 | =head2 Better heuristics on older platforms for determining locale UTF-8ness | |
114 | ||
115 | On platforms that implement neither the C99 standard nor the POSIX 2001 | |
116 | standard, determining if the current locale is UTF-8 or not depends on | |
117 | heuristics. These are improved in this release. | |
118 | ||
119 | =head2 Aliasing via reference | |
120 | ||
121 | Variables and subroutines can now be aliased by assigning to a reference: | |
122 | ||
123 | \$c = \$d; | |
124 | \&x = \&y; | |
125 | ||
126 | Aliasing can also be accomplished | |
127 | by using a backslash before a C<foreach> iterator variable; this is | |
128 | perhaps the most useful idiom this feature provides: | |
129 | ||
130 | foreach \%hash (@array_of_hash_refs) { ... } | |
131 | ||
132 | This feature is experimental and must be enabled via S<C<use feature | |
133 | 'refaliasing'>>. It will warn unless the C<experimental::refaliasing> | |
134 | warnings category is disabled. | |
135 | ||
136 | See L<perlref/Assigning to References> | |
137 | ||
138 | =head2 C<prototype> with no arguments | |
139 | ||
140 | C<prototype()> with no arguments now infers C<$_>. | |
141 | L<[perl #123514]|https://rt.perl.org/Ticket/Display.html?id=123514>. | |
142 | ||
143 | =head2 New C<:const> subroutine attribute | |
144 | ||
145 | The C<const> attribute can be applied to an anonymous subroutine. It | |
146 | causes the new sub to be executed immediately whenever one is created | |
147 | (I<i.e.> when the C<sub> expression is evaluated). Its value is captured | |
148 | and used to create a new constant subroutine that is returned. This | |
149 | feature is experimental. See L<perlsub/Constant Functions>. | |
150 | ||
151 | =head2 C<fileno> now works on directory handles | |
152 | ||
153 | When the relevant support is available in the operating system, the | |
154 | C<fileno> builtin now works on directory handles, yielding the | |
155 | underlying file descriptor in the same way as for filehandles. On | |
156 | operating systems without such support, C<fileno> on a directory handle | |
157 | continues to return the undefined value, as before, but also sets C<$!> to | |
158 | indicate that the operation is not supported. | |
159 | ||
160 | Currently, this uses either a C<dd_fd> member in the OS C<DIR> | |
161 | structure, or a C<dirfd(3)> function as specified by POSIX.1-2008. | |
162 | ||
163 | =head2 List form of pipe open implemented for Win32 | |
164 | ||
165 | The list form of pipe: | |
166 | ||
167 | open my $fh, "-|", "program", @arguments; | |
168 | ||
169 | is now implemented on Win32. It has the same limitations as C<system | |
170 | LIST> on Win32, since the Win32 API doesn't accept program arguments | |
171 | as a list. | |
172 | ||
173 | =head2 Assignment to list repetition | |
174 | ||
175 | C<(...) x ...> can now be used within a list that is assigned to, as long | |
176 | as the left-hand side is a valid lvalue. This allows S<C<(undef,undef,$foo) | |
177 | = that_function()>> to be written as S<C<((undef)x2, $foo) = that_function()>>. | |
178 | ||
179 | =head2 Infinity and NaN (not-a-number) handling improved | |
180 | ||
181 | Floating point values are able to hold the special values infinity, negative | |
182 | infinity, and NaN (not-a-number). Now we more robustly recognize and | |
183 | propagate the value in computations, and on output normalize them to the strings | |
184 | C<Inf>, C<-Inf>, and C<NaN>. | |
185 | ||
186 | See also the L<POSIX> enhancements. | |
187 | ||
188 | =head2 Floating point parsing has been improved | |
189 | ||
190 | Parsing and printing of floating point values has been improved. | |
191 | ||
192 | As a completely new feature, hexadecimal floating point literals | |
193 | (like C<0x1.23p-4>) are now supported, and they can be output with | |
194 | S<C<printf "%a">>. See L<perldata/Scalar value constructors> for more | |
195 | details. | |
196 | ||
197 | =head2 Packing infinity or not-a-number into a character is now fatal | |
198 | ||
199 | Before, when trying to pack infinity or not-a-number into a | |
200 | (signed) character, Perl would warn, and assumed you tried to | |
201 | pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>, | |
202 | C<< U+FFFD >> was returned. | |
203 | ||
204 | But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>) | |
205 | result in a fatal error. | |
206 | ||
207 | =head2 Experimental C Backtrace API | |
208 | ||
209 | Perl now supports (via a C level API) retrieving | |
210 | the C level backtrace (similar to what symbolic debuggers like gdb do). | |
211 | ||
212 | The backtrace returns the stack trace of the C call frames, | |
213 | with the symbol names (function names), the object names (like "perl"), | |
214 | and if it can, also the source code locations (file:line). | |
215 | ||
216 | The supported platforms are Linux and OS X (some *BSD might work at | |
217 | least partly, but they have not yet been tested). | |
218 | ||
219 | The feature needs to be enabled with C<Configure -Dusecbacktrace>. | |
220 | ||
221 | See L<perlhacktips/"C backtrace"> for more information. | |
222 | ||
223 | =head1 Security | |
224 | ||
225 | =head2 Perl is now compiled with C<-fstack-protector-strong> if available | |
226 | ||
227 | Perl has been compiled with the anti-stack-smashing option | |
228 | C<-fstack-protector> since 5.10.1. Now Perl uses the newer variant | |
229 | called C<-fstack-protector-strong>, if available. | |
230 | ||
231 | =head2 The L<Safe> module could allow outside packages to be replaced | |
232 | ||
233 | Critical bugfix: outside packages could be replaced. L<Safe> has | |
234 | been patched to 2.38 to address this. | |
235 | ||
236 | =head2 Perl is now always compiled with C<-D_FORTIFY_SOURCE=2> if available | |
237 | ||
238 | The 'code hardening' option called C<_FORTIFY_SOURCE>, available in | |
239 | gcc 4.*, is now always used for compiling Perl, if available. | |
240 | ||
241 | Note that this isn't necessarily a huge step since in many platforms | |
242 | the step had already been taken several years ago: many Linux | |
243 | distributions (like Fedora) have been using this option for Perl, | |
244 | and OS X has enforced the same for many years. | |
245 | ||
246 | =head1 Incompatible Changes | |
247 | ||
248 | =head2 Subroutine signatures moved before attributes | |
249 | ||
250 | The experimental sub signatures feature, as introduced in 5.20, parsed | |
251 | signatures after attributes. In this release, following feedback from users | |
252 | of the experimental feature, the positioning has been moved such that | |
253 | signatures occur after the subroutine name (if any) and before the attribute | |
254 | list (if any). | |
255 | ||
256 | =head2 C<&> and C<\&> prototypes accepts only subs | |
257 | ||
258 | The C<&> prototype character now accepts only anonymous subs (C<sub | |
259 | {...}>), things beginning with C<\&>, or an explicit C<undef>. Formerly | |
260 | it erroneously also allowed references to arrays, hashes, and lists. | |
261 | L<[perl #4539]|https://rt.perl.org/Ticket/Display.html?id=4539>. | |
262 | L<[perl #123062]|https://rt.perl.org/Ticket/Display.html?id=123062>. | |
263 | L<[perl #123062]|https://rt.perl.org/Ticket/Display.html?id=123475>. | |
264 | ||
265 | In addition, the C<\&> prototype was allowing subroutine calls, whereas | |
266 | now it only allows subroutines: C<&foo> is still permitted as an argument, | |
267 | while C<&foo()> and C<foo()> no longer are. | |
268 | L<[perl #77860]|https://rt.perl.org/Ticket/Display.html?id=77860>. | |
269 | ||
270 | =head2 C<use encoding> is now lexical | |
271 | ||
272 | The L<encoding> pragma's effect is now limited to lexical scope. This | |
273 | pragma is deprecated, but in the meantime, it could adversely affect | |
274 | unrelated modules that are included in the same program; this change | |
275 | fixes that. | |
276 | ||
277 | =head2 List slices returning empty lists | |
278 | ||
279 | List slices now return an empty list only if the original list was empty | |
280 | (or if there are no indices). Formerly, a list slice would return an empty | |
281 | list if all indices fell outside the original list; now it returns a list | |
282 | of C<undef> values in that case. | |
283 | L<[perl #114498]|https://rt.perl.org/Ticket/Display.html?id=114498>. | |
284 | ||
285 | =head2 C<\N{}> with a sequence of multiple spaces is now a fatal error | |
286 | ||
287 | E.g. S<C<\N{TOOE<nbsp>E<nbsp>MANY SPACES}>> or S<C<\N{TRAILING SPACE }>>. | |
288 | This has been deprecated since v5.18. | |
289 | ||
290 | =head2 S<C<use UNIVERSAL '...'>> is now a fatal error | |
291 | ||
292 | Importing functions from C<UNIVERSAL> has been deprecated since v5.12, and | |
293 | is now a fatal error. S<C<use UNIVERSAL>> without any arguments is still | |
294 | allowed. | |
295 | ||
296 | =head2 In double-quotish C<\cI<X>>, I<X> must now be a printable ASCII character | |
297 | ||
298 | In prior releases, failure to do this raised a deprecation warning. | |
299 | ||
300 | =head2 Splitting the tokens C<(?> and C<(*> in regular expressions is now a fatal compilation error. | |
301 | ||
302 | These had been deprecated since v5.18. | |
303 | ||
304 | =head2 C<qr/foo/x> now ignores all Unicode pattern white space | |
305 | ||
306 | The C</x> regular expression modifier allows the pattern to contain | |
307 | white space and comments (both of which are ignored) for improved | |
308 | readability. Until now, not all the white space characters that Unicode | |
309 | designates for this purpose were handled. The additional ones now | |
310 | recognized are: | |
311 | ||
312 | U+0085 NEXT LINE | |
313 | U+200E LEFT-TO-RIGHT MARK | |
314 | U+200F RIGHT-TO-LEFT MARK | |
315 | U+2028 LINE SEPARATOR | |
316 | U+2029 PARAGRAPH SEPARATOR | |
317 | ||
318 | The use of these characters with C</x> outside bracketed character | |
319 | classes and when not preceded by a backslash has raised a deprecation | |
320 | warning since v5.18. Now they will be ignored. | |
321 | ||
322 | =head2 Comment lines within S<C<(?[ ])>> are now ended only by a C<\n> | |
323 | ||
324 | S<C<(?[ ])>> is an experimental feature, introduced in v5.18. It operates | |
325 | as if C</x> is always enabled. But there was a difference: comment | |
326 | lines (following a C<#> character) were terminated by anything matching | |
327 | C<\R> which includes all vertical whitespace, such as form feeds. For | |
328 | consistency, this is now changed to match what terminates comment lines | |
329 | outside S<C<(?[ ])>>, namely a C<\n> (even if escaped), which is the | |
330 | same as what terminates a heredoc string and formats. | |
331 | ||
332 | =head2 C<(?[...])> operators now follow standard Perl precedence | |
333 | ||
334 | This experimental feature allows set operations in regular expression patterns. | |
335 | Prior to this, the intersection operator had the same precedence as the other | |
336 | binary operators. Now it has higher precedence. This could lead to different | |
337 | outcomes than existing code expects (though the documentation has always noted | |
338 | that this change might happen, recommending fully parenthesizing the | |
339 | expressions). See L<perlrecharclass/Extended Bracketed Character Classes>. | |
340 | ||
341 | =head2 Omitting C<%> and C<@> on hash and array names is no longer permitted | |
342 | ||
343 | Really old Perl let you omit the C<@> on array names and the C<%> on hash | |
344 | names in some spots. This has issued a deprecation warning since Perl | |
345 | 5.000, and is no longer permitted. | |
346 | ||
347 | =head2 C<"$!"> text is now in English outside the scope of C<use locale> | |
348 | ||
349 | Previously, the text, unlike almost everything else, always came out | |
350 | based on the current underlying locale of the program. (Also affected | |
351 | on some systems is C<"$^E">.) For programs that are unprepared to | |
352 | handle locale differences, this can cause garbage text to be displayed. | |
353 | It's better to display text that is translatable via some tool than | |
354 | garbage text which is much harder to figure out. | |
355 | ||
356 | =head2 C<"$!"> text will be returned in UTF-8 when appropriate | |
357 | ||
358 | The stringification of C<$!> and C<$^E> will have the UTF-8 flag set | |
359 | when the text is actually non-ASCII UTF-8. This will enable programs | |
360 | that are set up to be locale-aware to properly output messages in the | |
361 | user's native language. Code that needs to continue the 5.20 and | |
362 | earlier behavior can do the stringification within the scopes of both | |
363 | S<C<use bytes>> and S<C<use locale ":messages">>. Within these two | |
364 | scopes, no other Perl operations will | |
365 | be affected by locale; only C<$!> and C<$^E> stringification. The | |
366 | C<bytes> pragma causes the UTF-8 flag to not be set, just as in previous | |
367 | Perl releases. This resolves | |
368 | L<[perl #112208]|https://rt.perl.org/Ticket/Display.html?id=112208>. | |
369 | ||
370 | =head2 Support for C<?PATTERN?> without explicit operator has been removed | |
371 | ||
372 | The C<m?PATTERN?> construct, which allows matching a regex only once, | |
373 | previously had an alternative form that was written directly with a question | |
374 | mark delimiter, omitting the explicit C<m> operator. This usage has produced | |
375 | a deprecation warning since 5.14.0. It is now a syntax error, so that the | |
376 | question mark can be available for use in new operators. | |
377 | ||
378 | =head2 C<defined(@array)> and C<defined(%hash)> are now fatal errors | |
379 | ||
380 | These have been deprecated since v5.6.1 and have raised deprecation | |
381 | warnings since v5.16. | |
382 | ||
383 | =head2 Using a hash or an array as a reference are now fatal errors | |
384 | ||
385 | For example, C<< %foo->{"bar"} >> now causes a fatal compilation | |
386 | error. These have been deprecated since before v5.8, and have raised | |
387 | deprecation warnings since then. | |
388 | ||
389 | =head2 Changes to the C<*> prototype | |
390 | ||
391 | The C<*> character in a subroutine's prototype used to allow barewords to take | |
392 | precedence over most, but not all, subroutine names. It was never | |
393 | consistent and exhibited buggy behavior. | |
394 | ||
395 | Now it has been changed, so subroutines always take precedence over barewords, | |
396 | which brings it into conformity with similarly prototyped built-in functions: | |
397 | ||
398 | sub splat(*) { ... } | |
399 | sub foo { ... } | |
400 | splat(foo); # now always splat(foo()) | |
401 | splat(bar); # still splat('bar') as before | |
402 | close(foo); # close(foo()) | |
403 | close(bar); # close('bar') | |
404 | ||
405 | =head1 Deprecations | |
406 | ||
407 | =head2 Setting C<${^ENCODING}> to anything but C<undef> | |
408 | ||
409 | This variable allows Perl scripts to be written in an encoding other than | |
410 | ASCII or UTF-8. However, it affects all modules globally, leading | |
411 | to wrong answers and segmentation faults. New scripts should be written | |
412 | in UTF-8; old scripts should be converted to UTF-8, which is easily done | |
413 | with the L<piconv> utility. | |
414 | ||
415 | =head2 Use of non-graphic characters in single-character variable names | |
416 | ||
417 | The syntax for single-character variable names is more lenient than | |
418 | for longer variable names, allowing the one-character name to be a | |
419 | punctuation character or even invisible (a non-graphic). Perl v5.20 | |
420 | deprecated the ASCII-range controls as such a name. Now, all | |
421 | non-graphic characters that formerly were allowed are deprecated. | |
422 | The practical effect of this occurs only when not under C<S<use | |
423 | utf8>>, and affects just the C1 controls (code points 0x80 through | |
424 | 0xFF), NO-BREAK SPACE, and SOFT HYPHEN. | |
425 | ||
426 | =head2 Inlining of C<sub () { $var }> with observable side-effects | |
427 | ||
428 | In many cases Perl makes S<C<sub () { $var }>> into an inlinable constant | |
429 | subroutine, capturing the value of C<$var> at the time the C<sub> expression | |
430 | is evaluated. This can break the closure behavior in those cases where | |
431 | C<$var> is subsequently modified, since the subroutine won't return the | |
432 | changed value. (Note that this all only applies to anonymous subroutines | |
433 | with an empty prototype (S<C<sub ()>>).) | |
434 | ||
435 | This usage is now deprecated in those cases where the variable could be | |
436 | modified elsewhere. Perl detects those cases and emits a deprecation | |
437 | warning. Such code will likely change in the future and stop producing a | |
438 | constant. | |
439 | ||
440 | If your variable is only modified in the place where it is declared, then | |
441 | Perl will continue to make the sub inlinable with no warnings. | |
442 | ||
443 | sub make_constant { | |
444 | my $var = shift; | |
445 | return sub () { $var }; # fine | |
446 | } | |
447 | ||
448 | sub make_constant_deprecated { | |
449 | my $var; | |
450 | $var = shift; | |
451 | return sub () { $var }; # deprecated | |
452 | } | |
453 | ||
454 | sub make_constant_deprecated2 { | |
455 | my $var = shift; | |
456 | log_that_value($var); # could modify $var | |
457 | return sub () { $var }; # deprecated | |
458 | } | |
459 | ||
460 | In the second example above, detecting that C<$var> is assigned to only once | |
461 | is too hard to detect. That it happens in a spot other than the C<my> | |
462 | declaration is enough for Perl to find it suspicious. | |
463 | ||
464 | This deprecation warning happens only for a simple variable for the body of | |
465 | the sub. (A C<BEGIN> block or C<use> statement inside the sub is ignored, | |
466 | because it does not become part of the sub's body.) For more complex | |
467 | cases, such as S<C<sub () { do_something() if 0; $var }>> the behavior has | |
468 | changed such that inlining does not happen if the variable is modifiable | |
469 | elsewhere. Such cases should be rare. | |
470 | ||
471 | =head2 Use of multiple C</x> regexp modifiers | |
472 | ||
473 | It is now deprecated to say something like any of the following: | |
474 | ||
475 | qr/foo/xx; | |
476 | /(?xax:foo)/; | |
477 | use re qw(/amxx); | |
478 | ||
479 | That is, now C<x> should only occur once in any string of contiguous | |
480 | regular expression pattern modifiers. We do not believe there are any | |
481 | occurrences of this in all of CPAN. This is in preparation for a future | |
482 | Perl release having C</xx> permit white-space for readability in | |
483 | bracketed character classes (those enclosed in square brackets: | |
484 | C<[...]>). | |
485 | ||
486 | =head2 Using a NO-BREAK space in a character alias for C<\N{...}> is now deprecated | |
487 | ||
488 | This non-graphic character is essentially indistinguishable from a | |
489 | regular space, and so should not be allowed. See | |
490 | L<charnames/CUSTOM ALIASES>. | |
491 | ||
492 | =head2 A literal C<"{"> should now be escaped in a pattern | |
493 | ||
494 | If you want a literal left curly bracket (also called a left brace) in a | |
495 | regular expression pattern, you should now escape it by either | |
496 | preceding it with a backslash (C<"\{">) or enclosing it within square | |
497 | brackets C<"[{]">, or by using C<\Q>; otherwise a deprecation warning | |
498 | will be raised. This was first announced as forthcoming in the v5.16 | |
499 | release; it will allow future extensions to the language to happen. | |
500 | ||
501 | =head2 Making all warnings fatal is discouraged | |
502 | ||
503 | The documentation for L<fatal warnings|warnings/Fatal Warnings> notes that | |
504 | C<< use warnings FATAL => 'all' >> is discouraged, and provides stronger | |
505 | language about the risks of fatal warnings in general. | |
506 | ||
507 | =head1 Performance Enhancements | |
508 | ||
509 | =over 4 | |
510 | ||
511 | =item * | |
512 | ||
513 | If a method or class name is known at compile time, a hash is precomputed | |
514 | to speed up run-time method lookup. Also, compound method names like | |
515 | C<SUPER::new> are parsed at compile time, to save having to parse them at | |
516 | run time. | |
517 | ||
518 | =item * | |
519 | ||
520 | Array and hash lookups (especially nested ones) that use only constants | |
521 | or simple variables as keys, are now considerably faster. See | |
522 | L</Internal Changes> for more details. | |
523 | ||
524 | =item * | |
525 | ||
526 | C<(...)x1>, C<("constant")x0> and C<($scalar)x0> are now optimised in list | |
527 | context. If the right-hand argument is a constant 1, the repetition | |
528 | operator disappears. If the right-hand argument is a constant 0, the whole | |
529 | expression is optimised to the empty list, so long as the left-hand | |
530 | argument is a simple scalar or constant. (That is, C<(foo())x0> is not | |
531 | subject to this optimisation.) | |
532 | ||
533 | =item * | |
534 | ||
535 | C<substr> assignment is now optimised into 4-argument C<substr> at the end | |
536 | of a subroutine (or as the argument to C<return>). Previously, this | |
537 | optimisation only happened in void context. | |
538 | ||
539 | =item * | |
540 | ||
541 | In C<"\L...">, C<"\Q...">, etc., the extra "stringify" op is now optimised | |
542 | away, making these just as fast as C<lcfirst>, C<quotemeta>, etc. | |
543 | ||
544 | =item * | |
545 | ||
546 | Assignment to an empty list is now sometimes faster. In particular, it | |
547 | never calls C<FETCH> on tied arguments on the right-hand side, whereas it | |
548 | used to sometimes. | |
549 | ||
550 | =item * | |
551 | ||
552 | There is a performance improvement of up to 20% when C<length> is applied to | |
553 | a non-magical, non-tied string, and either C<use bytes> is in scope or the | |
554 | string doesn't use UTF-8 internally. | |
555 | ||
556 | =item * | |
557 | ||
558 | On most perl builds with 64-bit integers, memory usage for non-magical, | |
559 | non-tied scalars containing only a floating point value has been reduced | |
560 | by between 8 and 32 bytes, depending on OS. | |
561 | ||
562 | =item * | |
563 | ||
564 | In C<@array = split>, the assignment can be optimized away, so that C<split> | |
565 | writes directly to the array. This optimisation was happening only for | |
566 | package arrays other than C<@_>, and only sometimes. Now this | |
567 | optimisation happens almost all the time. | |
568 | ||
569 | =item * | |
570 | ||
571 | C<join> is now subject to constant folding. So for example | |
572 | S<C<join "-", "a", "b">> is converted at compile-time to C<"a-b">. | |
573 | Moreover, C<join> with a scalar or constant for the separator and a | |
574 | single-item list to join is simplified to a stringification, and the | |
575 | separator doesn't even get evaluated. | |
576 | ||
577 | =item * | |
578 | ||
579 | C<qq(@array)> is implemented using two ops: a stringify op and a join op. | |
580 | If the C<qq> contains nothing but a single array, the stringification is | |
581 | optimized away. | |
582 | ||
583 | =item * | |
584 | ||
585 | S<C<our $var>> and S<C<our($s,@a,%h)>> in void context are no longer evaluated at | |
586 | run time. Even a whole sequence of S<C<our $foo;>> statements will simply be | |
587 | skipped over. The same applies to C<state> variables. | |
588 | ||
589 | =item * | |
590 | ||
591 | Many internal functions have been refactored to improve performance and reduce | |
592 | their memory footprints. | |
593 | L<[perl #121436]|https://rt.perl.org/Ticket/Display.html?id=121436> | |
594 | L<[perl #121906]|https://rt.perl.org/Ticket/Display.html?id=121906> | |
595 | L<[perl #121969]|https://rt.perl.org/Ticket/Display.html?id=121969> | |
596 | ||
597 | =item * | |
598 | ||
599 | C<-T> and C<-B> filetests will return sooner when an empty file is detected. | |
600 | L<[perl #121489]|https://rt.perl.org/Ticket/Display.html?id=121489> | |
601 | ||
602 | =item * | |
603 | ||
604 | Hash lookups where the key is a constant are faster. | |
605 | ||
606 | =item * | |
607 | ||
608 | Subroutines with an empty prototype and a body containing just C<undef> are now | |
609 | eligible for inlining. | |
610 | L<[perl #122728]|https://rt.perl.org/Ticket/Display.html?id=122728> | |
611 | ||
612 | =item * | |
613 | ||
614 | Subroutines in packages no longer need to be stored in typeglobs: | |
615 | declaring a subroutine will now put a simple sub reference directly in the | |
616 | stash if possible, saving memory. The typeglob still notionally exists, | |
617 | so accessing it will cause the stash entry to be upgraded to a typeglob | |
618 | (I<i.e.> this is just an internal implementation detail). | |
619 | This optimization does not currently apply to XSUBs or exported | |
620 | subroutines, and method calls will undo it, since they cache things in | |
621 | typeglobs. | |
622 | L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> | |
623 | ||
624 | =item * | |
625 | ||
626 | The functions C<utf8::native_to_unicode()> and C<utf8::unicode_to_native()> | |
627 | (see L<utf8>) are now optimized out on ASCII platforms. There is now not even | |
628 | a minimal performance hit in writing code portable between ASCII and EBCDIC | |
629 | platforms. | |
630 | ||
631 | =item * | |
632 | ||
633 | Win32 Perl uses 8 KB less of per-process memory than before for every perl | |
634 | process, because some data is now memory mapped from disk and shared | |
635 | between processes from the same perl binary. | |
636 | ||
637 | =back | |
638 | ||
639 | =head1 Modules and Pragmata | |
640 | ||
641 | =head2 Updated Modules and Pragmata | |
642 | ||
643 | Many of the libraries distributed with perl have been upgraded since v5.20.0. | |
644 | For a complete list of changes, run: | |
645 | ||
646 | corelist --diff 5.20.0 5.22.0 | |
647 | ||
648 | You can substitute your favorite version in place of 5.20.0, too. | |
649 | ||
650 | Some notable changes include: | |
651 | ||
652 | =over 4 | |
653 | ||
654 | =item * | |
655 | ||
656 | L<Archive::Tar> has been upgraded to version 2.04. | |
657 | ||
658 | Tests can now be run in parallel. | |
659 | ||
660 | =item * | |
661 | ||
662 | L<attributes> has been upgraded to version 0.27. | |
663 | ||
664 | The usage of C<memEQs> in the XS has been corrected. | |
665 | L<[perl #122701]|https://rt.perl.org/Ticket/Display.html?id=122701> | |
666 | ||
667 | Avoid reading beyond the end of a buffer. [perl #122629] | |
668 | ||
669 | =item * | |
670 | ||
671 | L<B> has been upgraded to version 1.58. | |
672 | ||
673 | It provides a new C<B::safename> function, based on the existing | |
674 | C<< B::GV->SAFENAME >>, that converts C<\cOPEN> to C<^OPEN>. | |
675 | ||
676 | Nulled COPs are now of class C<B::COP>, rather than C<B::OP>. | |
677 | ||
678 | C<B::REGEXP> objects now provide a C<qr_anoncv> method for accessing the | |
679 | implicit CV associated with C<qr//> things containing code blocks, and a | |
680 | C<compflags> method that returns the pertinent flags originating from the | |
681 | C<qr//blahblah> op. | |
682 | ||
683 | C<B::PMOP> now provides a C<pmregexp> method returning a C<B::REGEXP> object. | |
684 | Two new classes, C<B::PADNAME> and C<B::PADNAMELIST>, have been introduced. | |
685 | ||
686 | A bug where, after an ithread creation or psuedofork, special/immortal SVs in | |
687 | the child ithread/psuedoprocess did not have the correct class of | |
688 | C<B::SPECIAL>, has been fixed. | |
689 | The C<id> and C<outid> PADLIST methods have been added. | |
690 | ||
691 | =item * | |
692 | ||
693 | L<B::Concise> has been upgraded to version 0.996. | |
694 | ||
695 | Null ops that are part of the execution chain are now given sequence | |
696 | numbers. | |
697 | ||
698 | Private flags for nulled ops are now dumped with mnemonics as they would be | |
699 | for the non-nulled counterparts. | |
700 | ||
701 | =item * | |
702 | ||
703 | L<B::Deparse> has been upgraded to version 1.35. | |
704 | ||
705 | It now deparses C<+sub : attr { ... }> correctly at the start of a | |
706 | statement. Without the initial C<+>, C<sub> would be a statement label. | |
707 | ||
708 | C<BEGIN> blocks are now emitted in the right place most of the time, but | |
709 | the change unfortunately introduced a regression, in that C<BEGIN> blocks | |
710 | occurring just before the end of the enclosing block may appear below it | |
711 | instead. | |
712 | ||
713 | C<B::Deparse> no longer puts erroneous C<local> here and there, such as for | |
714 | C<LIST = tr/a//d>. [perl #119815] | |
715 | ||
716 | Adjacent C<use> statements are no longer accidentally nested if one | |
717 | contains a C<do> block. [perl #115066] | |
718 | ||
719 | Parenthesised arrays in lists passed to C<\> are now correctly deparsed | |
720 | with parentheses (I<e.g.>, C<\(@a, (@b), @c)> now retains the parentheses | |
721 | around @b), thus preserving the flattening behavior of referenced | |
722 | parenthesised arrays. Formerly, it only worked for one array: C<\(@a)>. | |
723 | ||
724 | C<local our> is now deparsed correctly, with the C<our> included. | |
725 | ||
726 | C<for($foo; !$bar; $baz) {...}> was deparsed without the C<!> (or C<not>). | |
727 | This has been fixed. | |
728 | ||
729 | Core keywords that conflict with lexical subroutines are now deparsed with | |
730 | the C<CORE::> prefix. | |
731 | ||
732 | C<foreach state $x (...) {...}> now deparses correctly with C<state> and | |
733 | not C<my>. | |
734 | ||
735 | C<our @array = split(...)> now deparses correctly with C<our> in those | |
736 | cases where the assignment is optimized away. | |
737 | ||
738 | It now deparses C<our(I<LIST>)> and typed lexical (C<my Dog $spot>) correctly. | |
739 | ||
740 | Deparse C<$#_> as that instead of as C<$#{_}>. | |
741 | L<[perl #123947]|https://rt.perl.org/Ticket/Display.html?id=123947> | |
742 | ||
743 | BEGIN blocks at the end of the enclosing scope are now deparsed in the | |
744 | right place. [perl #77452] | |
745 | ||
746 | BEGIN blocks were sometimes deparsed as __ANON__, but are now always called | |
747 | BEGIN. | |
748 | ||
749 | Lexical subroutines are now fully deparsed. [perl #116553] | |
750 | ||
751 | C<Anything =~ y///r> with C</r> no longer omits the left-hand operand. | |
752 | ||
753 | The op trees that make up regexp code blocks are now deparsed for real. | |
754 | Formerly, the original string that made up the regular expression was used. | |
755 | That caused problems with C<qr/(?{E<lt>E<lt>heredoc})/> and multiline code blocks, | |
756 | which were deparsed incorrectly. [perl #123217] [perl #115256] | |
757 | ||
758 | C<$;> at the end of a statement no longer loses its semicolon. | |
759 | [perl #123357] | |
760 | ||
761 | Some cases of subroutine declarations stored in the stash in shorthand form | |
762 | were being omitted. | |
763 | ||
764 | Non-ASCII characters are now consistently escaped in strings, instead of | |
765 | some of the time. (There are still outstanding problems with regular | |
766 | expressions and identifiers that have not been fixed.) | |
767 | ||
768 | When prototype sub calls are deparsed with C<&> (I<e.g.>, under the B<-P> | |
769 | option), C<scalar> is now added where appropriate, to force the scalar | |
770 | context implied by the prototype. | |
771 | ||
772 | C<require(foo())>, C<do(foo())>, C<goto(foo())> and similar constructs with | |
773 | loop controls are now deparsed correctly. The outer parentheses are not | |
774 | optional. | |
775 | ||
776 | Whitespace is no longer escaped in regular expressions, because it was | |
777 | getting erroneously escaped within C<(?x:...)> sections. | |
778 | ||
779 | C<sub foo { foo() }> is now deparsed with those mandatory parentheses. | |
780 | ||
781 | C</@array/> is now deparsed as a regular expression, and not just | |
782 | C<@array>. | |
783 | ||
784 | C</@{-}/>, C</@{+}/> and C<$#{1}> are now deparsed with the braces, which | |
785 | are mandatory in these cases. | |
786 | ||
787 | In deparsing feature bundles, C<B::Deparse> was emitting C<no feature;> first | |
788 | instead of C<no feature ':all';>. This has been fixed. | |
789 | ||
790 | C<chdir FH> is now deparsed without quotation marks. | |
791 | ||
792 | C<\my @a> is now deparsed without parentheses. (Parenthese would flatten | |
793 | the array.) | |
794 | ||
795 | C<system> and C<exec> followed by a block are now deparsed correctly. | |
796 | Formerly there was an erroneous C<do> before the block. | |
797 | ||
798 | C<< use constant QR =E<gt> qr/.../flags >> followed by C<"" =~ QR> is no longer | |
799 | without the flags. | |
800 | ||
801 | Deparsing C<BEGIN { undef &foo }> with the B<-w> switch enabled started to | |
802 | emit 'uninitialized' warnings in Perl 5.14. This has been fixed. | |
803 | ||
804 | Deparsing calls to subs with a C<(;+)> prototype resulted in an infinite | |
805 | loop. The C<(;$>) C<(_)> and C<(;_)> prototypes were given the wrong | |
806 | precedence, causing C<foo($aE<lt>$b)> to be deparsed without the parentheses. | |
807 | ||
808 | Deparse now provides a defined state sub in inner subs. | |
809 | ||
810 | =item * | |
811 | ||
812 | L<B::Op_private> has been added. | |
813 | ||
814 | L<B::Op_private> provides detailed information about the flags used in the | |
815 | C<op_private> field of perl opcodes. | |
816 | ||
817 | =item * | |
818 | ||
819 | L<bigint>, L<bignum>, L<bigrat> have been upgraded to version 0.39. | |
820 | ||
821 | Document in CAVEATS that using strings as numbers won't always invoke | |
822 | the big number overloading, and how to invoke it. [rt.perl.org #123064] | |
823 | ||
824 | =item * | |
825 | ||
826 | L<Carp> has been upgraded to version 1.36. | |
827 | ||
828 | C<Carp::Heavy> now ignores version mismatches with Carp if Carp is newer | |
829 | than 1.12, since C<Carp::Heavy>'s guts were merged into Carp at that | |
830 | point. | |
831 | L<[perl #121574]|https://rt.perl.org/Ticket/Display.html?id=121574> | |
832 | ||
833 | Carp now handles non-ASCII platforms better. | |
834 | ||
835 | Off-by-one error fix for Perl E<lt> 5.14. | |
836 | ||
837 | =item * | |
838 | ||
839 | L<constant> has been upgraded to version 1.33. | |
840 | ||
841 | It now accepts fully-qualified constant names, allowing constants to be defined | |
842 | in packages other than the caller. | |
843 | ||
844 | =item * | |
845 | ||
846 | L<CPAN> has been upgraded to version 2.11. | |
847 | ||
848 | Add support for C<Cwd::getdcwd()> and introduce workaround for a misbehavior | |
849 | seen on Strawberry Perl 5.20.1. | |
850 | ||
851 | Fix C<chdir()> after building dependencies bug. | |
852 | ||
853 | Introduce experimental support for plugins/hooks. | |
854 | ||
855 | Integrate the C<App::Cpan> sources. | |
856 | ||
857 | Do not check recursion on optional dependencies. | |
858 | ||
859 | Sanity check F<META.yml> to contain a hash. | |
860 | L<[cpan #95271]|https://rt.cpan.org/Ticket/Display.html?id=95271> | |
861 | ||
862 | =item * | |
863 | ||
864 | L<CPAN::Meta::Requirements> has been upgraded to version 2.132. | |
865 | ||
866 | Works around limitations in C<version::vpp> detecting v-string magic and adds | |
867 | support for forthcoming L<ExtUtils::MakeMaker> bootstrap F<version.pm> for | |
868 | Perls older than 5.10.0. | |
869 | ||
870 | =item * | |
871 | ||
872 | L<Data::Dumper> has been upgraded to version 2.158. | |
873 | ||
874 | Fixes CVE-2014-4330 by adding a configuration variable/option to limit | |
875 | recursion when dumping deep data structures. | |
876 | ||
877 | Changes to resolve Coverity issues. | |
878 | XS dumps incorrectly stored the name of code references stored in a | |
879 | GLOB. | |
880 | L<[perl #122070]|https://rt.perl.org/Ticket/Display.html?id=122070> | |
881 | ||
882 | =item * | |
883 | ||
884 | L<DynaLoader> has been upgraded to version 1.32. | |
885 | ||
886 | Remove C<dl_nonlazy> global if unused in Dynaloader. [perl #122926] | |
887 | ||
888 | =item * | |
889 | ||
890 | L<Encode> has been upgraded to version 2.72. | |
891 | ||
892 | C<piconv> now has better error handling when the encoding name is nonexistent, | |
893 | and a build breakage when upgrading L<Encode> in perl-5.8.2 and earlier has | |
894 | been fixed. | |
895 | ||
896 | Building in C++ mode on Windows now works. | |
897 | ||
898 | =item * | |
899 | ||
900 | L<Errno> has been upgraded to version 1.23. | |
901 | ||
902 | Add C<-P> to the preprocessor command-line on GCC 5. GCC added extra | |
903 | line directives, breaking parsing of error code definitions. [rt.perl.org | |
904 | #123784] | |
905 | ||
906 | =item * | |
907 | ||
908 | L<experimental> has been upgraded to version 0.013. | |
909 | ||
910 | Hardcodes features for Perls older than 5.15.7. | |
911 | ||
912 | =item * | |
913 | ||
914 | L<ExtUtils::CBuilder> has been upgraded to version 0.280221. | |
915 | ||
916 | Fixes a regression on Android. | |
917 | L<[perl #122675]|https://rt.perl.org/Ticket/Display.html?id=122675> | |
918 | ||
919 | =item * | |
920 | ||
921 | L<ExtUtils::Manifest> has been upgraded to version 1.70. | |
922 | ||
923 | Fixes a bug with C<maniread()>'s handling of quoted filenames and improves | |
924 | C<manifind()> to follow symlinks. | |
925 | L<[perl #122415]|https://rt.perl.org/Ticket/Display.html?id=122415> | |
926 | ||
927 | =item * | |
928 | ||
929 | L<ExtUtils::ParseXS> has been upgraded to version 3.28. | |
930 | ||
931 | Only declare C<file> unused if we actually define it. | |
932 | Improve generated C<RETVAL> code generation to avoid repeated | |
933 | references to C<ST(0)>. [perl #123278] | |
934 | Broaden and document the C</OBJ$/> to C</REF$/> typemap optimization | |
935 | for the C<DESTROY> method. [perl #123418] | |
936 | ||
937 | =item * | |
938 | ||
939 | L<Fcntl> has been upgraded to version 1.13. | |
940 | ||
941 | Add support for the Linux pipe buffer size C<fcntl()> commands. | |
942 | ||
943 | =item * | |
944 | ||
945 | L<File::Find> has been upgraded to version 1.29. | |
946 | ||
947 | C<find()> and C<finddepth()> will now warn if passed inappropriate or | |
948 | misspelled options. | |
949 | ||
950 | =item * | |
951 | ||
952 | L<File::Glob> has been upgraded to version 1.24. | |
953 | ||
954 | Avoid C<SvIV()> expanding to call C<get_sv()> three times in a few | |
955 | places. [perl #123606] | |
956 | ||
957 | =item * | |
958 | ||
959 | L<HTTP::Tiny> has been upgraded to version 0.054. | |
960 | ||
961 | C<keep_alive> is now fork-safe and thread-safe. | |
962 | ||
963 | =item * | |
964 | ||
965 | L<IO> has been upgraded to version 1.35. | |
966 | ||
967 | The XS implementation has been fixed for the sake of older Perls. | |
968 | ||
969 | =item * | |
970 | ||
971 | L<IO::Socket> has been upgraded to version 1.38. | |
972 | ||
973 | Document the limitations of the C<connected()> method. [perl #123096] | |
974 | ||
975 | =item * | |
976 | ||
977 | L<IO::Socket::IP> has been upgraded to version 0.37. | |
978 | ||
979 | A better fix for subclassing C<connect()>. | |
980 | L<[cpan #95983]|https://rt.cpan.org/Ticket/Display.html?id=95983> | |
981 | L<[cpan #97050]|https://rt.cpan.org/Ticket/Display.html?id=97050> | |
982 | ||
983 | Implements Timeout for C<connect()>. | |
984 | L<[cpan #92075]|https://rt.cpan.org/Ticket/Display.html?id=92075> | |
985 | ||
986 | =item * | |
987 | ||
988 | The libnet collection of modules has been upgraded to version 3.05. | |
989 | ||
990 | Support for IPv6 and SSL to C<Net::FTP>, C<Net::NNTP>, C<Net::POP3> and C<Net::SMTP>. | |
991 | Improvements in C<Net::SMTP> authentication. | |
992 | ||
993 | =item * | |
994 | ||
995 | L<Locale::Codes> has been upgraded to version 3.34. | |
996 | ||
997 | Fixed a bug in the scripts used to extract data from spreadsheets that | |
998 | prevented the SHP currency code from being found. | |
999 | L<[cpan #94229]|https://rt.cpan.org/Ticket/Display.html?id=94229> | |
1000 | ||
1001 | New codes have been added. | |
1002 | ||
1003 | =item * | |
1004 | ||
1005 | L<Math::BigInt> has been upgraded to version 1.9997. | |
1006 | ||
1007 | Synchronize POD changes from the CPAN release. | |
1008 | C<< Math::BigFloat->blog(x) >> would sometimes return C<blog(2*x)> when | |
1009 | the accuracy was greater than 70 digits. | |
1010 | The result of C<< Math::BigFloat->bdiv() >> in list context now | |
1011 | satisfies C<< x = quotient * divisor + remainder >>. | |
1012 | ||
1013 | Correct handling of subclasses. | |
1014 | L<[cpan #96254]|https://rt.cpan.org/Ticket/Display.html?id=96254> | |
1015 | L<[cpan #96329]|https://rt.cpan.org/Ticket/Display.html?id=96329> | |
1016 | ||
1017 | =item * | |
1018 | ||
1019 | L<Module::Metadata> has been upgraded to version 1.000026. | |
1020 | ||
1021 | Support installations on older perls with an L<ExtUtils::MakeMaker> earlier | |
1022 | than 6.63_03 | |
1023 | ||
1024 | =item * | |
1025 | ||
1026 | L<overload> has been upgraded to version 1.26. | |
1027 | ||
1028 | A redundant C<ref $sub> check has been removed. | |
1029 | ||
1030 | =item * | |
1031 | ||
1032 | The PathTools module collection has been upgraded to version 3.56. | |
1033 | ||
1034 | A warning from the B<gcc> compiler is now avoided when building the XS. | |
1035 | ||
1036 | Don't turn leading C<//> into C</> on Cygwin. [perl #122635] | |
1037 | ||
1038 | =item * | |
1039 | ||
1040 | L<perl5db.pl> has been upgraded to version 1.49. | |
1041 | ||
1042 | The debugger would cause an assertion failure. | |
1043 | L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127> | |
1044 | ||
1045 | C<fork()> in the debugger under C<tmux> will now create a new window for | |
1046 | the forked process. L<[perl | |
1047 | #121333]|https://rt.perl.org/Ticket/Display.html?id=121333> | |
1048 | ||
1049 | The debugger now saves the current working directory on startup and | |
1050 | restores it when you restart your program with C<R> or C<rerun>. L<[perl | |
1051 | #121509]|https://rt.perl.org/Ticket/Display.html?id=121509> | |
1052 | ||
1053 | =item * | |
1054 | ||
1055 | L<PerlIO::scalar> has been upgraded to version 0.22. | |
1056 | ||
1057 | Reading from a position well past the end of the scalar now correctly | |
1058 | returns end of file. [perl #123443] | |
1059 | ||
1060 | Seeking to a negative position still fails, but no longer leaves the | |
1061 | file position set to a negation location. | |
1062 | ||
1063 | C<eof()> on a C<PerlIO::scalar> handle now properly returns true when | |
1064 | the file position is past the 2GB mark on 32-bit systems. | |
1065 | ||
1066 | Attempting to write at file positions impossible for the platform now | |
1067 | fail early rather than wrapping at 4GB. | |
1068 | ||
1069 | =item * | |
1070 | ||
1071 | L<Pod::Perldoc> has been upgraded to version 3.25. | |
1072 | ||
1073 | Filehandles opened for reading or writing now have C<:encoding(UTF-8)> set. | |
1074 | L<[cpan #98019]|https://rt.cpan.org/Ticket/Display.html?id=98019> | |
1075 | ||
1076 | =item * | |
1077 | ||
1078 | L<POSIX> has been upgraded to version 1.53. | |
1079 | ||
1080 | The C99 math functions and constants (for example C<acosh>, C<isinf>, C<isnan>, C<round>, | |
1081 | C<trunc>; C<M_E>, C<M_SQRT2>, C<M_PI>) have been added. | |
1082 | ||
1083 | C<POSIX::tmpnam()> now produces a deprecation warning. [perl #122005] | |
1084 | ||
1085 | =item * | |
1086 | ||
1087 | L<Safe> has been upgraded to version 2.39. | |
1088 | ||
1089 | C<reval> was not propagating void context properly. | |
1090 | ||
1091 | =item * | |
1092 | ||
1093 | Scalar-List-Utils has been upgraded to version 1.41. | |
1094 | ||
1095 | A new module, L<Sub::Util>, has been added, containing functions related to | |
1096 | CODE refs, including C<subname> (inspired by C<Sub::Identity>) and C<set_subname> | |
1097 | (copied and renamed from C<Sub::Name>). | |
1098 | The use of C<GetMagic> in C<List::Util::reduce()> has also been fixed. | |
1099 | L<[cpan #63211]|https://rt.cpan.org/Ticket/Display.html?id=63211> | |
1100 | ||
1101 | =item * | |
1102 | ||
1103 | L<SDBM_File> has been upgraded to version 1.13. | |
1104 | ||
1105 | Simplified the build process. [perl #123413] | |
1106 | ||
1107 | =item * | |
1108 | ||
1109 | L<Time::Piece> has been upgraded to version 1.29. | |
1110 | ||
1111 | When pretty printing negative C<Time::Seconds>, the "minus" is no longer lost. | |
1112 | ||
1113 | =item * | |
1114 | ||
1115 | L<Unicode::Collate> has been upgraded to version 1.12. | |
1116 | ||
1117 | Version 0.67's improved discontiguous contractions is invalidated by default | |
1118 | and is supported as a parameter C<long_contraction>. | |
1119 | ||
1120 | =item * | |
1121 | ||
1122 | L<Unicode::Normalize> has been upgraded to version 1.18. | |
1123 | ||
1124 | The XSUB implementation has been removed in favor of pure Perl. | |
1125 | ||
1126 | =item * | |
1127 | ||
1128 | L<Unicode::UCD> has been upgraded to version 0.61. | |
1129 | ||
1130 | A new function L<property_values()|Unicode::UCD/prop_values()> | |
1131 | has been added to return a given property's possible values. | |
1132 | ||
1133 | A new function L<charprop()|Unicode::UCD/charprop()> | |
1134 | has been added to return the value of a given property for a given code | |
1135 | point. | |
1136 | ||
1137 | A new function L<charprops_all()|Unicode::UCD/charprops_all()> | |
1138 | has been added to return the values of all Unicode properties for a | |
1139 | given code point. | |
1140 | ||
1141 | A bug has been fixed so that L<propaliases()|Unicode::UCD/prop_aliases()> | |
1142 | returns the correct short and long names for the Perl extensions where | |
1143 | it was incorrect. | |
1144 | ||
1145 | A bug has been fixed so that | |
1146 | L<prop_value_aliases()|Unicode::UCD/prop_value_aliases()> | |
1147 | returns C<undef> instead of a wrong result for properties that are Perl | |
1148 | extensions. | |
1149 | ||
1150 | This module now works on EBCDIC platforms. | |
1151 | ||
1152 | =item * | |
1153 | ||
1154 | L<utf8> has been upgraded to version 1.17 | |
1155 | ||
1156 | A mismatch between the documentation and the code in C<utf8::downgrade()> | |
1157 | was fixed in favor of the documentation. The optional second argument | |
1158 | is now correctly treated as a perl boolean (true/false semantics) and | |
1159 | not as an integer. | |
1160 | ||
1161 | =item * | |
1162 | ||
1163 | L<version> has been upgraded to version 0.9909. | |
1164 | ||
1165 | Numerous changes. See the F<Changes> file in the CPAN distribution for | |
1166 | details. | |
1167 | ||
1168 | =item * | |
1169 | ||
1170 | L<Win32> has been upgraded to version 0.51. | |
1171 | ||
1172 | C<GetOSName()> now supports Windows 8.1, and building in C++ mode now works. | |
1173 | ||
1174 | =item * | |
1175 | ||
1176 | L<Win32API::File> has been upgraded to version 0.1202 | |
1177 | ||
1178 | Building in C++ mode now works. | |
1179 | ||
1180 | =item * | |
1181 | ||
1182 | L<XSLoader> has been upgraded to version 0.20. | |
1183 | ||
1184 | Allow XSLoader to load modules from a different namespace. | |
1185 | [perl #122455] | |
1186 | ||
1187 | =back | |
1188 | ||
1189 | =head2 Removed Modules and Pragmata | |
1190 | ||
1191 | The following modules (and associated modules) have been removed from the core | |
1192 | perl distribution: | |
1193 | ||
1194 | =over 4 | |
1195 | ||
1196 | =item * | |
1197 | ||
1198 | L<CGI> | |
1199 | ||
1200 | =item * | |
1201 | ||
1202 | L<Module::Build> | |
1203 | ||
1204 | =back | |
1205 | ||
1206 | =head1 Documentation | |
1207 | ||
1208 | =head2 New Documentation | |
1209 | ||
1210 | =head3 L<perlunicook> | |
1211 | ||
1212 | This document, by Tom Christiansen, provides examples of handling Unicode in | |
1213 | Perl. | |
1214 | ||
1215 | =head2 Changes to Existing Documentation | |
1216 | ||
1217 | =head3 L<perlaix> | |
1218 | ||
1219 | =over 4 | |
1220 | ||
1221 | =item * | |
1222 | ||
1223 | A note on long doubles has been added. | |
1224 | ||
1225 | =back | |
1226 | ||
1227 | ||
1228 | =head3 L<perlapi> | |
1229 | ||
1230 | =over 4 | |
1231 | ||
1232 | =item * | |
1233 | ||
1234 | Note that C<SvSetSV> doesn't do set magic. | |
1235 | ||
1236 | =item * | |
1237 | ||
1238 | C<sv_usepvn_flags> - fix documentation to mention the use of C<Newx> instead of | |
1239 | C<malloc>. | |
1240 | ||
1241 | L<[perl #121869]|https://rt.perl.org/Ticket/Display.html?id=121869> | |
1242 | ||
1243 | =item * | |
1244 | ||
1245 | Clarify where C<NUL> may be embedded or is required to terminate a string. | |
1246 | ||
1247 | =item * | |
1248 | ||
1249 | Some documentation that was previously missing due to formatting errors is | |
1250 | now included. | |
1251 | ||
1252 | =item * | |
1253 | ||
1254 | Entries are now organized into groups rather than by the file where they | |
1255 | are found. | |
1256 | ||
1257 | =item * | |
1258 | ||
1259 | Alphabetical sorting of entries is now done consistently (automatically | |
1260 | by the POD generator) to make entries easier to find when scanning. | |
1261 | ||
1262 | =back | |
1263 | ||
1264 | =head3 L<perldata> | |
1265 | ||
1266 | =over 4 | |
1267 | ||
1268 | =item * | |
1269 | ||
1270 | The syntax of single-character variable names has been brought | |
1271 | up-to-date and more fully explained. | |
1272 | ||
1273 | =item * | |
1274 | ||
1275 | Hexadecimal floating point numbers are described, as are infinity and | |
1276 | NaN. | |
1277 | ||
1278 | =back | |
1279 | ||
1280 | =head3 L<perlebcdic> | |
1281 | ||
1282 | =over 4 | |
1283 | ||
1284 | =item * | |
1285 | ||
1286 | This document has been significantly updated in the light of recent | |
1287 | improvements to EBCDIC support. | |
1288 | ||
1289 | =back | |
1290 | ||
1291 | =head3 L<perlfilter> | |
1292 | ||
1293 | =over 4 | |
1294 | ||
1295 | =item * | |
1296 | ||
1297 | Added a L<LIMITATIONS|perlfilter/LIMITATIONS> section. | |
1298 | ||
1299 | =back | |
1300 | ||
1301 | ||
1302 | =head3 L<perlfunc> | |
1303 | ||
1304 | =over 4 | |
1305 | ||
1306 | =item * | |
1307 | ||
1308 | Mention that C<study()> is currently a no-op. | |
1309 | ||
1310 | =item * | |
1311 | ||
1312 | Calling C<delete> or C<exists> on array values is now described as "strongly | |
1313 | discouraged" rather than "deprecated". | |
1314 | ||
1315 | =item * | |
1316 | ||
1317 | Improve documentation of C<< our >>. | |
1318 | ||
1319 | =item * | |
1320 | ||
1321 | C<-l> now notes that it will return false if symlinks aren't supported by the | |
1322 | file system. | |
1323 | L<[perl #121523]|https://rt.perl.org/Ticket/Display.html?id=121523> | |
1324 | ||
1325 | =item * | |
1326 | ||
1327 | Note that C<exec LIST> and C<system LIST> may fall back to the shell on | |
1328 | Win32. Only the indirect-object syntax C<exec PROGRAM LIST> and | |
1329 | C<system PROGRAM LIST> will reliably avoid using the shell. | |
1330 | ||
1331 | This has also been noted in L<perlport>. | |
1332 | ||
1333 | L<[perl #122046]|https://rt.perl.org/Ticket/Display.html?id=122046> | |
1334 | ||
1335 | =back | |
1336 | ||
1337 | =head3 L<perlguts> | |
1338 | ||
1339 | =over 4 | |
1340 | ||
1341 | =item * | |
1342 | ||
1343 | The OOK example has been updated to account for COW changes and a change in the | |
1344 | storage of the offset. | |
1345 | ||
1346 | =item * | |
1347 | ||
1348 | Details on C level symbols and libperl.t added. | |
1349 | ||
1350 | =item * | |
1351 | ||
1352 | Information on Unicode handling has been added | |
1353 | ||
1354 | =item * | |
1355 | ||
1356 | Information on EBCDIC handling has been added | |
1357 | ||
1358 | =back | |
1359 | ||
1360 | =head3 L<perlhack> | |
1361 | ||
1362 | =over 4 | |
1363 | ||
1364 | =item * | |
1365 | ||
1366 | A note has been added about running on platforms with non-ASCII | |
1367 | character sets | |
1368 | ||
1369 | =item * | |
1370 | ||
1371 | A note has been added about performance testing | |
1372 | ||
1373 | =back | |
1374 | ||
1375 | =head3 L<perlhacktips> | |
1376 | ||
1377 | =over 4 | |
1378 | ||
1379 | =item * | |
1380 | ||
1381 | Documentation has been added illustrating the perils of assuming that | |
1382 | there is no change to the contents of static memory pointed to by the | |
1383 | return values of Perl's wrappers for C library functions. | |
1384 | ||
1385 | =item * | |
1386 | ||
1387 | Replacements for C<tmpfile>, C<atoi>, C<strtol>, and C<strtoul> are now | |
1388 | recommended. | |
1389 | ||
1390 | =item * | |
1391 | ||
1392 | Updated documentation for the C<test.valgrind> C<make> target. | |
1393 | L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> | |
1394 | ||
1395 | =item * | |
1396 | ||
1397 | Information is given about writing test files portably to non-ASCII | |
1398 | platforms. | |
1399 | ||
1400 | =item * | |
1401 | ||
1402 | A note has been added about how to get a C language stack backtrace. | |
1403 | ||
1404 | =back | |
1405 | ||
1406 | =head3 L<perlhpux> | |
1407 | ||
1408 | =over 4 | |
1409 | ||
1410 | =item * | |
1411 | ||
1412 | Note that the message "Redeclaration of "sendpath" with a different | |
1413 | storage class specifier" is harmless. | |
1414 | ||
1415 | =back | |
1416 | ||
1417 | =head3 L<perllocale> | |
1418 | ||
1419 | =over 4 | |
1420 | ||
1421 | =item * | |
1422 | ||
1423 | Updated for the enhancements in v5.22, along with some clarifications. | |
1424 | ||
1425 | =back | |
1426 | ||
1427 | =head3 L<perlmodstyle> | |
1428 | ||
1429 | =over 4 | |
1430 | ||
1431 | =item * | |
1432 | ||
1433 | Instead of pointing to the module list, we are now pointing to | |
1434 | L<PrePAN|http://prepan.org/>. | |
1435 | ||
1436 | =back | |
1437 | ||
1438 | =head3 L<perlop> | |
1439 | ||
1440 | =over 4 | |
1441 | ||
1442 | =item * | |
1443 | ||
1444 | Updated for the enhancements in v5.22, along with some clarifications. | |
1445 | ||
1446 | =back | |
1447 | ||
1448 | =head3 L<perlpodspec> | |
1449 | ||
1450 | =over 4 | |
1451 | ||
1452 | =item * | |
1453 | ||
1454 | The specification of the pod language is changing so that the default | |
1455 | encoding of pods that aren't in UTF-8 (unless otherwise indicated) is | |
1456 | CP1252 instead of ISO 8859-1 (Latin1). | |
1457 | ||
1458 | =back | |
1459 | ||
1460 | =head3 L<perlpolicy> | |
1461 | ||
1462 | =over 4 | |
1463 | ||
1464 | =item * | |
1465 | ||
1466 | We now have a code of conduct for the I<< p5p >> mailing list, as documented | |
1467 | in L<< perlpolicy/STANDARDS OF CONDUCT >>. | |
1468 | ||
1469 | =item * | |
1470 | ||
1471 | The conditions for marking an experimental feature as non-experimental are now | |
1472 | set out. | |
1473 | ||
1474 | =item * | |
1475 | ||
1476 | Clarification has been made as to what sorts of changes are permissible in | |
1477 | maintenance releases. | |
1478 | ||
1479 | =back | |
1480 | ||
1481 | =head3 L<perlport> | |
1482 | ||
1483 | =over 4 | |
1484 | ||
1485 | =item * | |
1486 | ||
1487 | Out-of-date VMS-specific information has been fixed and/or simplified. | |
1488 | ||
1489 | =item * | |
1490 | ||
1491 | Notes about EBCDIC have been added. | |
1492 | ||
1493 | =back | |
1494 | ||
1495 | =head3 L<perlre> | |
1496 | ||
1497 | =over 4 | |
1498 | ||
1499 | =item * | |
1500 | ||
1501 | The description of the C</x> modifier has been clarified to note that | |
1502 | comments cannot be continued onto the next line by escaping them; and | |
1503 | there is now a list of all the characters that are considered whitespace | |
1504 | by this modifier. | |
1505 | ||
1506 | =item * | |
1507 | ||
1508 | The new C</n> modifier is described. | |
1509 | ||
1510 | =item * | |
1511 | ||
1512 | A note has been added on how to make bracketed character class ranges | |
1513 | portable to non-ASCII machines. | |
1514 | ||
1515 | =back | |
1516 | ||
1517 | =head3 L<perlrebackslash> | |
1518 | ||
1519 | =over 4 | |
1520 | ||
1521 | =item * | |
1522 | ||
1523 | Added documentation of C<\b{sb}>, C<\b{wb}>, C<\b{gcb}>, and C<\b{g}>. | |
1524 | ||
1525 | =back | |
1526 | ||
1527 | =head3 L<perlrecharclass> | |
1528 | ||
1529 | =over 4 | |
1530 | ||
1531 | =item * | |
1532 | ||
1533 | Clarifications have been added to L<perlrecharclass/Character Ranges> | |
1534 | to the effect C<[A-Z]>, C<[a-z]>, C<[0-9]> and | |
1535 | any subranges thereof in regular expression bracketed character classes | |
1536 | are guaranteed to match exactly what a naive English speaker would | |
1537 | expect them to match, even on platforms (such as EBCDIC) where perl | |
1538 | has to do extra work to accomplish this. | |
1539 | ||
1540 | =item * | |
1541 | ||
1542 | The documentation of Bracketed Character Classes has been expanded to cover the | |
1543 | improvements in C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>). | |
1544 | ||
1545 | =back | |
1546 | ||
1547 | =head3 L<perlref> | |
1548 | ||
1549 | =over 4 | |
1550 | ||
1551 | =item * | |
1552 | ||
1553 | A new section has been added | |
1554 | L<Assigning to References|perlref/Assigning to References> | |
1555 | ||
1556 | =back | |
1557 | ||
1558 | =head3 L<perlsec> | |
1559 | ||
1560 | =over 4 | |
1561 | ||
1562 | =item * | |
1563 | ||
1564 | Comments added on algorithmic complexity and tied hashes. | |
1565 | ||
1566 | =back | |
1567 | ||
1568 | =head3 L<perlsyn> | |
1569 | ||
1570 | =over 4 | |
1571 | ||
1572 | =item * | |
1573 | ||
1574 | An ambiguity in the documentation of the C<...> statement has been corrected. | |
1575 | L<[perl #122661]|https://rt.perl.org/Ticket/Display.html?id=122661> | |
1576 | ||
1577 | =item * | |
1578 | ||
1579 | The empty conditional in C<< for >> and C<< while >> is now documented | |
1580 | in L<< perlsyn >>. | |
1581 | ||
1582 | =back | |
1583 | ||
1584 | =head3 L<perlunicode> | |
1585 | ||
1586 | =over 4 | |
1587 | ||
1588 | =item * | |
1589 | ||
1590 | This has had extensive revisions to bring it up-to-date with current | |
1591 | Unicode support and to make it more readable. Notable is that Unicode | |
1592 | 7.0 changed what it should do with non-characters. Perl retains the old | |
1593 | way of handling for reasons of backward compatibility. See | |
1594 | L<perlunicode/Noncharacter code points>. | |
1595 | ||
1596 | =back | |
1597 | ||
1598 | =head3 L<perluniintro> | |
1599 | ||
1600 | =over 4 | |
1601 | ||
1602 | =item * | |
1603 | ||
1604 | Advice for how to make sure your strings and regular expression patterns are | |
1605 | interpreted as Unicode has been updated. | |
1606 | ||
1607 | =back | |
1608 | ||
1609 | =head3 L<perlvar> | |
1610 | ||
1611 | =over 4 | |
1612 | ||
1613 | =item * | |
1614 | ||
1615 | C<$]> is no longer listed as being deprecated. Instead, discussion has | |
1616 | been added on the advantages and disadvantages of using it versus | |
83c1fffe KE |
1617 | C<$^V>. C<$OLD_PERL_VERSION> was re-added to the documentation as the long |
1618 | form of C<$]>. | |
2cfe9b50 RS |
1619 | |
1620 | =item * | |
1621 | ||
1622 | C<${^ENCODING}> is now marked as deprecated. | |
1623 | ||
1624 | =item * | |
1625 | ||
1626 | The entry for C<%^H> has been clarified to indicate it can only handle | |
1627 | simple values. | |
1628 | ||
1629 | =back | |
1630 | ||
1631 | =head3 L<perlvms> | |
1632 | ||
1633 | =over 4 | |
1634 | ||
1635 | =item * | |
1636 | ||
1637 | Out-of-date and/or incorrect material has been removed. | |
1638 | ||
1639 | =item * | |
1640 | ||
1641 | Updated documentation on environment and shell interaction in VMS. | |
1642 | ||
1643 | =back | |
1644 | ||
1645 | =head3 L<perlxs> | |
1646 | ||
1647 | =over 4 | |
1648 | ||
1649 | =item * | |
1650 | ||
1651 | Added a discussion of locale issues in XS code. | |
1652 | ||
1653 | =back | |
1654 | ||
1655 | =head1 Diagnostics | |
1656 | ||
1657 | The following additions or changes have been made to diagnostic output, | |
1658 | including warnings and fatal error messages. For the complete list of | |
1659 | diagnostic messages, see L<perldiag>. | |
1660 | ||
1661 | =head2 New Diagnostics | |
1662 | ||
1663 | =head3 New Errors | |
1664 | ||
1665 | =over 4 | |
1666 | ||
1667 | =item * | |
1668 | ||
1669 | L<Bad symbol for scalar|perldiag/"Bad symbol for scalar"> | |
1670 | ||
1671 | (P) An internal request asked to add a scalar entry to something that | |
1672 | wasn't a symbol table entry. | |
1673 | ||
1674 | =item * | |
1675 | ||
1676 | L<Can't use a hash as a reference|perldiag/"Can't use a hash as a reference"> | |
1677 | ||
1678 | (F) You tried to use a hash as a reference, as in | |
1679 | C<< %foo->{"bar"} >> or C<< %$ref->{"hello"} >>. Versions of perl E<lt>= 5.6.1 | |
1680 | used to allow this syntax, but shouldn't have. | |
1681 | ||
1682 | =item * | |
1683 | ||
1684 | L<Can't use an array as a reference|perldiag/"Can't use an array as a reference"> | |
1685 | ||
1686 | (F) You tried to use an array as a reference, as in | |
1687 | C<< @foo->[23] >> or C<< @$ref->[99] >>. Versions of perl E<lt>= 5.6.1 used to | |
1688 | allow this syntax, but shouldn't have. | |
1689 | ||
1690 | =item * | |
1691 | ||
1692 | L<Can't use 'defined(@array)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(@array)' (Maybe you should just omit the defined()?)"> | |
1693 | ||
1694 | (F) C<defined()> is not useful on arrays because it | |
1695 | checks for an undefined I<scalar> value. If you want to see if the | |
1696 | array is empty, just use S<C<if (@array) { # not empty }>> for example. | |
1697 | ||
1698 | =item * | |
1699 | ||
1700 | L<Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)|perldiag/"Can't use 'defined(%hash)' (Maybe you should just omit the defined()?)"> | |
1701 | ||
1702 | (F) C<defined()> is not usually right on hashes. | |
1703 | ||
1704 | Although S<C<defined %hash>> is false on a plain not-yet-used hash, it | |
1705 | becomes true in several non-obvious circumstances, including iterators, | |
1706 | weak references, stash names, even remaining true after S<C<undef %hash>>. | |
1707 | These things make S<C<defined %hash>> fairly useless in practice, so it now | |
1708 | generates a fatal error. | |
1709 | ||
1710 | If a check for non-empty is what you wanted then just put it in boolean | |
1711 | context (see L<perldata/Scalar values>): | |
1712 | ||
1713 | if (%hash) { | |
1714 | # not empty | |
1715 | } | |
1716 | ||
1717 | If you had S<C<defined %Foo::Bar::QUUX>> to check whether such a package | |
1718 | variable exists then that's never really been reliable, and isn't | |
1719 | a good way to enquire about the features of a package, or whether | |
1720 | it's loaded, etc. | |
1721 | ||
1722 | =item * | |
1723 | ||
1724 | L<Cannot chr %f|perldiag/"Cannot chr %f"> | |
1725 | ||
1726 | (F) You passed an invalid number (like an infinity or not-a-number) to | |
1727 | C<chr>. | |
1728 | ||
1729 | =item * | |
1730 | ||
1731 | L<Cannot compress %f in pack|perldiag/"Cannot compress %f in pack"> | |
1732 | ||
1733 | (F) You tried converting an infinity or not-a-number to an unsigned | |
1734 | character, which makes no sense. | |
1735 | ||
1736 | =item * | |
1737 | ||
1738 | L<Cannot pack %f with '%c'|perldiag/"Cannot pack %f with '%c'"> | |
1739 | ||
1740 | (F) You tried converting an infinity or not-a-number to a character, | |
1741 | which makes no sense. | |
1742 | ||
1743 | =item * | |
1744 | ||
1745 | L<Cannot print %f with '%c'|perldiag/"Cannot printf %f with '%c'"> | |
1746 | ||
1747 | (F) You tried printing an infinity or not-a-number as a character (C<%c>), | |
1748 | which makes no sense. Maybe you meant C<'%s'>, or just stringifying it? | |
1749 | ||
1750 | =item * | |
1751 | ||
1752 | L<charnames alias definitions may not contain a sequence of multiple spaces|perldiag/"charnames alias definitions may not contain a sequence of multiple spaces"> | |
1753 | ||
1754 | (F) You defined a character name which had multiple space | |
1755 | characters in a row. Change them to single spaces. Usually these | |
1756 | names are defined in the C<:alias> import argument to C<use charnames>, but | |
1757 | they could be defined by a translator installed into C<$^H{charnames}>. | |
1758 | See L<charnames/CUSTOM ALIASES>. | |
1759 | ||
1760 | =item * | |
1761 | ||
1762 | L<charnames alias definitions may not contain trailing white-space|perldiag/"charnames alias definitions may not contain trailing white-space"> | |
1763 | ||
1764 | (F) You defined a character name which ended in a space | |
1765 | character. Remove the trailing space(s). Usually these names are | |
1766 | defined in the C<:alias> import argument to C<use charnames>, but they | |
1767 | could be defined by a translator installed into C<$^H{charnames}>. | |
1768 | See L<charnames/CUSTOM ALIASES>. | |
1769 | ||
1770 | =item * | |
1771 | ||
1772 | L<:const is not permitted on named subroutines|perldiag/":const is not permitted on named subroutines"> | |
1773 | ||
1774 | (F) The C<const> attribute causes an anonymous subroutine to be run and | |
1775 | its value captured at the time that it is cloned. Named subroutines are | |
1776 | not cloned like this, so the attribute does not make sense on them. | |
1777 | ||
1778 | =item * | |
1779 | ||
1780 | L<Hexadecimal float: internal error|perldiag/"Hexadecimal float: internal error"> | |
1781 | ||
1782 | (F) Something went horribly bad in hexadecimal float handling. | |
1783 | ||
1784 | =item * | |
1785 | ||
1786 | L<Hexadecimal float: unsupported long double format|perldiag/"Hexadecimal float: unsupported long double format"> | |
1787 | ||
1788 | (F) You have configured Perl to use long doubles but | |
1789 | the internals of the long double format are unknown, | |
1790 | therefore the hexadecimal float output is impossible. | |
1791 | ||
1792 | =item * | |
1793 | ||
1794 | L<Illegal suidscript|perldiag/"Illegal suidscript"> | |
1795 | ||
1796 | (F) The script run under suidperl was somehow illegal. | |
1797 | ||
1798 | =item * | |
1799 | ||
1800 | L<In '(?...)', the '(' and '?' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(?...)', the '(' and '?' must be adjacent in regex; marked by <-- HERE in m/%s/"> | |
1801 | ||
1802 | (F) The two-character sequence C<"(?"> in | |
1803 | this context in a regular expression pattern should be an | |
1804 | indivisible token, with nothing intervening between the C<"("> | |
1805 | and the C<"?">, but you separated them. | |
1806 | ||
1807 | =item * | |
1808 | ||
1809 | L<In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by S<<-- HERE> in mE<sol>%sE<sol>|perldiag/"In '(*VERB...)', the '(' and '*' must be adjacent in regex; marked by <-- HERE in m/%s/"> | |
1810 | ||
1811 | (F) The two-character sequence C<"(*"> in | |
1812 | this context in a regular expression pattern should be an | |
1813 | indivisible token, with nothing intervening between the C<"("> | |
1814 | and the C<"*">, but you separated them. | |
1815 | ||
1816 | =item * | |
1817 | ||
1818 | L<Invalid quantifier in {,} in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/"> | |
1819 | ||
1820 | (F) The pattern looks like a {min,max} quantifier, but the min or max could not | |
1821 | be parsed as a valid number: either it has leading zeroes, or it represents | |
1822 | too big a number to cope with. The S<<-- HERE> shows where in the regular | |
1823 | expression the problem was discovered. See L<perlre>. | |
1824 | ||
1825 | =item * | |
1826 | ||
1827 | L<'%s' is an unknown bound type in regex|perldiag/"'%s' is an unknown bound type in regex; marked by <-- HERE in m/%s/"> | |
1828 | ||
1829 | (F) You used C<\b{...}> or C<\B{...}> and the C<...> is not known to | |
1830 | Perl. The current valid ones are given in | |
1831 | L<perlrebackslash/\b{}, \b, \B{}, \B>. | |
1832 | ||
1833 | =item * | |
1834 | ||
1835 | L<Missing or undefined argument to require|perldiag/Missing or undefined argument to require> | |
1836 | ||
1837 | (F) You tried to call C<require> with no argument or with an undefined | |
1838 | value as an argument. C<require> expects either a package name or a | |
1839 | file-specification as an argument. See L<perlfunc/require>. | |
1840 | ||
1841 | Formerly, C<require> with no argument or C<undef> warned about a Null filename. | |
1842 | ||
1843 | =back | |
1844 | ||
1845 | =head3 New Warnings | |
1846 | ||
1847 | =over 4 | |
1848 | ||
1849 | =item * | |
1850 | ||
1851 | L<\C is deprecated in regex|perldiag/"\C is deprecated in regex; marked by <-- HERE in m/%s/"> | |
1852 | ||
1853 | (D deprecated) The C<< /\C/ >> character class was deprecated in v5.20, and | |
1854 | now emits a warning. It is intended that it will become an error in v5.24. | |
1855 | This character class matches a single byte even if it appears within a | |
1856 | multi-byte character, breaks encapsulation, and can corrupt UTF-8 | |
1857 | strings. | |
1858 | ||
1859 | =item * | |
1860 | ||
1861 | L<"%s" is more clearly written simply as "%s" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"%s" is more clearly written simply as "%s" in regex; marked by <-- HERE in mE<sol>%sE<sol>> | |
1862 | ||
1863 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) | |
1864 | ||
1865 | You specified a character that has the given plainer way of writing it, | |
1866 | and which is also portable to platforms running with different character | |
1867 | sets. | |
1868 | ||
1869 | =item * | |
1870 | ||
1871 | L<Argument "%s" treated as 0 in increment (++)|perldiag/"Argument "%s" treated | |
1872 | as 0 in increment (++)"> | |
1873 | ||
1874 | (W numeric) The indicated string was fed as an argument to the C<++> operator | |
1875 | which expects either a number or a string matching C</^[a-zA-Z]*[0-9]*\z/>. | |
1876 | See L<perlop/Auto-increment and Auto-decrement> for details. | |
1877 | ||
1878 | =item * | |
1879 | ||
1880 | L<Both or neither range ends should be Unicode in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Both or neither range ends should be Unicode in regex; marked by <-- HERE in m/%s/"> | |
1881 | ||
1882 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) | |
1883 | ||
1884 | In a bracketed character class in a regular expression pattern, you | |
1885 | had a range which has exactly one end of it specified using C<\N{}>, and | |
1886 | the other end is specified using a non-portable mechanism. Perl treats | |
1887 | the range as a Unicode range, that is, all the characters in it are | |
1888 | considered to be the Unicode characters, and which may be different code | |
1889 | points on some platforms Perl runs on. For example, C<[\N{U+06}-\x08]> | |
1890 | is treated as if you had instead said C<[\N{U+06}-\N{U+08}]>, that is it | |
1891 | matches the characters whose code points in Unicode are 6, 7, and 8. | |
1892 | But that C<\x08> might indicate that you meant something different, so | |
1893 | the warning gets raised. | |
1894 | ||
1895 | =item * | |
1896 | ||
1897 | L<Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".|perldiag/Can't do %s("%s") on non-UTF-8 locale; resolved to "%s".> | |
1898 | ||
1899 | (W locale) You are 1) running under "C<use locale>"; 2) the current | |
1900 | locale is not a UTF-8 one; 3) you tried to do the designated case-change | |
1901 | operation on the specified Unicode character; and 4) the result of this | |
1902 | operation would mix Unicode and locale rules, which likely conflict. | |
1903 | ||
1904 | The warnings category C<locale> is new. | |
1905 | ||
1906 | =item * | |
1907 | ||
1908 | L<:const is experimental|perldiag/":const is experimental"> | |
1909 | ||
1910 | (S experimental::const_attr) The C<const> attribute is experimental. | |
1911 | If you want to use the feature, disable the warning with C<no warnings | |
1912 | 'experimental::const_attr'>, but know that in doing so you are taking | |
1913 | the risk that your code may break in a future Perl version. | |
1914 | ||
1915 | =item * | |
1916 | ||
1917 | L<gmtime(%f) failed|perldiag/"gmtime(%f) failed"> | |
1918 | ||
1919 | (W overflow) You called C<gmtime> with a number that it could not handle: | |
1920 | too large, too small, or NaN. The returned value is C<undef>. | |
1921 | ||
1922 | =item * | |
1923 | ||
1924 | L<Hexadecimal float: exponent overflow|perldiag/"Hexadecimal float: exponent overflow"> | |
1925 | ||
1926 | (W overflow) The hexadecimal floating point has larger exponent | |
1927 | than the floating point supports. | |
1928 | ||
1929 | =item * | |
1930 | ||
1931 | L<Hexadecimal float: exponent underflow|perldiag/"Hexadecimal float: exponent underflow"> | |
1932 | ||
1933 | (W overflow) The hexadecimal floating point has smaller exponent | |
1934 | than the floating point supports. | |
1935 | ||
1936 | =item * | |
1937 | ||
1938 | L<Hexadecimal float: mantissa overflow|perldiag/"Hexadecimal float: mantissa overflow"> | |
1939 | ||
1940 | (W overflow) The hexadecimal floating point literal had more bits in | |
1941 | the mantissa (the part between the C<0x> and the exponent, also known as | |
1942 | the fraction or the significand) than the floating point supports. | |
1943 | ||
1944 | =item * | |
1945 | ||
1946 | L<Hexadecimal float: precision loss|perldiag/"Hexadecimal float: precision loss"> | |
1947 | ||
1948 | (W overflow) The hexadecimal floating point had internally more | |
1949 | digits than could be output. This can be caused by unsupported | |
1950 | long double formats, or by 64-bit integers not being available | |
1951 | (needed to retrieve the digits under some configurations). | |
1952 | ||
1953 | =item * | |
1954 | ||
1955 | L<Locale '%s' may not work well.%s|perldiag/Locale '%s' may not work well.%s> | |
1956 | ||
1957 | (W locale) You are using the named locale, which is a non-UTF-8 one, and | |
1958 | which perl has determined is not fully compatible with what it can | |
1959 | handle. The second C<%s> gives a reason. | |
1960 | ||
1961 | The warnings category C<locale> is new. | |
1962 | ||
1963 | =item * | |
1964 | ||
1965 | L<localtime(%f) failed|perldiag/"localtime(%f) failed"> | |
1966 | ||
1967 | (W overflow) You called C<localtime> with a number that it could not handle: | |
1968 | too large, too small, or NaN. The returned value is C<undef>. | |
1969 | ||
1970 | =item * | |
1971 | ||
1972 | L<Negative repeat count does nothing|perldiag/"Negative repeat count does nothing"> | |
1973 | ||
1974 | (W numeric) You tried to execute the | |
1975 | L<C<x>|perlop/Multiplicative Operators> repetition operator fewer than 0 | |
1976 | times, which doesn't make sense. | |
1977 | ||
1978 | =item * | |
1979 | ||
1980 | L<NO-BREAK SPACE in a charnames alias definition is deprecated|perldiag/"NO-BREAK SPACE in a charnames alias definition is deprecated"> | |
1981 | ||
1982 | (D deprecated) You defined a character name which contained a no-break | |
1983 | space character. Change it to a regular space. Usually these names are | |
1984 | defined in the C<:alias> import argument to C<use charnames>, but they | |
1985 | could be defined by a translator installed into C<$^H{charnames}>. See | |
1986 | L<charnames/CUSTOM ALIASES>. | |
1987 | ||
1988 | =item * | |
1989 | ||
1990 | L<Non-finite repeat count does nothing|perldiag/"Non-finite repeat count does nothing"> | |
1991 | ||
1992 | (W numeric) You tried to execute the | |
1993 | L<C<x>|perlop/Multiplicative Operators> repetition operator C<Inf> (or | |
1994 | C<-Inf>) or NaN times, which doesn't make sense. | |
1995 | ||
1996 | =item * | |
1997 | ||
1998 | L<PerlIO layer ':win32' is experimental|perldiag/"PerlIO layer ':win32' is experimental"> | |
1999 | ||
2000 | (S experimental::win32_perlio) The C<:win32> PerlIO layer is | |
2001 | experimental. If you want to take the risk of using this layer, | |
2002 | simply disable this warning: | |
2003 | ||
2004 | no warnings "experimental::win32_perlio"; | |
2005 | ||
2006 | =item * | |
2007 | ||
2008 | L<Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of ASCII printables should be some subset of "0-9", "A-Z", or "a-z" in regex; marked by <-- HERE in mE<sol>%sE<sol>"> | |
2009 | ||
2010 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) | |
2011 | ||
2012 | Stricter rules help to find typos and other errors. Perhaps you didn't | |
2013 | even intend a range here, if the C<"-"> was meant to be some other | |
2014 | character, or should have been escaped (like C<"\-">). If you did | |
2015 | intend a range, the one that was used is not portable between ASCII and | |
2016 | EBCDIC platforms, and doesn't have an obvious meaning to a casual | |
2017 | reader. | |
2018 | ||
2019 | [3-7] # OK; Obvious and portable | |
2020 | [d-g] # OK; Obvious and portable | |
2021 | [A-Y] # OK; Obvious and portable | |
2022 | [A-z] # WRONG; Not portable; not clear what is meant | |
2023 | [a-Z] # WRONG; Not portable; not clear what is meant | |
2024 | [%-.] # WRONG; Not portable; not clear what is meant | |
2025 | [\x41-Z] # WRONG; Not portable; not obvious to non-geek | |
2026 | ||
2027 | (You can force portability by specifying a Unicode range, which means that | |
2028 | the endpoints are specified by | |
2029 | L<C<\N{...}>|perlrecharclass/Character Ranges>, but the meaning may | |
2030 | still not be obvious.) | |
2031 | The stricter rules require that ranges that start or stop with an ASCII | |
2032 | character that is not a control have all their endpoints be a literal | |
2033 | character, and not some escape sequence (like C<"\x41">), and the ranges | |
2034 | must be all digits, or all uppercase letters, or all lowercase letters. | |
2035 | ||
2036 | =item * | |
2037 | ||
2038 | L<Ranges of digits should be from the same group in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Ranges of digits should be from the same group in regex; marked by <-- HERE in m/%s/"> | |
2039 | ||
2040 | (W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) | |
2041 | ||
2042 | Stricter rules help to find typos and other errors. You included a | |
2043 | range, and at least one of the end points is a decimal digit. Under the | |
2044 | stricter rules, when this happens, both end points should be digits in | |
2045 | the same group of 10 consecutive digits. | |
2046 | ||
2047 | =item * | |
2048 | ||
2049 | L<Redundant argument in %s|perldiag/Redundant argument in %s> | |
2050 | ||
2051 | (W redundant) You called a function with more arguments than were | |
2052 | needed, as indicated by information within other arguments you supplied | |
2053 | (I<e.g>. a printf format). Currently only emitted when a printf-type format | |
2054 | required fewer arguments than were supplied, but might be used in the | |
2055 | future for I<e.g.> L<perlfunc/pack>. | |
2056 | ||
2057 | The warnings category C<< redundant >> is new. See also | |
2058 | L<[perl #121025]|https://rt.perl.org/Ticket/Display.html?id=121025>. | |
2059 | ||
2060 | =item * | |
2061 | ||
2062 | L<Replacement list is longer than search list|perldiag/Replacement list is longer than search list> | |
2063 | ||
2064 | This is not a new diagnostic, but in earlier releases was accidentally | |
2065 | not displayed if the transliteration contained wide characters. This is | |
2066 | now fixed, so that you may see this diagnostic in places where you | |
2067 | previously didn't (but should have). | |
2068 | ||
2069 | =item * | |
2070 | ||
2071 | L<Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale|perldiag/"Use of \b{} for non-UTF-8 locale is wrong. Assuming a UTF-8 locale"> | |
2072 | ||
2073 | (W locale) You are matching a regular expression using locale rules, | |
2074 | and a Unicode boundary is being matched, but the locale is not a Unicode | |
2075 | one. This doesn't make sense. Perl will continue, assuming a Unicode | |
2076 | (UTF-8) locale, but the results could well be wrong except if the locale | |
2077 | happens to be ISO-8859-1 (Latin1) where this message is spurious and can | |
2078 | be ignored. | |
2079 | ||
2080 | The warnings category C<locale> is new. | |
2081 | ||
2082 | =item * | |
2083 | ||
2084 | L<< Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by E<lt>-- HERE in mE<sol>%sE<sol>|perldiag/"Using E<sol>u for '%s' instead of E<sol>%s in regex; marked by <-- HERE in mE<sol>%sE<sol>" >> | |
2085 | ||
2086 | (W regexp) You used a Unicode boundary (C<\b{...}> or C<\B{...}>) in a | |
2087 | portion of a regular expression where the character set modifiers C</a> | |
2088 | or C</aa> are in effect. These two modifiers indicate an ASCII | |
2089 | interpretation, and this doesn't make sense for a Unicode definition. | |
2090 | The generated regular expression will compile so that the boundary uses | |
2091 | all of Unicode. No other portion of the regular expression is affected. | |
2092 | ||
2093 | =item * | |
2094 | ||
2095 | L<The bitwise feature is experimental|perldiag/"The bitwise feature is experimental"> | |
2096 | ||
2097 | (S experimental::bitwise) This warning is emitted if you use bitwise | |
2098 | operators (C<& | ^ ~ &. |. ^. ~.>) with the "bitwise" feature enabled. | |
2099 | Simply suppress the warning if you want to use the feature, but know | |
2100 | that in doing so you are taking the risk of using an experimental | |
2101 | feature which may change or be removed in a future Perl version: | |
2102 | ||
2103 | no warnings "experimental::bitwise"; | |
2104 | use feature "bitwise"; | |
2105 | $x |.= $y; | |
2106 | ||
2107 | =item * | |
2108 | ||
2109 | L<Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Unescaped left brace in regex is deprecated, passed through in regex; marked by <-- HERE in m/%s/"> | |
2110 | ||
2111 | (D deprecated, regexp) You used a literal C<"{"> character in a regular | |
2112 | expression pattern. You should change to use C<"\{"> instead, because a future | |
2113 | version of Perl (tentatively v5.26) will consider this to be a syntax error. If | |
2114 | the pattern delimiters are also braces, any matching right brace | |
2115 | (C<"}">) should also be escaped to avoid confusing the parser, for | |
2116 | example, | |
2117 | ||
2118 | qr{abc\{def\}ghi} | |
2119 | ||
2120 | =item * | |
2121 | ||
2122 | L<Use of literal non-graphic characters in variable names is deprecated|perldiag/"Use of literal non-graphic characters in variable names is deprecated"> | |
2123 | ||
2124 | (D deprecated) Using literal non-graphic (including control) | |
2125 | characters in the source to refer to the I<^FOO> variables, like C<$^X> and | |
2126 | C<${^GLOBAL_PHASE}> is now deprecated. | |
2127 | ||
2128 | =item * | |
2129 | ||
2130 | L<Useless use of attribute "const"|perldiag/Useless use of attribute "const"> | |
2131 | ||
2132 | (W misc) The C<const> attribute has no effect except | |
2133 | on anonymous closure prototypes. You applied it to | |
2134 | a subroutine via L<attributes.pm|attributes>. This is only useful | |
2135 | inside an attribute handler for an anonymous subroutine. | |
2136 | ||
2137 | =item * | |
2138 | ||
2139 | L<Useless use of E<sol>d modifier in transliteration operator|perldiag/"Useless use of /d modifier in transliteration operator"> | |
2140 | ||
2141 | This is not a new diagnostic, but in earlier releases was accidentally | |
2142 | not displayed if the transliteration contained wide characters. This is | |
2143 | now fixed, so that you may see this diagnostic in places where you | |
2144 | previously didn't (but should have). | |
2145 | ||
2146 | =item * | |
2147 | ||
2148 | L<E<quot>use re 'strict'E<quot> is experimental|perldiag/"use re 'strict'" is experimental> | |
2149 | ||
2150 | (S experimental::re_strict) The things that are different when a regular | |
2151 | expression pattern is compiled under C<'strict'> are subject to change | |
2152 | in future Perl releases in incompatible ways; there are also proposals | |
2153 | to change how to enable strict checking instead of using this subpragma. | |
2154 | This means that a pattern that compiles today may not in a future Perl | |
2155 | release. This warning is to alert you to that risk. | |
2156 | ||
2157 | =item * | |
2158 | ||
2159 | L<Warning: unable to close filehandle properly: %s|perldiag/"Warning: unable to close filehandle properly: %s"> | |
2160 | ||
2161 | L<Warning: unable to close filehandle %s properly: %s|perldiag/"Warning: unable to close filehandle %s properly: %s"> | |
2162 | ||
2163 | (S io) Previously, perl silently ignored any errors when doing an implicit | |
2164 | close of a filehandle, I<i.e.> where the reference count of the filehandle | |
2165 | reached zero and the user's code hadn't already called C<close()>; I<e.g.> | |
2166 | ||
2167 | { | |
2168 | open my $fh, '>', $file or die "open: '$file': $!\n"; | |
2169 | print $fh, $data or die; | |
2170 | } # implicit close here | |
2171 | ||
2172 | In a situation such as disk full, due to buffering, the error may only be | |
2173 | detected during the final close, so not checking the result of the close is | |
2174 | dangerous. | |
2175 | ||
2176 | So perl now warns in such situations. | |
2177 | ||
2178 | =item * | |
2179 | ||
2180 | L<Wide character (U+%X) in %s|perldiag/"Wide character (U+%X) in %s"> | |
2181 | ||
2182 | (W locale) While in a single-byte locale (I<i.e.>, a non-UTF-8 | |
2183 | one), a multi-byte character was encountered. Perl considers this | |
2184 | character to be the specified Unicode code point. Combining non-UTF-8 | |
2185 | locales and Unicode is dangerous. Almost certainly some characters | |
2186 | will have two different representations. For example, in the ISO 8859-7 | |
2187 | (Greek) locale, the code point 0xC3 represents a Capital Gamma. But so | |
2188 | also does 0x393. This will make string comparisons unreliable. | |
2189 | ||
2190 | You likely need to figure out how this multi-byte character got mixed up | |
2191 | with your single-byte locale (or perhaps you thought you had a UTF-8 | |
2192 | locale, but Perl disagrees). | |
2193 | ||
2194 | The warnings category C<locale> is new. | |
2195 | ||
2196 | =back | |
2197 | ||
2198 | =head2 Changes to Existing Diagnostics | |
2199 | ||
2200 | =over 4 | |
2201 | ||
2202 | =item * | |
2203 | ||
2204 | <> should be quotes | |
2205 | ||
2206 | This warning has been changed to | |
2207 | L<< <> at require-statement should be quotes|perldiag/"<> at require-statement should be quotes" >> | |
2208 | to make the issue more identifiable. | |
2209 | ||
2210 | =item * | |
2211 | ||
2212 | L<Argument "%s" isn't numeric%s|perldiag/"Argument "%s" isn't numeric%s"> | |
2213 | ||
2214 | The L<perldiag> entry for this warning has added this clarifying note: | |
2215 | ||
2216 | Note that for the Inf and NaN (infinity and not-a-number) the | |
2217 | definition of "numeric" is somewhat unusual: the strings themselves | |
2218 | (like "Inf") are considered numeric, and anything following them is | |
2219 | considered non-numeric. | |
2220 | ||
2221 | =item * | |
2222 | ||
2223 | L<Global symbol "%s" requires explicit package name|perldiag/"Global symbol "%s" requires explicit package name (did you forget to declare "my %s"?)"> | |
2224 | ||
2225 | This message has had '(did you forget to declare "my %s"?)' appended to it, to | |
2226 | make it more helpful to new Perl programmers. | |
2227 | L<[perl #121638]|https://rt.perl.org/Ticket/Display.html?id=121638> | |
2228 | ||
2229 | =item * | |
2230 | ||
2231 | '"my" variable &foo::bar can't be in a package' has been reworded to say | |
2232 | 'subroutine' instead of 'variable'. | |
2233 | ||
2234 | =item * | |
2235 | ||
2236 | L<<< \N{} in character class restricted to one character in regex; marked by | |
2237 | S<< <-- HERE >> in mE<sol>%sE<sol>|perldiag/"\N{} in inverted character | |
2238 | class or as a range end-point is restricted to one character in regex; | |
2239 | marked by <-- HERE in m/%s/" >>> | |
2240 | ||
2241 | This message has had I<character class> changed to I<inverted character | |
2242 | class or as a range end-point is> to reflect improvements in | |
2243 | C<qr/[\N{named sequence}]/> (see under L</Selected Bug Fixes>). | |
2244 | ||
2245 | =item * | |
2246 | ||
2247 | L<panic: frexp|perldiag/"panic: frexp: %f"> | |
2248 | ||
2249 | This message has had ': C<%f>' appended to it, to show what the offending | |
2250 | floating point number is. | |
2251 | ||
2252 | =item * | |
2253 | ||
2254 | I<Possible precedence problem on bitwise %c operator> reworded as | |
2255 | L<Possible precedence problem on bitwise %s operator|perldiag/"Possible precedence problem on bitwise %s operator">. | |
2256 | ||
2257 | =item * | |
2258 | ||
2259 | L<Unsuccessful %s on filename containing newline|perldiag/"Unsuccessful %s on filename containing newline"> | |
2260 | ||
2261 | This warning is now only produced when the newline is at the end of | |
2262 | the filename. | |
2263 | ||
2264 | =item * | |
2265 | ||
2266 | "Variable C<%s> will not stay shared" has been changed to say "Subroutine" | |
2267 | when it is actually a lexical sub that will not stay shared. | |
2268 | ||
2269 | =item * | |
2270 | ||
2271 | L<Variable length lookbehind not implemented in regex mE<sol>%sE<sol>|perldiag/"Variable length lookbehind not implemented in regex m/%s/"> | |
2272 | ||
2273 | The L<perldiag> entry for this warning has had information about Unicode | |
2274 | behavior added. | |
2275 | ||
2276 | =back | |
2277 | ||
2278 | =head2 Diagnostic Removals | |
2279 | ||
2280 | =over | |
2281 | ||
2282 | =item * | |
2283 | ||
2284 | "Ambiguous use of -foo resolved as -&foo()" | |
2285 | ||
2286 | There is actually no ambiguity here, and this impedes the use of negated | |
2287 | constants; I<e.g.>, C<-Inf>. | |
2288 | ||
2289 | =item * | |
2290 | ||
2291 | "Constant is not a FOO reference" | |
2292 | ||
2293 | Compile-time checking of constant dereferencing (I<e.g.>, C<< my_constant->() >>) | |
2294 | has been removed, since it was not taking overloading into account. | |
2295 | L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> | |
2296 | L<[perl #122607]|https://rt.perl.org/Ticket/Display.html?id=122607> | |
2297 | ||
2298 | =back | |
2299 | ||
2300 | =head1 Utility Changes | |
2301 | ||
2302 | =head2 F<find2perl>, F<s2p> and F<a2p> removal | |
2303 | ||
2304 | =over 4 | |
2305 | ||
2306 | =item * | |
2307 | ||
2308 | The F<x2p/> directory has been removed from the Perl core. | |
2309 | ||
2310 | This removes find2perl, s2p and a2p. They have all been released to CPAN as | |
2311 | separate distributions (C<App::find2perl>, C<App::s2p>, C<App::a2p>). | |
2312 | ||
2313 | =back | |
2314 | ||
2315 | =head2 L<h2ph> | |
2316 | ||
2317 | =over 4 | |
2318 | ||
2319 | =item * | |
2320 | ||
2321 | F<h2ph> now handles hexadecimal constants in the compiler's predefined | |
2322 | macro definitions, as visible in C<$Config{cppsymbols}>. | |
2323 | L<[perl #123784]|https://rt.perl.org/Ticket/Display.html?id=123784>. | |
2324 | ||
2325 | =back | |
2326 | ||
2327 | =head2 L<encguess> | |
2328 | ||
2329 | =over 4 | |
2330 | ||
2331 | =item * | |
2332 | ||
2333 | No longer depends on non-core modules. | |
2334 | ||
2335 | =back | |
2336 | ||
2337 | =head1 Configuration and Compilation | |
2338 | ||
2339 | =over 4 | |
2340 | ||
2341 | =item * | |
2342 | ||
2343 | F<Configure> now checks for C<lrintl()>, C<lroundl()>, C<llrintl()>, and | |
2344 | C<llroundl()>. | |
2345 | ||
2346 | =item * | |
2347 | ||
2348 | F<Configure> with C<-Dmksymlinks> should now be faster. | |
2349 | L<[perl #122002]|https://rt.perl.org/Ticket/Display.html?id=122002>. | |
2350 | ||
2351 | =item * | |
2352 | ||
2353 | The C<pthreads> and C<cl> libraries will be linked by default if present. | |
2354 | This allows XS modules that require threading to work on non-threaded | |
2355 | perls. Note that you must still pass C<-Dusethreads> if you want a | |
2356 | threaded perl. | |
2357 | ||
2358 | =item * | |
2359 | ||
b7ce25dd JH |
2360 | To get more precision and range for floating point numbers one can now |
2361 | use the GCC quadmath library which implements the quadruple precision | |
2362 | floating point numbers on x86 and IA-64 platforms. See F<INSTALL> for | |
2363 | details. | |
2cfe9b50 RS |
2364 | |
2365 | =item * | |
2366 | ||
2367 | MurmurHash64A and MurmurHash64B can now be configured as the internal hash | |
2368 | function. | |
2369 | ||
2370 | =item * | |
2371 | ||
2372 | C<make test.valgrind> now supports parallel testing. | |
2373 | ||
2374 | For example: | |
2375 | ||
2376 | TEST_JOBS=9 make test.valgrind | |
2377 | ||
2378 | See L<perlhacktips/valgrind> for more information. | |
2379 | ||
2380 | L<[perl #121431]|https://rt.perl.org/Ticket/Display.html?id=121431> | |
2381 | ||
2382 | =item * | |
2383 | ||
2384 | The MAD (Misc Attribute Decoration) build option has been removed | |
2385 | ||
2386 | This was an unmaintained attempt at preserving | |
2387 | the Perl parse tree more faithfully so that automatic conversion of | |
2388 | Perl 5 to Perl 6 would have been easier. | |
2389 | ||
2390 | This build-time configuration option had been unmaintained for years, | |
2391 | and had probably seriously diverged on both Perl 5 and Perl 6 sides. | |
2392 | ||
2393 | =item * | |
2394 | ||
2395 | A new compilation flag, C<< -DPERL_OP_PARENT >> is available. For details, | |
2396 | see the discussion below at L<< /Internal Changes >>. | |
2397 | ||
2398 | =item * | |
2399 | ||
2400 | Pathtools no longer tries to load XS on miniperl. This speeds up building perl | |
2401 | slightly. | |
2402 | ||
2403 | =back | |
2404 | ||
2405 | =head1 Testing | |
2406 | ||
2407 | =over 4 | |
2408 | ||
2409 | =item * | |
2410 | ||
2411 | F<t/porting/re_context.t> has been added to test that L<utf8> and its | |
2412 | dependencies only use the subset of the C<$1..$n> capture vars that | |
2413 | C<Perl_save_re_context()> is hard-coded to localize, because that function | |
2414 | has no efficient way of determining at runtime what vars to localize. | |
2415 | ||
2416 | =item * | |
2417 | ||
2418 | Tests for performance issues have been added in the file F<t/perf/taint.t>. | |
2419 | ||
2420 | =item * | |
2421 | ||
2422 | Some regular expression tests are written in such a way that they will | |
2423 | run very slowly if certain optimizations break. These tests have been | |
2424 | moved into new files, F<< t/re/speed.t >> and F<< t/re/speed_thr.t >>, | |
2425 | and are run with a C<< watchdog() >>. | |
2426 | ||
2427 | =item * | |
2428 | ||
2429 | C<< test.pl >> now allows C<< plan skip_all => $reason >>, to make it | |
2430 | more compatible with C<< Test::More >>. | |
2431 | ||
2432 | =item * | |
2433 | ||
2434 | A new test script, F<op/infnan.t>, has been added to test if infinity and NaN are | |
2435 | working correctly. See L</Infinity and NaN (not-a-number) handling improved>. | |
2436 | ||
2437 | =back | |
2438 | ||
2439 | =head1 Platform Support | |
2440 | ||
2441 | =head2 Regained Platforms | |
2442 | ||
2443 | =over 4 | |
2444 | ||
2445 | =item IRIX and Tru64 platforms are working again. | |
2446 | ||
2447 | Some C<make test> failures remain: | |
2448 | L<[perl #123977]|https://rt.perl.org/Ticket/Display.html?id=123977> | |
2449 | and L<[perl #125298]|https://rt.perl.org/Ticket/Display.html?id=125298> | |
2450 | for IRIX; L<[perl #124212]|https://rt.perl.org/Ticket/Display.html?id=124212>, | |
2451 | L<[cpan #99605]|https://rt.cpan.org/Public/Bug/Display.html?id=99605>, and | |
ec610f8a | 2452 | L<[cpan #104836]|https://rt.cpan.org/Ticket/Display.html?id=104836> for Tru64. |
2cfe9b50 RS |
2453 | |
2454 | =item z/OS running EBCDIC Code Page 1047 | |
2455 | ||
2456 | Core perl now works on this EBCDIC platform. Earlier perls also worked, but, | |
2457 | even though support wasn't officially withdrawn, recent perls would not compile | |
2458 | and run well. Perl 5.20 would work, but had many bugs which have now been | |
2459 | fixed. Many CPAN modules that ship with Perl still fail tests, including | |
2460 | C<Pod::Simple>. However the version of C<Pod::Simple> currently on CPAN should work; | |
2461 | it was fixed too late to include in Perl 5.22. Work is under way to fix many | |
2462 | of the still-broken CPAN modules, which likely will be installed on CPAN when | |
2463 | completed, so that you may not have to wait until Perl 5.24 to get a working | |
2464 | version. | |
2465 | ||
2466 | =back | |
2467 | ||
2468 | =head2 Discontinued Platforms | |
2469 | ||
2470 | =over 4 | |
2471 | ||
2472 | =item NeXTSTEP/OPENSTEP | |
2473 | ||
2474 | NeXTSTEP was a proprietary operating system bundled with NeXT's | |
2475 | workstations in the early to mid 90s; OPENSTEP was an API specification | |
2476 | that provided a NeXTSTEP-like environment on a non-NeXTSTEP system. Both | |
2477 | are now long dead, so support for building Perl on them has been removed. | |
2478 | ||
2479 | =back | |
2480 | ||
2481 | =head2 Platform-Specific Notes | |
2482 | ||
2483 | =over 4 | |
2484 | ||
2485 | =item EBCDIC | |
2486 | ||
2487 | Special handling is required of the perl interpreter on EBCDIC platforms | |
2488 | to get C<qr/[i-j]/> to match only C<"i"> and C<"j">, since there are 7 | |
2489 | characters between the | |
2490 | code points for C<"i"> and C<"j">. This special handling had only been | |
2491 | invoked when both ends of the range are literals. Now it is also | |
2492 | invoked if any of the C<\N{...}> forms for specifying a character by | |
2493 | name or Unicode code point is used instead of a literal. See | |
2494 | L<perlrecharclass/Character Ranges>. | |
2495 | ||
2496 | =item HP-UX | |
2497 | ||
2498 | The archname now distinguishes use64bitint from use64bitall. | |
2499 | ||
2500 | =item Android | |
2501 | ||
2502 | Build support has been improved for cross-compiling in general and for | |
2503 | Android in particular. | |
2504 | ||
2505 | =item VMS | |
2506 | ||
2507 | =over 4 | |
2508 | ||
2509 | =item * | |
2510 | ||
2511 | When spawning a subprocess without waiting, the return value is now | |
2512 | the correct PID. | |
2513 | ||
2514 | =item * | |
2515 | ||
2516 | Fix a prototype so linking doesn't fail under the VMS C++ compiler. | |
2517 | ||
2518 | =item * | |
2519 | ||
2520 | C<finite>, C<finitel>, and C<isfinite> detection has been added to | |
2521 | C<configure.com>, environment handling has had some minor changes, and | |
2522 | a fix for legacy feature checking status. | |
2523 | ||
2524 | =back | |
2525 | ||
2526 | =item Win32 | |
2527 | ||
2528 | =over 4 | |
2529 | ||
2530 | =item * | |
2531 | ||
2532 | F<miniperl.exe> is now built with C<-fno-strict-aliasing>, allowing 64-bit | |
2533 | builds to complete on GCC 4.8. | |
2534 | L<[perl #123976]|https://rt.perl.org/Ticket/Display.html?id=123976> | |
2535 | ||
2536 | =item * | |
2537 | ||
2538 | C<nmake minitest> now works on Win32. Due to dependency issues you | |
2539 | need to build C<nmake test-prep> first, and a small number of the | |
2540 | tests fail. | |
2541 | L<[perl #123394]|https://rt.perl.org/Ticket/Display.html?id=123394> | |
2542 | ||
2543 | =item * | |
2544 | ||
2545 | Perl can now be built in C++ mode on Windows by setting the makefile macro | |
2546 | C<USE_CPLUSPLUS> to the value "define". | |
2547 | ||
2548 | =item * | |
2549 | ||
2550 | The list form of piped open has been implemented for Win32. Note: unlike | |
2551 | C<system LIST> this does not fall back to the shell. | |
2552 | L<[perl #121159]|https://rt.perl.org/Ticket/Display.html?id=121159> | |
2553 | ||
2554 | =item * | |
2555 | ||
2556 | New C<DebugSymbols> and C<DebugFull> configuration options added to | |
2557 | Windows makefiles. | |
2558 | ||
2559 | =item * | |
2560 | ||
2561 | Previously, compiling XS modules (including CPAN ones) using Visual C++ for | |
2562 | Win64 resulted in around a dozen warnings per file from F<hv_func.h>. These | |
2563 | warnings have been silenced. | |
2564 | ||
2565 | =item * | |
2566 | ||
2567 | Support for building without PerlIO has been removed from the Windows | |
2568 | makefiles. Non-PerlIO builds were all but deprecated in Perl 5.18.0 and are | |
2569 | already not supported by F<Configure> on POSIX systems. | |
2570 | ||
2571 | =item * | |
2572 | ||
2573 | Between 2 and 6 milliseconds and seven I/O calls have been saved per attempt | |
2574 | to open a perl module for each path in C<@INC>. | |
2575 | ||
2576 | =item * | |
2577 | ||
2578 | Intel C builds are now always built with C99 mode on. | |
2579 | ||
2580 | =item * | |
2581 | ||
2582 | C<%I64d> is now being used instead of C<%lld> for MinGW. | |
2583 | ||
2584 | =item * | |
2585 | ||
2586 | In the experimental C<:win32> layer, a crash in C<open> was fixed. Also | |
2587 | opening F</dev/null> (which works under Win32 Perl's default C<:unix> | |
2588 | layer) was implemented for C<:win32>. | |
2589 | L<[perl #122224]|https://rt.perl.org/Ticket/Display.html?id=122224> | |
2590 | ||
2591 | =item * | |
2592 | ||
2593 | A new makefile option, C<USE_LONG_DOUBLE>, has been added to the Windows | |
2594 | dmake makefile for gcc builds only. Set this to "define" if you want perl to | |
2595 | use long doubles to give more accuracy and range for floating point numbers. | |
2596 | ||
2597 | =back | |
2598 | ||
2599 | =item OpenBSD | |
2600 | ||
2601 | On OpenBSD, Perl will now default to using the system C<malloc> due to the | |
2602 | security features it provides. Perl's own malloc wrapper has been in use | |
2603 | since v5.14 due to performance reasons, but the OpenBSD project believes | |
2604 | the tradeoff is worth it and would prefer that users who need the speed | |
2605 | specifically ask for it. | |
2606 | ||
2607 | L<[perl #122000]|https://rt.perl.org/Ticket/Display.html?id=122000>. | |
2608 | ||
2609 | =item Solaris | |
2610 | ||
2611 | =over 4 | |
2612 | ||
2613 | =item * | |
2614 | ||
2615 | We now look for the Sun Studio compiler in both F</opt/solstudio*> and | |
2616 | F</opt/solarisstudio*>. | |
2617 | ||
2618 | =item * | |
2619 | ||
2620 | Builds on Solaris 10 with C<-Dusedtrace> would fail early since make | |
2621 | didn't follow implied dependencies to build C<perldtrace.h>. Added an | |
2622 | explicit dependency to C<depend>. | |
2623 | L<[perl #120120]|https://rt.perl.org/Ticket/Display.html?id=120120> | |
2624 | ||
2625 | =item * | |
2626 | ||
2627 | C99 options have been cleaned up; hints look for C<solstudio> | |
2628 | as well as C<SUNWspro>; and support for native C<setenv> has been added. | |
2629 | ||
2630 | =back | |
2631 | ||
2632 | =back | |
2633 | ||
2634 | =head1 Internal Changes | |
2635 | ||
2636 | =over 4 | |
2637 | ||
2638 | =item * | |
2639 | ||
2640 | Experimental support has been added to allow ops in the optree to locate | |
2641 | their parent, if any. This is enabled by the non-default build option | |
2642 | C<-DPERL_OP_PARENT>. It is envisaged that this will eventually become | |
2643 | enabled by default, so XS code which directly accesses the C<op_sibling> | |
2644 | field of ops should be updated to be future-proofed. | |
2645 | ||
2646 | On C<PERL_OP_PARENT> builds, the C<op_sibling> field has been renamed | |
2647 | C<op_sibparent> and a new flag, C<op_moresib>, added. On the last op in a | |
2648 | sibling chain, C<op_moresib> is false and C<op_sibparent> points to the | |
2649 | parent (if any) rather than being C<NULL>. | |
2650 | ||
2651 | To make existing code work transparently whether using C<PERL_OP_PARENT> | |
2652 | or not, a number of new macros and functions have been added that should | |
2653 | be used, rather than directly manipulating C<op_sibling>. | |
2654 | ||
2655 | For the case of just reading C<op_sibling> to determine the next sibling, | |
2656 | two new macros have been added. A simple scan through a sibling chain | |
2657 | like this: | |
2658 | ||
2659 | for (; kid->op_sibling; kid = kid->op_sibling) { ... } | |
2660 | ||
2661 | should now be written as: | |
2662 | ||
2663 | for (; OpHAS_SIBLING(kid); kid = OpSIBLING(kid)) { ... } | |
2664 | ||
2665 | For altering optrees, a general-purpose function C<op_sibling_splice()> | |
2666 | has been added, which allows for manipulation of a chain of sibling ops. | |
2667 | By analogy with the Perl function C<splice()>, it allows you to cut out | |
2668 | zero or more ops from a sibling chain and replace them with zero or more | |
2669 | new ops. It transparently handles all the updating of sibling, parent, | |
2670 | op_last pointers etc. | |
2671 | ||
2672 | If you need to manipulate ops at a lower level, then three new macros, | |
2673 | C<OpMORESIB_set>, C<OpLASTSIB_set> and C<OpMAYBESIB_set> are intended to | |
2674 | be a low-level portable way to set C<op_sibling> / C<op_sibparent> while | |
2675 | also updating C<op_moresib>. The first sets the sibling pointer to a new | |
2676 | sibling, the second makes the op the last sibling, and the third | |
2677 | conditionally does the first or second action. Note that unlike | |
2678 | C<op_sibling_splice()> these macros won't maintain consistency in the | |
2679 | parent at the same time (I<e.g.> by updating C<op_first> and C<op_last> where | |
2680 | appropriate). | |
2681 | ||
2682 | A C-level C<Perl_op_parent()> function and a Perl-level C<B::OP::parent()> | |
2683 | method have been added. The C function only exists under | |
2684 | C<PERL_OP_PARENT> builds (using it is build-time error on vanilla | |
2685 | perls). C<B::OP::parent()> exists always, but on a vanilla build it | |
2686 | always returns C<NULL>. Under C<PERL_OP_PARENT>, they return the parent | |
2687 | of the current op, if any. The variable C<$B::OP::does_parent> allows you | |
2688 | to determine whether C<B> supports retrieving an op's parent. | |
2689 | ||
2690 | C<PERL_OP_PARENT> was introduced in 5.21.2, but the interface was | |
2691 | changed considerably in 5.21.11. If you updated your code before the | |
2692 | 5.21.11 changes, it may require further revision. The main changes after | |
2693 | 5.21.2 were: | |
2694 | ||
2695 | =over 4 | |
2696 | ||
2697 | =item * | |
2698 | ||
2699 | The C<OP_SIBLING> and C<OP_HAS_SIBLING> macros have been renamed | |
2700 | C<OpSIBLING> and C<OpHAS_SIBLING> for consistency with other | |
2701 | op-manipulating macros. | |
2702 | ||
2703 | =item * | |
2704 | ||
2705 | The C<op_lastsib> field has been renamed C<op_moresib>, and its meaning | |
2706 | inverted. | |
2707 | ||
2708 | =item * | |
2709 | ||
2710 | The macro C<OpSIBLING_set> has been removed, and has been superseded by | |
2711 | C<OpMORESIB_set> I<et al>. | |
2712 | ||
2713 | =item * | |
2714 | ||
2715 | The C<op_sibling_splice()> function now accepts a null C<parent> argument | |
2716 | where the splicing doesn't affect the first or last ops in the sibling | |
2717 | chain | |
2718 | ||
2719 | =back | |
2720 | ||
2721 | =item * | |
2722 | ||
2723 | Macros have been created to allow XS code to better manipulate the POSIX locale | |
2724 | category C<LC_NUMERIC>. See L<perlapi/Locale-related functions and macros>. | |
2725 | ||
2726 | =item * | |
2727 | ||
2728 | The previous C<atoi> I<et al> replacement function, C<grok_atou>, has now been | |
2729 | superseded by C<grok_atoUV>. See L<perlclib> for details. | |
2730 | ||
2731 | =item * | |
2732 | ||
2733 | A new function, C<Perl_sv_get_backrefs()>, has been added which allows you | |
2734 | retrieve the weak references, if any, which point at an SV. | |
2735 | ||
2736 | =item * | |
2737 | ||
2738 | The C<screaminstr()> function has been removed. Although marked as | |
2739 | public API, it was undocumented and had no usage in CPAN modules. Calling | |
2740 | it has been fatal since 5.17.0. | |
2741 | ||
2742 | =item * | |
2743 | ||
2744 | The C<newDEFSVOP()>, C<block_start()>, C<block_end()> and C<intro_my()> | |
2745 | functions have been added to the API. | |
2746 | ||
2747 | =item * | |
2748 | ||
2749 | The internal C<convert> function in F<op.c> has been renamed | |
2750 | C<op_convert_list> and added to the API. | |
2751 | ||
2752 | =item * | |
2753 | ||
2754 | The C<sv_magic()> function no longer forbids "ext" magic on read-only | |
2755 | values. After all, perl can't know whether the custom magic will modify | |
2756 | the SV or not. | |
2757 | L<[perl #123103]|https://rt.perl.org/Ticket/Display.html?id=123103>. | |
2758 | ||
2759 | =item * | |
2760 | ||
2761 | Accessing L<perlapi/CvPADLIST> on an XSUB is now forbidden. | |
2762 | ||
2763 | The C<CvPADLIST> field has been reused for a different internal purpose | |
2764 | for XSUBs. So in particular, you can no longer rely on it being NULL as a | |
2765 | test of whether a CV is an XSUB. Use C<CvISXSUB()> instead. | |
2766 | ||
2767 | =item * | |
2768 | ||
2769 | SVs of type C<SVt_NV> are now sometimes bodiless when the build | |
2770 | configuration and platform allow it: specifically, when C<< sizeof(NV) <= | |
2771 | sizeof(IV) >>. "Bodiless" means that the NV value is stored directly in | |
2772 | the head of an SV, without requiring a separate body to be allocated. This | |
2773 | trick has already been used for IVs since 5.9.2 (though in the case of | |
2774 | IVs, it is always used, regardless of platform and build configuration). | |
2775 | ||
2776 | =item * | |
2777 | ||
2778 | The C<$DB::single>, C<$DB::signal> and C<$DB::trace> variables now have set- and | |
2779 | get-magic that stores their values as IVs, and those IVs are used when | |
2780 | testing their values in C<pp_dbstate()>. This prevents perl from | |
2781 | recursing infinitely if an overloaded object is assigned to any of those | |
2782 | variables. | |
2783 | L<[perl #122445]|https://rt.perl.org/Ticket/Display.html?id=122445>. | |
2784 | ||
2785 | =item * | |
2786 | ||
2787 | C<Perl_tmps_grow()>, which is marked as public API but is undocumented, has | |
2788 | been removed from the public API. This change does not affect XS code that | |
2789 | uses the C<EXTEND_MORTAL> macro to pre-extend the mortal stack. | |
2790 | ||
2791 | =item * | |
2792 | ||
2793 | Perl's internals no longer sets or uses the C<SVs_PADMY> flag. | |
2794 | C<SvPADMY()> now returns a true value for anything not marked C<PADTMP> | |
2795 | and C<SVs_PADMY> is now defined as 0. | |
2796 | ||
2797 | =item * | |
2798 | ||
2799 | The macros C<SETsv> and C<SETsvUN> have been removed. They were no longer used | |
2800 | in the core since commit 6f1401dc2a five years ago, and have not been | |
2801 | found present on CPAN. | |
2802 | ||
2803 | =item * | |
2804 | ||
2805 | The C<< SvFAKE >> bit (unused on HVs) got informally reserved by | |
2806 | David Mitchell for future work on vtables. | |
2807 | ||
2808 | =item * | |
2809 | ||
2810 | The C<sv_catpvn_flags()> function accepts C<SV_CATBYTES> and C<SV_CATUTF8> | |
2811 | flags, which specify whether the appended string is bytes or UTF-8, | |
2812 | respectively. (These flags have in fact been present since 5.16.0, but | |
2813 | were formerly not regarded as part of the API.) | |
2814 | ||
2815 | =item * | |
2816 | ||
2817 | A new opcode class, C<< METHOP >>, has been introduced. It holds | |
2818 | information used at runtime to improve the performance | |
2819 | of class/object method calls. | |
2820 | ||
2821 | C<< OP_METHOD >> and C<< OP_METHOD_NAMED >> have changed from being | |
2822 | C<< UNOP/SVOP >> to being C<< METHOP >>. | |
2823 | ||
2824 | =item * | |
2825 | ||
2826 | C<cv_name()> is a new API function that can be passed a CV or GV. It | |
2827 | returns an SV containing the name of the subroutine, for use in | |
2828 | diagnostics. | |
2829 | ||
2830 | L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735> | |
2831 | L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> | |
2832 | ||
2833 | =item * | |
2834 | ||
2835 | C<cv_set_call_checker_flags()> is a new API function that works like | |
2836 | C<cv_set_call_checker()>, except that it allows the caller to specify | |
2837 | whether the call checker requires a full GV for reporting the subroutine's | |
2838 | name, or whether it could be passed a CV instead. Whatever value is | |
2839 | passed will be acceptable to C<cv_name()>. C<cv_set_call_checker()> | |
2840 | guarantees there will be a GV, but it may have to create one on the fly, | |
2841 | which is inefficient. | |
2842 | L<[perl #116735]|https://rt.perl.org/Ticket/Display.html?id=116735> | |
2843 | ||
2844 | =item * | |
2845 | ||
2846 | C<CvGV> (which is not part of the API) is now a more complex macro, which may | |
2847 | call a function and reify a GV. For those cases where it has been used as a | |
2848 | boolean, C<CvHASGV> has been added, which will return true for CVs that | |
2849 | notionally have GVs, but without reifying the GV. C<CvGV> also returns a GV | |
2850 | now for lexical subs. | |
2851 | L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> | |
2852 | ||
2853 | =item * | |
2854 | ||
2855 | The L<perlapi/sync_locale> function has been added to the public API. | |
2856 | Changing the program's locale should be avoided by XS code. Nevertheless, | |
2857 | certain non-Perl libraries called from XS need to do so, such as C<Gtk>. | |
2858 | When this happens, Perl needs to be told that the locale has | |
2859 | changed. Use this function to do so, before returning to Perl. | |
2860 | ||
2861 | =item * | |
2862 | ||
2863 | The defines and labels for the flags in the C<op_private> field of OPs are now | |
2864 | auto-generated from data in F<regen/op_private>. The noticeable effect of this | |
2865 | is that some of the flag output of C<Concise> might differ slightly, and the | |
2866 | flag output of S<C<perl -Dx>> may differ considerably (they both use the same set | |
2867 | of labels now). Also, debugging builds now have a new assertion in | |
2868 | C<op_free()> to ensure that the op doesn't have any unrecognized flags set in | |
2869 | C<op_private>. | |
2870 | ||
2871 | =item * | |
2872 | ||
2873 | The deprecated variable C<PL_sv_objcount> has been removed. | |
2874 | ||
2875 | =item * | |
2876 | ||
2877 | Perl now tries to keep the locale category C<LC_NUMERIC> set to "C" | |
2878 | except around operations that need it to be set to the program's | |
2879 | underlying locale. This protects the many XS modules that cannot cope | |
2880 | with the decimal radix character not being a dot. Prior to this | |
2881 | release, Perl initialized this category to "C", but a call to | |
2882 | C<POSIX::setlocale()> would change it. Now such a call will change the | |
2883 | underlying locale of the C<LC_NUMERIC> category for the program, but the | |
2884 | locale exposed to XS code will remain "C". There are new macros | |
2885 | to manipulate the LC_NUMERIC locale, including | |
2886 | C<STORE_LC_NUMERIC_SET_TO_NEEDED> and | |
2887 | C<STORE_LC_NUMERIC_FORCE_TO_UNDERLYING>. | |
2888 | See L<perlapi/Locale-related functions and macros>. | |
2889 | ||
2890 | =item * | |
2891 | ||
2892 | A new macro L<C<isUTF8_CHAR>|perlapi/isUTF8_CHAR> has been written which | |
2893 | efficiently determines if the string given by its parameters begins | |
2894 | with a well-formed UTF-8 encoded character. | |
2895 | ||
2896 | =item * | |
2897 | ||
2898 | The following private API functions had their context parameter removed: | |
2899 | C<Perl_cast_ulong>, C<Perl_cast_i32>, C<Perl_cast_iv>, C<Perl_cast_uv>, | |
2900 | C<Perl_cv_const_sv>, C<Perl_mg_find>, C<Perl_mg_findext>, C<Perl_mg_magical>, | |
2901 | C<Perl_mini_mktime>, C<Perl_my_dirfd>, C<Perl_sv_backoff>, C<Perl_utf8_hop>. | |
2902 | ||
2903 | Note that the prefix-less versions of those functions that are part of the | |
2904 | public API, such as C<cast_i32()>, remain unaffected. | |
2905 | ||
2906 | =item * | |
2907 | ||
2908 | The C<PADNAME> and C<PADNAMELIST> types are now separate types, and no | |
2909 | longer simply aliases for SV and AV. | |
2910 | L<[perl #123223]|https://rt.perl.org/Ticket/Display.html?id=123223>. | |
2911 | ||
2912 | =item * | |
2913 | ||
2914 | Pad names are now always UTF-8. The C<PadnameUTF8> macro always returns | |
2915 | true. Previously, this was effectively the case already, but any support | |
2916 | for two different internal representations of pad names has now been | |
2917 | removed. | |
2918 | ||
2919 | =item * | |
2920 | ||
2921 | A new op class, C<UNOP_AUX>, has been added. This is a subclass of | |
2922 | C<UNOP> with an C<op_aux> field added, which points to an array of unions | |
2923 | of UV, SV* etc. It is intended for where an op needs to store more data | |
2924 | than a simple C<op_sv> or whatever. Currently the only op of this type is | |
2925 | C<OP_MULTIDEREF> (see next item). | |
2926 | ||
2927 | =item * | |
2928 | ||
2929 | A new op has been added, C<OP_MULTIDEREF>, which performs one or more | |
2930 | nested array and hash lookups where the key is a constant or simple | |
2931 | variable. For example the expression C<$a[0]{$k}[$i]>, which previously | |
2932 | involved ten C<rv2Xv>, C<Xelem>, C<gvsv> and C<const> ops is now performed | |
2933 | by a single C<multideref> op. It can also handle C<local>, C<exists> and | |
2934 | C<delete>. A non-simple index expression, such as C<[$i+1]> is still done | |
2935 | using C<aelem>/C<helem>, and single-level array lookup with a small constant | |
2936 | index is still done using C<aelemfast>. | |
2937 | ||
2938 | =back | |
2939 | ||
2940 | =head1 Selected Bug Fixes | |
2941 | ||
2942 | =over 4 | |
2943 | ||
2944 | =item * | |
2945 | ||
2946 | C<close> now sets C<$!> | |
2947 | ||
2948 | When an I/O error occurs, the fact that there has been an error is recorded | |
2949 | in the handle. C<close> returns false for such a handle. Previously, the | |
2950 | value of C<$!> would be untouched by C<close>, so the common convention of | |
2951 | writing S<C<close $fh or die $!>> did not work reliably. Now the handle | |
2952 | records the value of C<$!>, too, and C<close> restores it. | |
2953 | ||
2954 | =item * | |
2955 | ||
2956 | C<no re> now can turn off everything that C<use re> enables | |
2957 | ||
2958 | Previously, running C<no re> would turn off only a few things. Now it | |
2959 | can turn off all the enabled things. For example, the only way to | |
2960 | stop debugging, once enabled, was to exit the enclosing block; that is | |
2961 | now fixed. | |
2962 | ||
2963 | =item * | |
2964 | ||
2965 | C<pack("D", $x)> and C<pack("F", $x)> now zero the padding on x86 long | |
2966 | double builds. Under some build options on GCC 4.8 and later, they used | |
2967 | to either overwrite the zero-initialized padding, or bypass the | |
2968 | initialized buffer entirely. This caused F<op/pack.t> to fail. | |
2969 | L<[perl #123971]|https://rt.perl.org/Ticket/Display.html?id=123971> | |
2970 | ||
2971 | =item * | |
2972 | ||
2973 | Extending an array cloned from a parent thread could result in "Modification of | |
2974 | a read-only value attempted" errors when attempting to modify the new elements. | |
2975 | L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127> | |
2976 | ||
2977 | =item * | |
2978 | ||
2979 | An assertion failure and subsequent crash with C<< *x=<y> >> has been fixed. | |
2980 | L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790> | |
2981 | ||
2982 | =item * | |
2983 | ||
2984 | A possible crashing/looping bug related to compiling lexical subs has been | |
2985 | fixed. | |
2986 | L<[perl #124099]|https://rt.perl.org/Ticket/Display.html?id=124099> | |
2987 | ||
2988 | =item * | |
2989 | ||
2990 | UTF-8 now works correctly in function names, in unquoted HERE-document | |
2991 | terminators, and in variable names used as array indexes. | |
2992 | L<[perl #124113]|https://rt.perl.org/Ticket/Display.html?id=124113> | |
2993 | ||
2994 | =item * | |
2995 | ||
2996 | Repeated global pattern matches in scalar context on large tainted strings were | |
2997 | exponentially slow depending on the current match position in the string. | |
2998 | L<[perl #123202]|https://rt.perl.org/Ticket/Display.html?id=123202> | |
2999 | ||
3000 | =item * | |
3001 | ||
3002 | Various crashes due to the parser getting confused by syntax errors have been | |
3003 | fixed. | |
3004 | L<[perl #123801]|https://rt.perl.org/Ticket/Display.html?id=123801> | |
3005 | L<[perl #123802]|https://rt.perl.org/Ticket/Display.html?id=123802> | |
3006 | L<[perl #123955]|https://rt.perl.org/Ticket/Display.html?id=123955> | |
3007 | L<[perl #123995]|https://rt.perl.org/Ticket/Display.html?id=123995> | |
3008 | ||
3009 | =item * | |
3010 | ||
3011 | C<split> in the scope of lexical C<$_> has been fixed not to fail assertions. | |
3012 | L<[perl #123763]|https://rt.perl.org/Ticket/Display.html?id=123763> | |
3013 | ||
3014 | =item * | |
3015 | ||
3016 | C<my $x : attr> syntax inside various list operators no longer fails | |
3017 | assertions. | |
3018 | L<[perl #123817]|https://rt.perl.org/Ticket/Display.html?id=123817> | |
3019 | ||
3020 | =item * | |
3021 | ||
3022 | An C<@> sign in quotes followed by a non-ASCII digit (which is not a valid | |
3023 | identifier) would cause the parser to crash, instead of simply trying the | |
3024 | C<@> as literal. This has been fixed. | |
3025 | L<[perl #123963]|https://rt.perl.org/Ticket/Display.html?id=123963> | |
3026 | ||
3027 | =item * | |
3028 | ||
3029 | C<*bar::=*foo::=*glob_with_hash> has been crashing since Perl 5.14, but no | |
3030 | longer does. | |
3031 | L<[perl #123847]|https://rt.perl.org/Ticket/Display.html?id=123847> | |
3032 | ||
3033 | =item * | |
3034 | ||
3035 | C<foreach> in scalar context was not pushing an item on to the stack, resulting | |
3036 | in bugs. (S<C<print 4, scalar do { foreach(@x){} } + 1>> would print 5.) | |
3037 | It has been fixed to return C<undef>. | |
3038 | L<[perl #124004]|https://rt.perl.org/Ticket/Display.html?id=124004> | |
3039 | ||
3040 | =item * | |
3041 | ||
3042 | Several cases of data used to store environment variable contents in core C | |
3043 | code being potentially overwritten before being used have been fixed. | |
3044 | L<[perl #123748]|https://rt.perl.org/Ticket/Display.html?id=123748> | |
3045 | ||
3046 | =item * | |
3047 | ||
3048 | Some patterns starting with C</.*..../> matched against long strings have | |
3049 | been slow since v5.8, and some of the form C</.*..../i> have been slow | |
3050 | since v5.18. They are now all fast again. | |
3051 | L<[perl #123743]|https://rt.perl.org/Ticket/Display.html?id=123743>. | |
3052 | ||
3053 | =item * | |
3054 | ||
3055 | The original visible value of C<$/> is now preserved when it is set to | |
3056 | an invalid value. Previously if you set C<$/> to a reference to an | |
3057 | array, for example, perl would produce a runtime error and not set | |
3058 | C<PL_rs>, but Perl code that checked C<$/> would see the array | |
3059 | reference. | |
3060 | L<[perl #123218]|https://rt.perl.org/Ticket/Display.html?id=123218>. | |
3061 | ||
3062 | =item * | |
3063 | ||
3064 | In a regular expression pattern, a POSIX class, like C<[:ascii:]>, must | |
3065 | be inside a bracketed character class, like C<qr/[[:ascii:]]/>. A | |
3066 | warning is issued when something looking like a POSIX class is not | |
3067 | inside a bracketed class. That warning wasn't getting generated when | |
3068 | the POSIX class was negated: C<[:^ascii:]>. This is now fixed. | |
3069 | ||
3070 | =item * | |
3071 | ||
3072 | Perl 5.14.0 introduced a bug whereby S<C<eval { LABEL: }>> would crash. This | |
3073 | has been fixed. | |
3074 | L<[perl #123652]|https://rt.perl.org/Ticket/Display.html?id=123652>. | |
3075 | ||
3076 | =item * | |
3077 | ||
3078 | Various crashes due to the parser getting confused by syntax errors have | |
3079 | been fixed. | |
3080 | L<[perl #123617]|https://rt.perl.org/Ticket/Display.html?id=123617>. | |
3081 | L<[perl #123737]|https://rt.perl.org/Ticket/Display.html?id=123737>. | |
3082 | L<[perl #123753]|https://rt.perl.org/Ticket/Display.html?id=123753>. | |
3083 | L<[perl #123677]|https://rt.perl.org/Ticket/Display.html?id=123677>. | |
3084 | ||
3085 | =item * | |
3086 | ||
3087 | Code like C</$a[/> used to read the next line of input and treat it as | |
3088 | though it came immediately after the opening bracket. Some invalid code | |
3089 | consequently would parse and run, but some code caused crashes, so this is | |
3090 | now disallowed. | |
3091 | L<[perl #123712]|https://rt.perl.org/Ticket/Display.html?id=123712>. | |
3092 | ||
3093 | =item * | |
3094 | ||
3095 | Fix argument underflow for C<pack>. | |
3096 | L<[perl #123874]|https://rt.perl.org/Ticket/Display.html?id=123874>. | |
3097 | ||
3098 | =item * | |
3099 | ||
3100 | Fix handling of non-strict C<\x{}>. Now C<\x{}> is equivalent to C<\x{0}> | |
3101 | instead of faulting. | |
3102 | ||
3103 | =item * | |
3104 | ||
3105 | C<stat -t> is now no longer treated as stackable, just like C<-t stat>. | |
3106 | L<[perl #123816]|https://rt.perl.org/Ticket/Display.html?id=123816>. | |
3107 | ||
3108 | =item * | |
3109 | ||
3110 | The following no longer causes a SEGV: C<qr{x+(y(?0))*}>. | |
3111 | ||
3112 | =item * | |
3113 | ||
3114 | Fixed infinite loop in parsing backrefs in regexp patterns. | |
3115 | ||
3116 | =item * | |
3117 | ||
3118 | Several minor bug fixes in behavior of Infinity and NaN, including | |
3119 | warnings when stringifying Infinity-like or NaN-like strings. For example, | |
3120 | "NaNcy" doesn't numify to NaN anymore. | |
3121 | ||
3122 | =item * | |
3123 | ||
3124 | A bug in regular expression patterns that could lead to segfaults and | |
3125 | other crashes has been fixed. This occurred only in patterns compiled | |
3126 | with C</i> while taking into account the current POSIX locale (which usually | |
3127 | means they have to be compiled within the scope of C<S<use locale>>), | |
3128 | and there must be a string of at least 128 consecutive bytes to match. | |
3129 | L<[perl #123539]|https://rt.perl.org/Ticket/Display.html?id=123539>. | |
3130 | ||
3131 | =item * | |
3132 | ||
3133 | C<s///g> now works on very long strings (where there are more than 2 | |
3134 | billion iterations) instead of dying with 'Substitution loop'. | |
3135 | L<[perl #103260]|https://rt.perl.org/Ticket/Display.html?id=103260>. | |
3136 | L<[perl #123071]|https://rt.perl.org/Ticket/Display.html?id=123071>. | |
3137 | ||
3138 | =item * | |
3139 | ||
3140 | C<gmtime> no longer crashes with not-a-number values. | |
3141 | L<[perl #123495]|https://rt.perl.org/Ticket/Display.html?id=123495>. | |
3142 | ||
3143 | =item * | |
3144 | ||
3145 | C<\()> (a reference to an empty list), and C<y///> with lexical C<$_> in | |
3146 | scope, could both do a bad write past the end of the stack. They have | |
3147 | both been fixed to extend the stack first. | |
3148 | ||
3149 | =item * | |
3150 | ||
3151 | C<prototype()> with no arguments used to read the previous item on the | |
3152 | stack, so S<C<print "foo", prototype()>> would print foo's prototype. | |
3153 | It has been fixed to infer C<$_> instead. | |
3154 | L<[perl #123514]|https://rt.perl.org/Ticket/Display.html?id=123514>. | |
3155 | ||
3156 | =item * | |
3157 | ||
3158 | Some cases of lexical state subs declared inside predeclared subs could | |
3159 | crash, for example when evalling a string including the name of an outer | |
3160 | variable, but no longer do. | |
3161 | ||
3162 | =item * | |
3163 | ||
3164 | Some cases of nested lexical state subs inside anonymous subs could cause | |
3165 | 'Bizarre copy' errors or possibly even crashes. | |
3166 | ||
3167 | =item * | |
3168 | ||
3169 | When trying to emit warnings, perl's default debugger (F<perl5db.pl>) was | |
3170 | sometimes giving 'Undefined subroutine &DB::db_warn called' instead. This | |
3171 | bug, which started to occur in Perl 5.18, has been fixed. | |
3172 | L<[perl #123553]|https://rt.perl.org/Ticket/Display.html?id=123553>. | |
3173 | ||
3174 | =item * | |
3175 | ||
3176 | Certain syntax errors in substitutions, such as C<< s/${<>{})// >>, would | |
3177 | crash, and had done so since Perl 5.10. (In some cases the crash did not | |
3178 | start happening till 5.16.) The crash has, of course, been fixed. | |
3179 | L<[perl #123542]|https://rt.perl.org/Ticket/Display.html?id=123542>. | |
3180 | ||
3181 | =item * | |
3182 | ||
3183 | Fix a couple of string grow size calculation overflows; in particular, | |
3184 | a repeat expression like S<C<33 x ~3>> could cause a large buffer | |
3185 | overflow since the new output buffer size was not correctly handled by | |
3186 | C<SvGROW()>. An expression like this now properly produces a memory wrap | |
3187 | panic. | |
3188 | L<[perl #123554]|https://rt.perl.org/Ticket/Display.html?id=123554>. | |
3189 | ||
3190 | =item * | |
3191 | ||
3192 | C<< formline("@...", "a"); >> would crash. The C<FF_CHECKNL> case in | |
3193 | C<pp_formline()> didn't set the pointer used to mark the chop position, | |
3194 | which led to the C<FF_MORE> case crashing with a segmentation fault. | |
3195 | This has been fixed. | |
3196 | L<[perl #123538]|https://rt.perl.org/Ticket/Display.html?id=123538>. | |
3197 | ||
3198 | =item * | |
3199 | ||
3200 | A possible buffer overrun and crash when parsing a literal pattern during | |
3201 | regular expression compilation has been fixed. | |
3202 | L<[perl #123604]|https://rt.perl.org/Ticket/Display.html?id=123604>. | |
3203 | ||
3204 | =item * | |
3205 | ||
3206 | C<fchmod()> and C<futimes()> now set C<$!> when they fail due to being | |
3207 | passed a closed file handle. | |
3208 | L<[perl #122703]|https://rt.perl.org/Ticket/Display.html?id=122703>. | |
3209 | ||
3210 | =item * | |
3211 | ||
3212 | C<op_free()> and C<scalarvoid()> no longer crash due to a stack overflow | |
3213 | when freeing a deeply recursive op tree. | |
3214 | L<[perl #108276]|https://rt.perl.org/Ticket/Display.html?id=108276>. | |
3215 | ||
3216 | =item * | |
3217 | ||
3218 | In Perl 5.20.0, C<$^N> accidentally had the internal UTF-8 flag turned off | |
3219 | if accessed from a code block within a regular expression, effectively | |
3220 | UTF-8-encoding the value. This has been fixed. | |
3221 | L<[perl #123135]|https://rt.perl.org/Ticket/Display.html?id=123135>. | |
3222 | ||
3223 | =item * | |
3224 | ||
3225 | A failed C<semctl> call no longer overwrites existing items on the stack, | |
3226 | which means that C<(semctl(-1,0,0,0))[0]> no longer gives an | |
3227 | "uninitialized" warning. | |
3228 | ||
3229 | =item * | |
3230 | ||
3231 | C<else{foo()}> with no space before C<foo> is now better at assigning the | |
3232 | right line number to that statement. | |
3233 | L<[perl #122695]|https://rt.perl.org/Ticket/Display.html?id=122695>. | |
3234 | ||
3235 | =item * | |
3236 | ||
3237 | Sometimes the assignment in C<@array = split> gets optimised so that C<split> | |
3238 | itself writes directly to the array. This caused a bug, preventing this | |
3239 | assignment from being used in lvalue context. So | |
3240 | C<(@a=split//,"foo")=bar()> was an error. (This bug probably goes back to | |
3241 | Perl 3, when the optimisation was added.) It has now been fixed. | |
3242 | L<[perl #123057]|https://rt.perl.org/Ticket/Display.html?id=123057>. | |
3243 | ||
3244 | =item * | |
3245 | ||
3246 | When an argument list fails the checks specified by a subroutine | |
3247 | signature (which is still an experimental feature), the resulting error | |
3248 | messages now give the file and line number of the caller, not of the | |
3249 | called subroutine. | |
3250 | L<[perl #121374]|https://rt.perl.org/Ticket/Display.html?id=121374>. | |
3251 | ||
3252 | =item * | |
3253 | ||
3254 | The flip-flop operators (C<..> and C<...> in scalar context) used to maintain | |
3255 | a separate state for each recursion level (the number of times the | |
3256 | enclosing sub was called recursively), contrary to the documentation. Now | |
3257 | each closure has one internal state for each flip-flop. | |
3258 | L<[perl #122829]|https://rt.perl.org/Ticket/Display.html?id=122829>. | |
3259 | ||
3260 | =item * | |
3261 | ||
3262 | The flip-flop operator (C<..> in scalar context) would return the same | |
3263 | scalar each time, unless the containing subroutine was called recursively. | |
3264 | Now it always returns a new scalar. | |
3265 | L<[perl #122829]|https://rt.perl.org/Ticket/Display.html?id=122829>. | |
3266 | ||
3267 | =item * | |
3268 | ||
3269 | C<use>, C<no>, statement labels, special blocks (C<BEGIN>) and pod are now | |
3270 | permitted as the first thing in a C<map> or C<grep> block, the block after | |
3271 | C<print> or C<say> (or other functions) returning a handle, and within | |
3272 | C<${...}>, C<@{...}>, etc. | |
3273 | L<[perl #122782]|https://rt.perl.org/Ticket/Display.html?id=122782>. | |
3274 | ||
3275 | =item * | |
3276 | ||
3277 | The repetition operator C<x> now propagates lvalue context to its left-hand | |
3278 | argument when used in contexts like C<foreach>. That allows | |
3279 | S<C<for(($#that_array)x2) { ... }>> to work as expected if the loop modifies | |
3280 | C<$_>. | |
3281 | ||
3282 | =item * | |
3283 | ||
3284 | C<(...) x ...> in scalar context used to corrupt the stack if one operand | |
3285 | was an object with "x" overloading, causing erratic behavior. | |
3286 | L<[perl #121827]|https://rt.perl.org/Ticket/Display.html?id=121827>. | |
3287 | ||
3288 | =item * | |
3289 | ||
3290 | Assignment to a lexical scalar is often optimised away; for example in | |
3291 | C<my $x; $x = $y + $z>, the assign operator is optimised away and the add | |
3292 | operator writes its result directly to C<$x>. Various bugs related to | |
3293 | this optimisation have been fixed. Certain operators on the right-hand | |
3294 | side would sometimes fail to assign the value at all or assign the wrong | |
3295 | value, or would call STORE twice or not at all on tied variables. The | |
3296 | operators affected were C<$foo++>, C<$foo-->, and C<-$foo> under C<use | |
3297 | integer>, C<chomp>, C<chr> and C<setpgrp>. | |
3298 | ||
3299 | =item * | |
3300 | ||
3301 | List assignments were sometimes buggy if the same scalar ended up on both | |
3302 | sides of the assignment due to use of C<tied>, C<values> or C<each>. The | |
3303 | result would be the wrong value getting assigned. | |
3304 | ||
3305 | =item * | |
3306 | ||
3307 | C<setpgrp($nonzero)> (with one argument) was accidentally changed in 5.16 | |
3308 | to mean C<setpgrp(0)>. This has been fixed. | |
3309 | ||
3310 | =item * | |
3311 | ||
3312 | C<__SUB__> could return the wrong value or even corrupt memory under the | |
3313 | debugger (the C<-d> switch) and in subs containing C<eval $string>. | |
3314 | ||
3315 | =item * | |
3316 | ||
3317 | When S<C<sub () { $var }>> becomes inlinable, it now returns a different | |
3318 | scalar each time, just as a non-inlinable sub would, though Perl still | |
3319 | optimises the copy away in cases where it would make no observable | |
3320 | difference. | |
3321 | ||
3322 | =item * | |
3323 | ||
3324 | S<C<my sub f () { $var }>> and S<C<sub () : attr { $var }>> are no longer | |
3325 | eligible for inlining. The former would crash; the latter would just | |
3326 | throw the attributes away. An exception is made for the little-known | |
3327 | C<:method> attribute, which does nothing much. | |
3328 | ||
3329 | =item * | |
3330 | ||
3331 | Inlining of subs with an empty prototype is now more consistent than | |
3332 | before. Previously, a sub with multiple statements, of which all but the last | |
3333 | were optimised away, would be inlinable only if it were an anonymous sub | |
3334 | containing a string C<eval> or C<state> declaration or closing over an | |
3335 | outer lexical variable (or any anonymous sub under the debugger). Now any | |
3336 | sub that gets folded to a single constant after statements have been | |
3337 | optimised away is eligible for inlining. This applies to things like C<sub | |
3338 | () { jabber() if DEBUG; 42 }>. | |
3339 | ||
3340 | Some subroutines with an explicit C<return> were being made inlinable, | |
3341 | contrary to the documentation, Now C<return> always prevents inlining. | |
3342 | ||
3343 | =item * | |
3344 | ||
3345 | On some systems, such as VMS, C<crypt> can return a non-ASCII string. If a | |
3346 | scalar assigned to had contained a UTF-8 string previously, then C<crypt> | |
3347 | would not turn off the UTF-8 flag, thus corrupting the return value. This | |
3348 | would happen with S<C<$lexical = crypt ...>>. | |
3349 | ||
3350 | =item * | |
3351 | ||
3352 | C<crypt> no longer calls C<FETCH> twice on a tied first argument. | |
3353 | ||
3354 | =item * | |
3355 | ||
3356 | An unterminated here-doc on the last line of a quote-like operator | |
3357 | (C<qq[${ <<END }]>, C</(?{ <<END })/>) no longer causes a double free. It | |
3358 | started doing so in 5.18. | |
3359 | ||
3360 | =item * | |
3361 | ||
3362 | C<index()> and C<rindex()> no longer crash when used on strings over 2GB in | |
3363 | size. | |
3364 | L<[perl #121562]|https://rt.perl.org/Ticket/Display.html?id=121562>. | |
3365 | ||
3366 | =item * | |
3367 | ||
3368 | A small, previously intentional, memory leak in | |
3369 | C<PERL_SYS_INIT>/C<PERL_SYS_INIT3> on Win32 builds was fixed. This might | |
3370 | affect embedders who repeatedly create and destroy perl engines within | |
3371 | the same process. | |
3372 | ||
3373 | =item * | |
3374 | ||
3375 | C<POSIX::localeconv()> now returns the data for the program's underlying | |
3376 | locale even when called from outside the scope of S<C<use locale>>. | |
3377 | ||
3378 | =item * | |
3379 | ||
3380 | C<POSIX::localeconv()> now works properly on platforms which don't have | |
3381 | C<LC_NUMERIC> and/or C<LC_MONETARY>, or for which Perl has been compiled | |
3382 | to disregard either or both of these locale categories. In such | |
3383 | circumstances, there are now no entries for the corresponding values in | |
3384 | the hash returned by C<localeconv()>. | |
3385 | ||
3386 | =item * | |
3387 | ||
3388 | C<POSIX::localeconv()> now marks appropriately the values it returns as | |
3389 | UTF-8 or not. Previously they were always returned as bytes, even if | |
3390 | they were supposed to be encoded as UTF-8. | |
3391 | ||
3392 | =item * | |
3393 | ||
3394 | On Microsoft Windows, within the scope of C<S<use locale>>, the following | |
3395 | POSIX character classes gave results for many locales that did not | |
3396 | conform to the POSIX standard: | |
3397 | C<[[:alnum:]]>, | |
3398 | C<[[:alpha:]]>, | |
3399 | C<[[:blank:]]>, | |
3400 | C<[[:digit:]]>, | |
3401 | C<[[:graph:]]>, | |
3402 | C<[[:lower:]]>, | |
3403 | C<[[:print:]]>, | |
3404 | C<[[:punct:]]>, | |
3405 | C<[[:upper:]]>, | |
3406 | C<[[:word:]]>, | |
3407 | and | |
3408 | C<[[:xdigit:]]>. | |
3409 | This was because the underlying Microsoft implementation does not | |
3410 | follow the standard. Perl now takes special precautions to correct for | |
3411 | this. | |
3412 | ||
3413 | =item * | |
3414 | ||
3415 | Many issues have been detected by L<Coverity|http://www.coverity.com/> and | |
3416 | fixed. | |
3417 | ||
3418 | =item * | |
3419 | ||
3420 | C<system()> and friends should now work properly on more Android builds. | |
3421 | ||
3422 | Due to an oversight, the value specified through C<-Dtargetsh> to F<Configure> | |
3423 | would end up being ignored by some of the build process. This caused perls | |
3424 | cross-compiled for Android to end up with defective versions of C<system()>, | |
3425 | C<exec()> and backticks: the commands would end up looking for C</bin/sh> | |
3426 | instead of C</system/bin/sh>, and so would fail for the vast majority | |
3427 | of devices, leaving C<$!> as C<ENOENT>. | |
3428 | ||
3429 | =item * | |
3430 | ||
3431 | C<qr(...\(...\)...)>, | |
3432 | C<qr[...\[...\]...]>, | |
3433 | and | |
3434 | C<qr{...\{...\}...}> | |
3435 | now work. Previously it was impossible to escape these three | |
3436 | left-characters with a backslash within a regular expression pattern | |
3437 | where otherwise they would be considered metacharacters, and the pattern | |
3438 | opening delimiter was the character, and the closing delimiter was its | |
3439 | mirror character. | |
3440 | ||
3441 | =item * | |
3442 | ||
3443 | C<< s///e >> on tainted UTF-8 strings corrupted C<< pos() >>. This bug, | |
3444 | introduced in 5.20, is now fixed. | |
3445 | L<[perl #122148]|https://rt.perl.org/Ticket/Display.html?id=122148>. | |
3446 | ||
3447 | =item * | |
3448 | ||
3449 | A non-word boundary in a regular expression (C<< \B >>) did not always | |
3450 | match the end of the string; in particular C<< q{} =~ /\B/ >> did not | |
3451 | match. This bug, introduced in perl 5.14, is now fixed. | |
3452 | L<[perl #122090]|https://rt.perl.org/Ticket/Display.html?id=122090>. | |
3453 | ||
3454 | =item * | |
3455 | ||
3456 | C<< " P" =~ /(?=.*P)P/ >> should match, but did not. This is now fixed. | |
3457 | L<[perl #122171]|https://rt.perl.org/Ticket/Display.html?id=122171>. | |
3458 | ||
3459 | =item * | |
3460 | ||
3461 | Failing to compile C<use Foo> in an C<eval> could leave a spurious | |
3462 | C<BEGIN> subroutine definition, which would produce a "Subroutine | |
3463 | BEGIN redefined" warning on the next use of C<use>, or other C<BEGIN> | |
3464 | block. | |
3465 | L<[perl #122107]|https://rt.perl.org/Ticket/Display.html?id=122107>. | |
3466 | ||
3467 | =item * | |
3468 | ||
3469 | C<method { BLOCK } ARGS> syntax now correctly parses the arguments if they | |
3470 | begin with an opening brace. | |
3471 | L<[perl #46947]|https://rt.perl.org/Ticket/Display.html?id=46947>. | |
3472 | ||
3473 | =item * | |
3474 | ||
3475 | External libraries and Perl may have different ideas of what the locale is. | |
3476 | This is problematic when parsing version strings if the locale's numeric | |
3477 | separator has been changed. Version parsing has been patched to ensure | |
3478 | it handles the locales correctly. | |
3479 | L<[perl #121930]|https://rt.perl.org/Ticket/Display.html?id=121930>. | |
3480 | ||
3481 | =item * | |
3482 | ||
3483 | A bug has been fixed where zero-length assertions and code blocks inside of a | |
3484 | regex could cause C<pos> to see an incorrect value. | |
3485 | L<[perl #122460]|https://rt.perl.org/Ticket/Display.html?id=122460>. | |
3486 | ||
3487 | =item * | |
3488 | ||
3489 | Dereferencing of constants now works correctly for typeglob constants. Previously | |
3490 | the glob was stringified and its name looked up. Now the glob itself is used. | |
3491 | L<[perl #69456]|https://rt.perl.org/Ticket/Display.html?id=69456> | |
3492 | ||
3493 | =item * | |
3494 | ||
3495 | When parsing a sigil (C<$> C<@> C<%> C<&)> followed by braces, | |
3496 | the parser no | |
3497 | longer tries to guess whether it is a block or a hash constructor (causing a | |
3498 | syntax error when it guesses the latter), since it can only be a block. | |
3499 | ||
3500 | =item * | |
3501 | ||
3502 | S<C<undef $reference>> now frees the referent immediately, instead of hanging on | |
3503 | to it until the next statement. | |
3504 | L<[perl #122556]|https://rt.perl.org/Ticket/Display.html?id=122556> | |
3505 | ||
3506 | =item * | |
3507 | ||
3508 | Various cases where the name of a sub is used (autoload, overloading, error | |
3509 | messages) used to crash for lexical subs, but have been fixed. | |
3510 | ||
3511 | =item * | |
3512 | ||
3513 | Bareword lookup now tries to avoid vivifying packages if it turns out the | |
3514 | bareword is not going to be a subroutine name. | |
3515 | ||
3516 | =item * | |
3517 | ||
3518 | Compilation of anonymous constants (I<e.g.>, C<sub () { 3 }>) no longer deletes | |
3519 | any subroutine named C<__ANON__> in the current package. Not only was | |
3520 | C<*__ANON__{CODE}> cleared, but there was a memory leak, too. This bug goes | |
3521 | back to Perl 5.8.0. | |
3522 | ||
3523 | =item * | |
3524 | ||
3525 | Stub declarations like C<sub f;> and C<sub f ();> no longer wipe out constants | |
3526 | of the same name declared by C<use constant>. This bug was introduced in Perl | |
3527 | 5.10.0. | |
3528 | ||
3529 | =item * | |
3530 | ||
3531 | C<qr/[\N{named sequence}]/> now works properly in many instances. | |
3532 | ||
3533 | Some names | |
3534 | known to C<\N{...}> refer to a sequence of multiple characters, instead of the | |
3535 | usual single character. Bracketed character classes generally only match | |
3536 | single characters, but now special handling has been added so that they can | |
3537 | match named sequences, but not if the class is inverted or the sequence is | |
3538 | specified as the beginning or end of a range. In these cases, the only | |
3539 | behavior change from before is a slight rewording of the fatal error message | |
3540 | given when this class is part of a C<?[...])> construct. When the C<[...]> | |
3541 | stands alone, the same non-fatal warning as before is raised, and only the | |
3542 | first character in the sequence is used, again just as before. | |
3543 | ||
3544 | =item * | |
3545 | ||
3546 | Tainted constants evaluated at compile time no longer cause unrelated | |
3547 | statements to become tainted. | |
3548 | L<[perl #122669]|https://rt.perl.org/Ticket/Display.html?id=122669> | |
3549 | ||
3550 | =item * | |
3551 | ||
3552 | S<C<open $$fh, ...>>, which vivifies a handle with a name like | |
3553 | C<"main::_GEN_0">, was not giving the handle the right reference count, so | |
3554 | a double free could happen. | |
3555 | ||
3556 | =item * | |
3557 | ||
3558 | When deciding that a bareword was a method name, the parser would get confused | |
3559 | if an C<our> sub with the same name existed, and look up the method in the | |
3560 | package of the C<our> sub, instead of the package of the invocant. | |
3561 | ||
3562 | =item * | |
3563 | ||
3564 | The parser no longer gets confused by C<\U=> within a double-quoted string. It | |
3565 | used to produce a syntax error, but now compiles it correctly. | |
3566 | L<[perl #80368]|https://rt.perl.org/Ticket/Display.html?id=80368> | |
3567 | ||
3568 | =item * | |
3569 | ||
3570 | It has always been the intention for the C<-B> and C<-T> file test operators to | |
3571 | treat UTF-8 encoded files as text. (L<perlfunc|perlfunc/-X FILEHANDLE> has | |
3572 | been updated to say this.) Previously, it was possible for some files to be | |
3573 | considered UTF-8 that actually weren't valid UTF-8. This is now fixed. The | |
3574 | operators now work on EBCDIC platforms as well. | |
3575 | ||
3576 | =item * | |
3577 | ||
3578 | Under some conditions warning messages raised during regular expression pattern | |
3579 | compilation were being output more than once. This has now been fixed. | |
3580 | ||
3581 | =item * | |
3582 | ||
3583 | Perl 5.20.0 introduced a regression in which a UTF-8 encoded regular | |
3584 | expression pattern that contains a single ASCII lowercase letter did not | |
3585 | match its uppercase counterpart. That has been fixed in both 5.20.1 and | |
3586 | 5.22.0. | |
3587 | L<[perl #122655]|https://rt.perl.org/Ticket/Display.html?id=122655> | |
3588 | ||
3589 | =item * | |
3590 | ||
3591 | Constant folding could incorrectly suppress warnings if lexical warnings | |
3592 | (C<use warnings> or C<no warnings>) were not in effect and C<$^W> were | |
3593 | false at compile time and true at run time. | |
3594 | ||
3595 | =item * | |
3596 | ||
3597 | Loading Unicode tables during a regular expression match could cause assertion | |
3598 | failures under debugging builds if the previous match used the very same | |
3599 | regular expression. | |
3600 | L<[perl #122747]|https://rt.perl.org/Ticket/Display.html?id=122747> | |
3601 | ||
3602 | =item * | |
3603 | ||
3604 | Thread cloning used to work incorrectly for lexical subs, possibly causing | |
3605 | crashes or double frees on exit. | |
3606 | ||
3607 | =item * | |
3608 | ||
3609 | Since Perl 5.14.0, deleting C<$SomePackage::{__ANON__}> and then undefining an | |
3610 | anonymous subroutine could corrupt things internally, resulting in | |
3611 | L<Devel::Peek> crashing or L<B.pm|B> giving nonsensical data. This has been | |
3612 | fixed. | |
3613 | ||
3614 | =item * | |
3615 | ||
3616 | S<C<(caller $n)[3]>> now reports names of lexical subs, instead of | |
3617 | treating them as C<"(unknown)">. | |
3618 | ||
3619 | =item * | |
3620 | ||
3621 | C<sort subname LIST> now supports using a lexical sub as the comparison | |
3622 | routine. | |
3623 | ||
3624 | =item * | |
3625 | ||
3626 | Aliasing (I<e.g.>, via S<C<*x = *y>>) could confuse list assignments that mention the | |
3627 | two names for the same variable on either side, causing wrong values to be | |
3628 | assigned. | |
3629 | L<[perl #15667]|https://rt.perl.org/Ticket/Display.html?id=15667> | |
3630 | ||
3631 | =item * | |
3632 | ||
3633 | Long here-doc terminators could cause a bad read on short lines of input. This | |
3634 | has been fixed. It is doubtful that any crash could have occurred. This bug | |
3635 | goes back to when here-docs were introduced in Perl 3.000 twenty-five years | |
3636 | ago. | |
3637 | ||
3638 | =item * | |
3639 | ||
3640 | An optimization in C<split> to treat S<C<split /^/>> like S<C<split /^/m>> had the | |
3641 | unfortunate side-effect of also treating S<C<split /\A/>> like S<C<split /^/m>>, | |
3642 | which it should not. This has been fixed. (Note, however, that S<C<split /^x/>> | |
3643 | does not behave like S<C<split /^x/m>>, which is also considered to be a bug and | |
3644 | will be fixed in a future version.) | |
3645 | L<[perl #122761]|https://rt.perl.org/Ticket/Display.html?id=122761> | |
3646 | ||
3647 | =item * | |
3648 | ||
3649 | The little-known S<C<my Class $var>> syntax (see L<fields> and L<attributes>) | |
3650 | could get confused in the scope of C<use utf8> if C<Class> were a constant | |
3651 | whose value contained Latin-1 characters. | |
3652 | ||
3653 | =item * | |
3654 | ||
3655 | Locking and unlocking values via L<Hash::Util> or C<Internals::SvREADONLY> | |
3656 | no longer has any effect on values that were read-only to begin with. | |
3657 | Previously, unlocking such values could result in crashes, hangs or | |
3658 | other erratic behavior. | |
3659 | ||
3660 | =item * | |
3661 | ||
3662 | Some unterminated C<(?(...)...)> constructs in regular expressions would | |
3663 | either crash or give erroneous error messages. C</(?(1)/> is one such | |
3664 | example. | |
3665 | ||
3666 | =item * | |
3667 | ||
3668 | S<C<pack "w", $tied>> no longer calls FETCH twice. | |
3669 | ||
3670 | =item * | |
3671 | ||
3672 | List assignments like S<C<($x, $z) = (1, $y)>> now work correctly if C<$x> and | |
3673 | C<$y> have been aliased by C<foreach>. | |
3674 | ||
3675 | =item * | |
3676 | ||
3677 | Some patterns including code blocks with syntax errors, such as | |
3678 | S<C</ (?{(^{})/>>, would hang or fail assertions on debugging builds. Now | |
3679 | they produce errors. | |
3680 | ||
3681 | =item * | |
3682 | ||
3683 | An assertion failure when parsing C<sort> with debugging enabled has been | |
3684 | fixed. | |
3685 | L<[perl #122771]|https://rt.perl.org/Ticket/Display.html?id=122771>. | |
3686 | ||
3687 | =item * | |
3688 | ||
3689 | S<C<*a = *b; @a = split //, $b[1]>> could do a bad read and produce junk | |
3690 | results. | |
3691 | ||
3692 | =item * | |
3693 | ||
3694 | In S<C<() = @array = split>>, the S<C<() =>> at the beginning no longer confuses | |
3695 | the optimizer into assuming a limit of 1. | |
3696 | ||
3697 | =item * | |
3698 | ||
3699 | Fatal warnings no longer prevent the output of syntax errors. | |
3700 | L<[perl #122966]|https://rt.perl.org/Ticket/Display.html?id=122966>. | |
3701 | ||
3702 | =item * | |
3703 | ||
3704 | Fixed a NaN double-to-long-double conversion error on VMS. For quiet NaNs | |
3705 | (and only on Itanium, not Alpha) negative infinity instead of NaN was | |
3706 | produced. | |
3707 | ||
3708 | =item * | |
3709 | ||
3710 | Fixed the issue that caused C<< make distclean >> to incorrectly leave some | |
3711 | files behind. | |
3712 | L<[perl #122820]|https://rt.perl.org/Ticket/Display.html?id=122820>. | |
3713 | ||
3714 | =item * | |
3715 | ||
3716 | AIX now sets the length in C<< getsockopt >> correctly. | |
3717 | L<[perl #120835]|https://rt.perl.org/Ticket/Display.html?id=120835>. | |
3718 | L<[cpan #91183]|https://rt.cpan.org/Ticket/Display.html?id=91183>. | |
3719 | L<[cpan #85570]|https://rt.cpan.org/Ticket/Display.html?id=85570>. | |
3720 | ||
3721 | =item * | |
3722 | ||
3723 | The optimization phase of a regexp compilation could run "forever" and | |
3724 | exhaust all memory under certain circumstances; now fixed. | |
3725 | L<[perl #122283]|https://rt.perl.org/Ticket/Display.html?id=122283>. | |
3726 | ||
3727 | =item * | |
3728 | ||
3729 | The test script F<< t/op/crypt.t >> now uses the SHA-256 algorithm if the | |
3730 | default one is disabled, rather than giving failures. | |
3731 | L<[perl #121591]|https://rt.perl.org/Ticket/Display.html?id=121591>. | |
3732 | ||
3733 | =item * | |
3734 | ||
3735 | Fixed an off-by-one error when setting the size of a shared array. | |
3736 | L<[perl #122950]|https://rt.perl.org/Ticket/Display.html?id=122950>. | |
3737 | ||
3738 | =item * | |
3739 | ||
3740 | Fixed a bug that could cause perl to enter an infinite loop during | |
3741 | compilation. In particular, a C<while(1)> within a sublist, I<e.g.> | |
3742 | ||
3743 | sub foo { () = ($a, my $b, ($c, do { while(1) {} })) } | |
3744 | ||
3745 | The bug was introduced in 5.20.0 | |
3746 | L<[perl #122995]|https://rt.perl.org/Ticket/Display.html?id=122995>. | |
3747 | ||
3748 | =item * | |
3749 | ||
3750 | On Win32, if a variable was C<local>-ized in a pseudo-process that later | |
3751 | forked, restoring the original value in the child pseudo-process caused | |
3752 | memory corruption and a crash in the child pseudo-process (and therefore the | |
3753 | OS process). | |
3754 | L<[perl #40565]|https://rt.perl.org/Ticket/Display.html?id=40565>. | |
3755 | ||
3756 | =item * | |
3757 | ||
3758 | Calling C<write> on a format with a C<^**> field could produce a panic | |
3759 | in C<sv_chop()> if there were insufficient arguments or if the variable | |
3760 | used to fill the field was empty. | |
3761 | L<[perl #123245]|https://rt.perl.org/Ticket/Display.html?id=123245>. | |
3762 | ||
3763 | =item * | |
3764 | ||
3765 | Non-ASCII lexical sub names now appear without trailing junk when they | |
3766 | appear in error messages. | |
3767 | ||
3768 | =item * | |
3769 | ||
3770 | The C<\@> subroutine prototype no longer flattens parenthesized arrays | |
3771 | (taking a reference to each element), but takes a reference to the array | |
3772 | itself. | |
3773 | L<[perl #47363]|https://rt.perl.org/Ticket/Display.html?id=47363>. | |
3774 | ||
3775 | =item * | |
3776 | ||
3777 | A block containing nothing except a C-style C<for> loop could corrupt the | |
3778 | stack, causing lists outside the block to lose elements or have elements | |
3779 | overwritten. This could happen with C<map { for(...){...} } ...> and with | |
3780 | lists containing C<do { for(...){...} }>. | |
3781 | L<[perl #123286]|https://rt.perl.org/Ticket/Display.html?id=123286>. | |
3782 | ||
3783 | =item * | |
3784 | ||
3785 | C<scalar()> now propagates lvalue context, so that | |
3786 | S<C<for(scalar($#foo)) { ... }>> can modify C<$#foo> through C<$_>. | |
3787 | ||
3788 | =item * | |
3789 | ||
3790 | C<qr/@array(?{block})/> no longer dies with "Bizarre copy of ARRAY". | |
3791 | L<[perl #123344]|https://rt.perl.org/Ticket/Display.html?id=123344>. | |
3792 | ||
3793 | =item * | |
3794 | ||
3795 | S<C<eval '$variable'>> in nested named subroutines would sometimes look up a | |
3796 | global variable even with a lexical variable in scope. | |
3797 | ||
3798 | =item * | |
3799 | ||
3800 | In perl 5.20.0, C<sort CORE::fake> where 'fake' is anything other than a | |
3801 | keyword, started chopping off the last 6 characters and treating the result | |
3802 | as a sort sub name. The previous behavior of treating C<CORE::fake> as a | |
3803 | sort sub name has been restored. | |
3804 | L<[perl #123410]|https://rt.perl.org/Ticket/Display.html?id=123410>. | |
3805 | ||
3806 | =item * | |
3807 | ||
3808 | Outside of C<use utf8>, a single-character Latin-1 lexical variable is | |
3809 | disallowed. The error message for it, "Can't use global C<$foo>...", was | |
3810 | giving garbage instead of the variable name. | |
3811 | ||
3812 | =item * | |
3813 | ||
3814 | C<readline> on a nonexistent handle was causing C<${^LAST_FH}> to produce a | |
3815 | reference to an undefined scalar (or fail an assertion). Now | |
3816 | C<${^LAST_FH}> ends up undefined. | |
3817 | ||
3818 | =item * | |
3819 | ||
3820 | C<(...) x ...> in void context now applies scalar context to the left-hand | |
3821 | argument, instead of the context the current sub was called in. | |
3822 | L<[perl #123020]|https://rt.perl.org/Ticket/Display.html?id=123020>. | |
3823 | ||
3824 | =back | |
3825 | ||
3826 | =head1 Known Problems | |
3827 | ||
3828 | =over 4 | |
3829 | ||
3830 | =item * | |
3831 | ||
3832 | C<pack>-ing a NaN on a perl compiled with Visual C 6 does not behave properly, | |
3833 | leading to a test failure in F<t/op/infnan.t>. | |
3834 | L<[perl 125203]|https://rt.perl.org/Ticket/Display.html?id=125203> | |
3835 | ||
3836 | =item * | |
3837 | ||
3838 | A goal is for Perl to be able to be recompiled to work reasonably well on any | |
3839 | Unicode version. In Perl 5.22, though, the earliest such version is Unicode | |
3840 | 5.1 (current is 7.0). | |
3841 | ||
3842 | =item * | |
3843 | ||
3844 | EBCDIC platforms | |
3845 | ||
3846 | =over 4 | |
3847 | ||
3848 | =item * | |
3849 | ||
3850 | The C<cmp> (and hence C<sort>) operators do not necessarily give the | |
3851 | correct results when both operands are UTF-EBCDIC encoded strings and | |
3852 | there is a mixture of ASCII and/or control characters, along with other | |
3853 | characters. | |
3854 | ||
3855 | =item * | |
3856 | ||
3857 | Ranges containing C<\N{...}> in the C<tr///> (and C<y///>) | |
3858 | transliteration operators are treated differently than the equivalent | |
3859 | ranges in regular expression patterns. They should, but don't, cause | |
3860 | the values in the ranges to all be treated as Unicode code points, and | |
3861 | not native ones. (L<perlre/Version 8 Regular Expressions> gives | |
3862 | details as to how it should work.) | |
3863 | ||
3864 | =item * | |
3865 | ||
3866 | Encode and encoding are mostly broken. | |
3867 | ||
3868 | =item * | |
3869 | ||
3870 | Many CPAN modules that are shipped with core show failing tests. | |
3871 | ||
3872 | =item * | |
3873 | ||
3874 | C<pack>/C<unpack> with C<"U0"> format may not work properly. | |
3875 | ||
3876 | =back | |
3877 | ||
3878 | =item * | |
3879 | ||
3880 | The following modules are known to have test failures with this version of | |
3881 | Perl. In many cases, patches have been submitted, so there will hopefully be | |
3882 | new releases soon: | |
3883 | ||
3884 | =over | |
3885 | ||
3886 | =item * | |
3887 | ||
3888 | L<B::Generate> version 1.50 | |
3889 | ||
3890 | =item * | |
3891 | ||
3892 | L<B::Utils> version 0.25 | |
3893 | ||
3894 | =item * | |
3895 | ||
3896 | L<Coro> version 6.42 | |
3897 | ||
3898 | =item * | |
3899 | ||
3900 | L<Dancer> version 1.3130 | |
3901 | ||
3902 | =item * | |
3903 | ||
3904 | L<Data::Alias> version 1.18 | |
3905 | ||
3906 | =item * | |
3907 | ||
3908 | L<Data::Dump::Streamer> version 2.38 | |
3909 | ||
3910 | =item * | |
3911 | ||
3912 | L<Data::Util> version 0.63 | |
3913 | ||
3914 | =item * | |
3915 | ||
3916 | L<Devel::Spy> version 0.07 | |
3917 | ||
3918 | =item * | |
3919 | ||
3920 | L<invoker> version 0.34 | |
3921 | ||
3922 | =item * | |
3923 | ||
3924 | L<Lexical::Var> version 0.009 | |
3925 | ||
3926 | =item * | |
3927 | ||
3928 | L<LWP::ConsoleLogger> version 0.000018 | |
3929 | ||
3930 | =item * | |
3931 | ||
3932 | L<Mason> version 2.22 | |
3933 | ||
3934 | =item * | |
3935 | ||
3936 | L<NgxQueue> version 0.02 | |
3937 | ||
3938 | =item * | |
3939 | ||
3940 | L<Padre> version 1.00 | |
3941 | ||
3942 | =item * | |
3943 | ||
3944 | L<Parse::Keyword> 0.08 | |
3945 | ||
3946 | =back | |
3947 | ||
3948 | =back | |
3949 | ||
3950 | =head1 Obituary | |
3951 | ||
3952 | Brian McCauley died on May 8, 2015. He was a frequent poster to Usenet, Perl | |
3953 | Monks, and other Perl forums, and made several CPAN contributions under the | |
3954 | nick NOBULL, including to the Perl FAQ. He attended almost every | |
3955 | YAPC::Europe, and indeed, helped organise YAPC::Europe 2006 and the QA | |
3956 | Hackathon 2009. His wit and his delight in intricate systems were | |
3957 | particularly apparent in his love of board games; many Perl mongers will | |
3958 | have fond memories of playing Fluxx and other games with Brian. He will be | |
3959 | missed. | |
3960 | ||
3961 | =head1 Acknowledgements | |
3962 | ||
3963 | Perl 5.22.0 represents approximately 12 months of development since Perl 5.20.0 | |
3964 | and contains approximately 590,000 lines of changes across 2,400 files from 94 | |
3965 | authors. | |
3966 | ||
3967 | Excluding auto-generated files, documentation and release tools, there were | |
3968 | approximately 370,000 lines of changes to 1,500 .pm, .t, .c and .h files. | |
3969 | ||
3970 | Perl continues to flourish into its third decade thanks to a vibrant community | |
3971 | of users and developers. The following people are known to have contributed the | |
3972 | improvements that became Perl 5.22.0: | |
3973 | ||
3974 | Aaron Crane, Abhijit Menon-Sen, Abigail, Alberto Simões, Alex Solovey, Alex | |
3975 | Vandiver, Alexandr Ciornii, Alexandre (Midnite) Jousset, Andreas König, | |
3976 | Andreas Voegele, Andrew Fresh, Andy Dougherty, Anthony Heading, Aristotle | |
3977 | Pagaltzis, brian d foy, Brian Fraser, Chad Granum, Chris 'BinGOs' Williams, | |
3978 | Craig A. Berry, Dagfinn Ilmari Mannsåker, Daniel Dragan, Darin McBride, Dave | |
3979 | Rolsky, David Golden, David Mitchell, David Wheeler, Dmitri Tikhonov, Doug | |
3980 | Bell, E. Choroba, Ed J, Eric Herman, Father Chrysostomos, George Greer, Glenn | |
3981 | D. Golden, Graham Knop, H.Merijn Brand, Herbert Breunung, Hugo van der Sanden, | |
3982 | James E Keenan, James McCoy, James Raspass, Jan Dubois, Jarkko Hietaniemi, | |
3983 | Jasmine Ngan, Jerry D. Hedden, Jim Cromie, John Goodyear, kafka, Karen | |
3984 | Etheridge, Karl Williamson, Kent Fredric, kmx, Lajos Veres, Leon Timmermans, | |
3985 | Lukas Mai, Mathieu Arnold, Matthew Horsfall, Max Maischein, Michael Bunk, | |
3986 | Nicholas Clark, Niels Thykier, Niko Tyni, Norman Koch, Olivier Mengué, Peter | |
3987 | John Acklam, Peter Martini, Petr Písař, Philippe Bruhat (BooK), Pierre | |
3988 | Bogossian, Rafael Garcia-Suarez, Randy Stauner, Reini Urban, Ricardo Signes, | |
3989 | Rob Hoelz, Rostislav Skudnov, Sawyer X, Shirakata Kentaro, Shlomi Fish, | |
3990 | Sisyphus, Slaven Rezic, Smylers, Steffen Müller, Steve Hay, Sullivan Beck, | |
3991 | syber, Tadeusz Sośnierz, Thomas Sibley, Todd Rinaldo, Tony Cook, Vincent Pit, | |
3992 | Vladimir Marek, Yaroslav Kuzmin, Yves Orton, Ævar Arnfjörð Bjarmason. | |
3993 | ||
3994 | The list above is almost certainly incomplete as it is automatically generated | |
3995 | from version control history. In particular, it does not include the names of | |
3996 | the (very much appreciated) contributors who reported issues to the Perl bug | |
3997 | tracker. | |
3998 | ||
3999 | Many of the changes included in this version originated in the CPAN modules | |
4000 | included in Perl's core. We're grateful to the entire CPAN community for | |
4001 | helping Perl to flourish. | |
4002 | ||
4003 | For a more complete list of all of Perl's historical contributors, please see | |
4004 | the F<AUTHORS> file in the Perl source distribution. | |
4005 | ||
4006 | =head1 Reporting Bugs | |
4007 | ||
4008 | If you find what you think is a bug, you might check the articles recently | |
4009 | posted to the comp.lang.perl.misc newsgroup and the perl bug database at | |
4010 | L<https://rt.perl.org/>. There may also be information at | |
4011 | L<http://www.perl.org/>, the Perl Home Page. | |
4012 | ||
4013 | If you believe you have an unreported bug, please run the L<perlbug> program | |
4014 | included with your release. Be sure to trim your bug down to a tiny but | |
4015 | sufficient test case. Your bug report, along with the output of C<perl -V>, | |
4016 | will be sent off to perlbug@perl.org to be analysed by the Perl porting team. | |
4017 | ||
4018 | If the bug you are reporting has security implications, which make it | |
4019 | inappropriate to send to a publicly archived mailing list, then please send it | |
4020 | to perl5-security-report@perl.org. This points to a closed subscription | |
4021 | unarchived mailing list, which includes all the core committers, who will be | |
4022 | able to help assess the impact of issues, figure out a resolution, and help | |
4023 | co-ordinate the release of patches to mitigate or fix the problem across all | |
4024 | platforms on which Perl is supported. Please only use this address for | |
4025 | security issues in the Perl core, not for modules independently distributed on | |
4026 | CPAN. | |
4027 | ||
4028 | =head1 SEE ALSO | |
4029 | ||
4030 | The F<Changes> file for an explanation of how to view exhaustive details on | |
4031 | what changed. | |
4032 | ||
4033 | The F<INSTALL> file for how to build Perl. | |
4034 | ||
4035 | The F<README> file for general stuff. | |
4036 | ||
4037 | The F<Artistic> and F<Copying> files for copyright information. | |
4038 | ||
4039 | =cut |