Commit | Line | Data |
---|---|---|
44691e6f AB |
1 | =encoding utf8 |
2 | ||
3 | =head1 NAME | |
4 | ||
5076a392 | 5 | perldelta - what is new for perl v5.14.0 |
c71a852f | 6 | |
5076a392 FC |
7 | =head1 DESCRIPTION |
8 | ||
9 | This document describes differences between the 5.12.0 release and | |
10 | the 5.14.0 release. | |
11 | ||
0980abf1 FC |
12 | If you are upgrading from an earlier release such as 5.10.0, first read |
13 | L<perl5120delta>, which describes differences between 5.10.0 and | |
14 | 5.12.0. | |
15 | ||
5076a392 FC |
16 | Some of the bug fixes in this release have been backported to subsequent |
17 | releases of 5.12.x. Those are indicated with the 5.12.x version in | |
18 | parentheses. | |
19 | ||
5076a392 FC |
20 | =head1 Notice |
21 | ||
22 | XXX Any important notices here | |
23 | ||
24 | =head1 Core Enhancements | |
25 | ||
1f539a1a | 26 | =head2 Unicode |
5076a392 | 27 | |
1f539a1a | 28 | =head3 Unicode Version 6.0 is now supported (mostly) |
5076a392 | 29 | |
1f539a1a FC |
30 | Perl comes with the Unicode 6.0 data base updated with |
31 | L<Corrigendum #8|http://www.unicode.org/versions/corrigendum8.html>, | |
32 | with one exception noted below. | |
33 | See L<http://unicode.org/versions/Unicode6.0.0> for details on the new | |
34 | release. Perl does not support any Unicode provisional properties, | |
a3c24add | 35 | including the new ones for this release. |
5076a392 | 36 | |
1f539a1a | 37 | Unicode 6.0 has chosen to use the name C<BELL> for the character at U+1F514, |
e1b1739f | 38 | which is a symbol that looks like a bell, and is used in Japanese cell |
1f539a1a FC |
39 | phones. This conflicts with the long-standing Perl usage of having |
40 | C<BELL> mean the ASCII C<BEL> character, U+0007. In Perl 5.14, | |
41 | C<\N{BELL}> will continue to mean U+0007, but its use will generate a | |
42 | deprecated warning message, unless such warnings are turned off. The | |
43 | new name for U+0007 in Perl will be C<ALERT>, which corresponds nicely | |
44 | with the existing shorthand sequence for it, C<"\a">. C<\N{BEL}> will | |
45 | mean U+0007, with no warning given. The character at U+1F514 will not | |
46 | have a name in 5.14, but can be referred to by C<\N{U+1F514}>. The plan | |
47 | is that in Perl 5.16, C<\N{BELL}> will refer to U+1F514, and so all code | |
48 | that uses C<\N{BELL}> should convert by then to using C<\N{ALERT}>, | |
49 | C<\N{BEL}>, or C<"\a"> instead. | |
5076a392 | 50 | |
1f539a1a | 51 | =head3 Full functionality for C<use feature 'unicode_strings'> |
5076a392 | 52 | |
1f539a1a FC |
53 | This release provides full functionality for C<use feature |
54 | 'unicode_strings'>. Under its scope, all string operations executed and | |
55 | regular expressions compiled (even if executed outside its scope) have | |
56 | Unicode semantics. See L<feature>. | |
5076a392 | 57 | |
1f539a1a FC |
58 | This feature avoids most forms of the "Unicode Bug" (See |
59 | L<perlunicode/The "Unicode Bug"> for details.) If there is a | |
60 | possibility that your code will process Unicode strings, you are | |
61 | B<strongly> encouraged to use this subpragma to avoid nasty surprises. | |
5076a392 | 62 | |
1f539a1a | 63 | =head3 C<\N{I<name>}> and C<charnames> enhancements |
5076a392 | 64 | |
1f539a1a | 65 | =over |
5076a392 | 66 | |
1f539a1a | 67 | =item * |
5076a392 FC |
68 | |
69 | C<\N{}> and C<charnames::vianame> now know about the abbreviated | |
e1b1739f FC |
70 | character names listed by Unicode, such as NBSP, SHY, LRO, ZWJ, etc., all |
71 | the customary abbreviations for the C0 and C1 control characters (such as | |
72 | ACK, BEL, CAN, etc.), and a few new variants of some C1 full names that | |
73 | are in common usage. | |
5076a392 | 74 | |
1f539a1a FC |
75 | =item * |
76 | ||
959ad7d5 FC |
77 | Unicode has a number of named character sequences, in which particular sequences |
78 | of code points are given names. C<\N{...}> now recognizes these. | |
79 | ||
1f539a1a FC |
80 | =item * |
81 | ||
959ad7d5 FC |
82 | C<\N{}>, C<charnames::vianame>, C<charnames::viacode> now know about every |
83 | character in Unicode. Previously, they didn't know about the Hangul syllables | |
84 | nor a number of CJK (Chinese/Japanese/Korean) characters. | |
85 | ||
1f539a1a FC |
86 | =item * |
87 | ||
5076a392 FC |
88 | In the past, it was ineffective to override one of Perl's abbreviations |
89 | with your own custom alias. Now it works. | |
90 | ||
1f539a1a FC |
91 | =item * |
92 | ||
e1b1739f | 93 | You can also create a custom alias of the ordinal of a |
5076a392 FC |
94 | character, known by C<\N{...}>, C<charnames::vianame()>, and |
95 | C<charnames::viacode()>. Previously, an alias had to be to an official | |
96 | Unicode character name. This made it impossible to create an alias for | |
e1b1739f FC |
97 | a code point that had no name, such as those reserved for private |
98 | use. | |
5076a392 | 99 | |
1f539a1a FC |
100 | =item * |
101 | ||
959ad7d5 FC |
102 | A new function, C<charnames::string_vianame()>, has been added. |
103 | This function is a run-time version of C<\N{...}>, returning the string | |
104 | of characters whose Unicode name is its parameter. It can handle | |
105 | Unicode named character sequences, whereas the pre-existing | |
106 | C<charnames::vianame()> cannot, as the latter returns a single code | |
107 | point. | |
108 | ||
1f539a1a FC |
109 | =back |
110 | ||
5076a392 FC |
111 | See L<charnames> for details on all these changes. |
112 | ||
22349846 KW |
113 | =head3 New warnings categories for problematic (non-)Unicode code points. |
114 | ||
115 | Three new warnings subcategories of "utf8" have been added. These | |
116 | allow you to turn off some "utf8" warnings, while allowing | |
117 | others warnings to remain on. The three categories are: | |
118 | C<surrogate> when UTF-16 surrogates are encountered; | |
119 | C<nonchar> when Unicode non-character code points are encountered; | |
120 | and C<non_unicode> when code points that are above the legal Unicode | |
121 | maximum of 0x10FFFF are encountered. | |
122 | ||
1f539a1a | 123 | =head3 Any unsigned value can be encoded as a character |
5076a392 | 124 | |
1f539a1a FC |
125 | With this release, Perl is adopting a model that any unsigned value can |
126 | be treated as a code point and encoded internally (as utf8) without | |
54c7bb16 | 127 | warnings - not just the code points that are legal in Unicode. |
22349846 KW |
128 | However, unless utf8 or the corresponding sub-category (see previous |
129 | item) warnings have been | |
1f539a1a FC |
130 | explicitly lexically turned off, outputting or performing a |
131 | Unicode-defined operation (such as upper-casing) on such a code point | |
132 | will generate a warning. Attempting to input these using strict rules | |
133 | (such as with the C<:encoding('UTF-8')> layer) will continue to fail. | |
134 | Prior to this release the handling was very inconsistent, and incorrect | |
135 | in places. Also, the Unicode non-characters, some of which previously were | |
136 | erroneously considered illegal in places by Perl, contrary to the Unicode | |
137 | standard, are now always legal internally. But inputting or outputting | |
138 | them will work the same as for the non-legal Unicode code points, as the | |
139 | Unicode standard says they are illegal for "open interchange". | |
5076a392 | 140 | |
daef9d5b KW |
141 | =head3 Unicode database files not installed |
142 | ||
143 | The Unicode database files are no longer installed with Perl. This | |
144 | doesn't affect any functionality in Perl and saves significant disk | |
145 | space. If you previously were explicitly opening and reading those | |
146 | files, you can download them from | |
147 | L<http://www.unicode.org/Public/zipped/6.0.0/>. | |
148 | ||
1f539a1a | 149 | =head2 Regular Expressions |
5076a392 | 150 | |
1f539a1a | 151 | =head3 C<(?^...)> construct to signify default modifiers |
5076a392 | 152 | |
e1b1739f FC |
153 | An ASCII caret (also called a "circumflex accent") C<"^"> |
154 | immediately following a C<"(?"> in a regular expression | |
155 | now means that the subexpression does not inherit the | |
156 | surrounding modifiers such as C</i>, but reverts to the | |
5076a392 FC |
157 | Perl defaults. Any modifiers following the caret override the defaults. |
158 | ||
159 | The stringification of regular expressions now uses this | |
160 | notation. E.g., before, C<qr/hlagh/i> would be stringified as | |
161 | C<(?i-xsm:hlagh)>, but now it's stringified as C<(?^i:hlagh)>. | |
162 | ||
163 | The main purpose of this is to allow tests that rely on the | |
e1b1739f | 164 | stringification not to have to change when new modifiers are added. |
5076a392 FC |
165 | See L<perlre/Extended Patterns>. |
166 | ||
1f539a1a | 167 | =head3 C</d>, C</l>, C</u>, C</a>, and C</aa> modifiers |
5076a392 | 168 | |
959ad7d5 FC |
169 | Four new regular expression modifiers have been added. These are mutually |
170 | exclusive; one only can be turned on at a time. | |
5076a392 | 171 | |
959ad7d5 | 172 | The C</l> modifier says to compile the regular expression as if it were |
5076a392 FC |
173 | in the scope of C<use locale>, even if it is not. |
174 | ||
959ad7d5 | 175 | The C</u> modifier says to compile the regular expression as if it were |
5076a392 FC |
176 | in the scope of a C<use feature "unicode_strings"> pragma. |
177 | ||
e1b1739f | 178 | The C</d> (default) modifier is used to override any C<use locale> and |
5076a392 FC |
179 | C<use feature "unicode_strings"> pragmas that are in effect at the time |
180 | of compiling the regular expression. | |
181 | ||
959ad7d5 | 182 | The C</a> regular expression modifier restricts C<\s>, C<\d> and C<\w> and |
7baaf023 | 183 | the Posix (C<[[:posix:]]>) character classes to the ASCII range. Their |
959ad7d5 FC |
184 | complements and C<\b> and C<\B> are correspondingly |
185 | affected. Otherwise, C</a> behaves like the C</u> modifier, in that | |
e1b1739f | 186 | case-insensitive matching uses Unicode semantics. |
5076a392 | 187 | |
959ad7d5 FC |
188 | The C</aa> modifier is like C</a>, except that, in case-insensitive matching, no ASCII character will match a |
189 | non-ASCII character. For example, | |
5076a392 | 190 | |
959ad7d5 | 191 | 'k' =~ /\N{KELVIN SIGN}/ai |
5076a392 | 192 | |
959ad7d5 | 193 | will match; it won't under C</aa>. |
5076a392 | 194 | |
959ad7d5 | 195 | See L<perlre/Modifiers> for more detail. |
5076a392 | 196 | |
1f539a1a | 197 | =head3 Non-destructive substitution |
5076a392 | 198 | |
1f539a1a FC |
199 | The substitution (C<s///>) and transliteration |
200 | (C<y///>) operators now support an C</r> option that | |
201 | copies the input variable, carries out the substitution on | |
202 | the copy and returns the result. The original remains unmodified. | |
5076a392 | 203 | |
1f539a1a FC |
204 | my $old = 'cat'; |
205 | my $new = $old =~ s/cat/dog/r; | |
206 | # $old is 'cat' and $new is 'dog' | |
5076a392 | 207 | |
1f539a1a | 208 | This is particularly useful with C<map>. See L<perlop> for more examples. |
5076a392 | 209 | |
1f539a1a | 210 | =head3 Reentrant regular expression engine |
5076a392 | 211 | |
1f539a1a FC |
212 | It is now safe to use regular expressions within C<(?{...})> and |
213 | C<(??{...})> code blocks inside regular expressions. | |
5076a392 | 214 | |
1f539a1a | 215 | These block are still experimental, however, and still have problems with |
e1b1739f | 216 | lexical (C<my>) variables and abnormal exiting. |
5076a392 | 217 | |
1f539a1a | 218 | =head3 C<use re '/flags';> |
5076a392 FC |
219 | |
220 | The C<re> pragma now has the ability to turn on regular expression flags | |
221 | till the end of the lexical scope: | |
222 | ||
223 | use re '/x'; | |
224 | "foo" =~ / (.+) /; # /x implied | |
225 | ||
226 | See L<re/"'/flags' mode"> for details. | |
227 | ||
1f539a1a | 228 | =head3 \o{...} for octals |
5076a392 | 229 | |
e1b1739f FC |
230 | There is a new octal escape sequence, C<"\o">, in double-quote-like |
231 | contexts. This construct allows large octal ordinals beyond the | |
1f539a1a FC |
232 | current max of 0777 to be represented. It also allows you to specify a |
233 | character in octal which can safely be concatenated with other regex | |
234 | snippets and which won't be confused with being a backreference to | |
235 | a regex capture group. See L<perlre/Capture groups>. | |
236 | ||
237 | =head3 Add C<\p{Titlecase}> as a synonym for C<\p{Title}> | |
238 | ||
239 | This synonym is added for symmetry with the Unicode property names | |
240 | C<\p{Uppercase}> and C<\p{Lowercase}>. | |
5076a392 | 241 | |
1f539a1a FC |
242 | =head3 Regular expression debugging output improvement |
243 | ||
244 | Regular expression debugging output (turned on by C<use re 'debug';>) now | |
245 | uses hexadecimal when escaping non-ASCII characters, instead of octal. | |
246 | ||
1e463951 FC |
247 | =head3 Return value of C<delete $+{...}> |
248 | ||
249 | Custom regular expression engines can now determine the return value of | |
250 | C<delete> on an entry of C<%+> or C<%->. | |
251 | ||
1f539a1a FC |
252 | =head2 Syntactical Enhancements |
253 | ||
254 | =head3 Array and hash container functions accept references | |
5076a392 FC |
255 | |
256 | All built-in functions that operate directly on array or hash | |
257 | containers now also accept hard references to arrays or hashes: | |
258 | ||
259 | |----------------------------+---------------------------| | |
260 | | Traditional syntax | Terse syntax | | |
261 | |----------------------------+---------------------------| | |
262 | | push @$arrayref, @stuff | push $arrayref, @stuff | | |
263 | | unshift @$arrayref, @stuff | unshift $arrayref, @stuff | | |
264 | | pop @$arrayref | pop $arrayref | | |
265 | | shift @$arrayref | shift $arrayref | | |
266 | | splice @$arrayref, 0, 2 | splice $arrayref, 0, 2 | | |
267 | | keys %$hashref | keys $hashref | | |
268 | | keys @$arrayref | keys $arrayref | | |
269 | | values %$hashref | values $hashref | | |
270 | | values @$arrayref | values $arrayref | | |
271 | | ($k,$v) = each %$hashref | ($k,$v) = each $hashref | | |
272 | | ($k,$v) = each @$arrayref | ($k,$v) = each $arrayref | | |
273 | |----------------------------+---------------------------| | |
274 | ||
275 | This allows these built-in functions to act on long dereferencing chains | |
276 | or on the return value of subroutines without needing to wrap them in | |
277 | C<@{}> or C<%{}>: | |
278 | ||
279 | push @{$obj->tags}, $new_tag; # old way | |
280 | push $obj->tags, $new_tag; # new way | |
281 | ||
282 | for ( keys %{$hoh->{genres}{artists}} ) {...} # old way | |
283 | for ( keys $hoh->{genres}{artists} ) {...} # new way | |
284 | ||
285 | For C<push>, C<unshift> and C<splice>, the reference will auto-vivify | |
286 | if it is not defined, just as if it were wrapped with C<@{}>. | |
287 | ||
5076a392 FC |
288 | For C<keys>, C<values>, C<each>, when overloaded dereferencing is |
289 | present, the overloaded dereference is used instead of dereferencing the | |
e1b1739f FC |
290 | underlying reftype. Warnings are issued about assumptions made in |
291 | ambiguous cases. | |
5076a392 | 292 | |
1f539a1a FC |
293 | =head3 Single term prototype |
294 | ||
295 | The C<+> prototype is a special alternative to C<$> that will act like | |
296 | C<\[@%]> when given a literal array or hash variable, but will otherwise | |
e1b1739f | 297 | force scalar context on the argument. See L<perlsub/Prototypes>. |
1f539a1a FC |
298 | |
299 | =head3 C<package> block syntax | |
300 | ||
301 | A package declaration can now contain a code block, in which case the | |
302 | declaration is in scope only inside that block. So C<package Foo { ... }> | |
303 | is precisely equivalent to C<{ package Foo; ... }>. It also works with | |
304 | a version number in the declaration, as in C<package Foo 1.2 { ... }>. | |
e1b1739f | 305 | See L<perlfunc>. |
1f539a1a FC |
306 | |
307 | =head3 Statement labels can appear in more places | |
308 | ||
309 | Statement labels can now occur before any type of statement or declaration, | |
310 | such as C<package>. | |
311 | ||
312 | =head3 Stacked labels | |
313 | ||
314 | Multiple statement labels can now appear before a single statement. | |
315 | ||
316 | =head3 Uppercase X/B allowed in hexadecimal/binary literals | |
317 | ||
318 | Literals may now use either upper case C<0X...> or C<0B...> prefixes, | |
319 | in addition to the already supported C<0x...> and C<0b...> | |
e1b1739f | 320 | syntax [perl #76296]. |
1f539a1a FC |
321 | |
322 | C, Ruby, Python and PHP already supported this syntax, and it makes | |
323 | Perl more internally consistent. A round-trip with C<eval sprintf | |
e1b1739f | 324 | "%#X", 0x10> now returns C<16>, the way C<eval sprintf "%#x", 0x10> does. |
1f539a1a | 325 | |
1e463951 FC |
326 | =head3 Overridable tie functions |
327 | ||
328 | C<tie>, C<tied> and C<untie> can now be overridden [perl #75902]. | |
329 | ||
1f539a1a FC |
330 | =head2 Exception Handling |
331 | ||
332 | Several changes have been made to the way C<die>, C<warn>, and C<$@> | |
333 | behave, in order to make them more reliable and consistent. | |
334 | ||
335 | When an exception is thrown inside an C<eval>, the exception is no | |
336 | longer at risk of being clobbered by code running during unwinding | |
337 | (e.g., destructors). Previously, the exception was written into C<$@> | |
338 | early in the throwing process, and would be overwritten if C<eval> was | |
339 | used internally in the destructor for an object that had to be freed | |
340 | while exiting from the outer C<eval>. Now the exception is written | |
341 | into C<$@> last thing before exiting the outer C<eval>, so the code | |
342 | running immediately thereafter can rely on the value in C<$@> correctly | |
343 | corresponding to that C<eval>. (C<$@> is still also set before exiting the | |
344 | C<eval>, for the sake of destructors that rely on this.) | |
345 | ||
346 | Likewise, a C<local $@> inside an C<eval> will no longer clobber any | |
347 | exception thrown in its scope. Previously, the restoration of C<$@> upon | |
348 | unwinding would overwrite any exception being thrown. Now the exception | |
349 | gets to the C<eval> anyway. So C<local $@> is safe before a C<die>. | |
350 | ||
351 | Exceptions thrown from object destructors no longer modify the C<$@> | |
352 | of the surrounding context. (If the surrounding context was exception | |
353 | unwinding, this used to be another way to clobber the exception being | |
354 | thrown.) Previously such an exception was | |
355 | sometimes emitted as a warning, and then either was | |
356 | string-appended to the surrounding C<$@> or completely replaced the | |
357 | surrounding C<$@>, depending on whether that exception and the surrounding | |
358 | C<$@> were strings or objects. Now, an exception in this situation is | |
359 | always emitted as a warning, leaving the surrounding C<$@> untouched. | |
360 | In addition to object destructors, this also affects any function call | |
361 | performed by XS code using the C<G_KEEPERR> flag. | |
362 | ||
363 | Warnings for C<warn> can now be objects, in the same way as exceptions | |
364 | for C<die>. If an object-based warning gets the default handling, | |
365 | of writing to standard error, it is stringified as | |
366 | before, with the file and line number appended. But | |
367 | a C<$SIG{__WARN__}> handler will now receive an | |
368 | object-based warning as an object, where previously it was passed the | |
369 | result of stringifying the object. | |
370 | ||
371 | =head2 Other Enhancements | |
372 | ||
373 | =head3 Assignment to C<$0> sets the legacy process name with C<prctl()> on Linux | |
374 | ||
375 | On Linux the legacy process name will be set with L<prctl(2)>, in | |
376 | addition to altering the POSIX name via C<argv[0]> as perl has done | |
377 | since version 4.000. Now system utilities that read the legacy process | |
378 | name such as ps, top and killall will recognize the name you set when | |
379 | assigning to C<$0>. The string you supply will be cut off at 16 bytes, | |
380 | this is a limitation imposed by Linux. | |
381 | ||
382 | =head3 C<srand()> now returns the seed | |
383 | ||
e1b1739f FC |
384 | This allows programs that need to have repeatable results not to have to come |
385 | up with their own seed-generating mechanism. Instead, they can use C<srand()> | |
386 | and stash the return value for future use. Typical is a test program which | |
1f539a1a | 387 | has too many combinations to test comprehensively in the time available to it |
e1b1739f | 388 | each run. It can test a random subset each time and, should there be a failure, |
1f539a1a | 389 | log the seed used for that run so that it can later be used to reproduce the |
e1b1739f | 390 | same results. |
1f539a1a FC |
391 | |
392 | =head3 printf-like functions understand post-1980 size modifiers | |
393 | ||
394 | Perl's printf and sprintf operators, and Perl's internal printf replacement | |
395 | function, now understand the C90 size modifiers "hh" (C<char>), "z" | |
396 | (C<size_t>), and "t" (C<ptrdiff_t>). Also, when compiled with a C99 | |
397 | compiler, Perl now understands the size modifier "j" (C<intmax_t>). | |
398 | ||
399 | So, for example, on any modern machine, C<sprintf('%hhd', 257)> returns '1'. | |
400 | ||
401 | =head3 New global variable C<${^GLOBAL_PHASE}> | |
5076a392 FC |
402 | |
403 | A new global variable, C<${^GLOBAL_PHASE}>, has been added to allow | |
404 | introspection of the current phase of the perl interpreter. It's explained in | |
405 | detail in L<perlvar/"${^GLOBAL_PHASE}"> and | |
406 | L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT and END">. | |
407 | ||
1f539a1a | 408 | =head3 C<-d:-foo> calls C<Devel::foo::unimport> |
5076a392 FC |
409 | |
410 | The syntax C<-dI<B<:>foo>> was extended in 5.6.1 to make C<-dI<:fooB<=bar>>> | |
411 | equivalent to C<-MDevel::foo=bar>, which expands | |
412 | internally to C<use Devel::foo 'bar';>. | |
413 | F<perl> now allows prefixing the module name with C<->, with the same | |
414 | semantics as C<-M>, I<i.e.> | |
415 | ||
416 | =over 4 | |
417 | ||
418 | =item C<-d:-foo> | |
419 | ||
420 | Equivalent to C<-M-Devel::foo>, expands to | |
421 | C<no Devel::foo;>, calls C<< Devel::foo->unimport() >> | |
422 | if the method exists. | |
423 | ||
424 | =item C<-d:-foo=bar> | |
425 | ||
426 | Equivalent to C<-M-Devel::foo=bar>, expands to C<no Devel::foo 'bar';>, | |
427 | calls C<< Devel::foo->unimport('bar') >> if the method exists. | |
428 | ||
429 | =back | |
430 | ||
e1b1739f | 431 | This is particularly useful for suppressing the default actions of a |
5076a392 FC |
432 | C<Devel::*> module's C<import> method whilst still loading it for debugging. |
433 | ||
1f539a1a | 434 | =head3 Filehandle method calls load L<IO::File> on demand |
5076a392 FC |
435 | |
436 | When a method call on a filehandle would die because the method cannot | |
437 | be resolved, and L<IO::File> has not been loaded, Perl now loads L<IO::File> | |
438 | via C<require> and attempts method resolution again: | |
439 | ||
440 | open my $fh, ">", $file; | |
441 | $fh->binmode(":raw"); # loads IO::File and succeeds | |
442 | ||
443 | This also works for globs like STDOUT, STDERR and STDIN: | |
444 | ||
445 | STDOUT->autoflush(1); | |
446 | ||
447 | Because this on-demand load only happens if method resolution fails, the | |
448 | legacy approach of manually loading an L<IO::File> parent class for partial | |
449 | method support still works as expected: | |
450 | ||
451 | use IO::Handle; | |
452 | open my $fh, ">", $file; | |
453 | $fh->autoflush(1); # IO::File not loaded | |
454 | ||
1984204c FC |
455 | =head3 IPv6 support |
456 | ||
457 | The C<Socket> module provides new affordances for IPv6, | |
458 | including implementations of the C<Socket::getaddrinfo()> and | |
459 | C<Socket::getnameinfo()> functions, along with related constants, and a | |
460 | handful of new functions. See L<Socket>. | |
461 | ||
1f539a1a | 462 | =head3 DTrace probes now include package name |
5076a392 FC |
463 | |
464 | The DTrace probes now include an additional argument (C<arg3>) which contains | |
465 | the package the subroutine being entered or left was compiled in. | |
466 | ||
467 | For example using the following DTrace script: | |
468 | ||
469 | perl$target:::sub-entry | |
470 | { | |
471 | printf("%s::%s\n", copyinstr(arg0), copyinstr(arg3)); | |
472 | } | |
473 | ||
474 | and then running: | |
475 | ||
476 | perl -e'sub test { }; test' | |
477 | ||
478 | DTrace will print: | |
479 | ||
480 | main::test | |
481 | ||
9378886b FC |
482 | =head2 New C APIs |
483 | ||
1e463951 | 484 | See L</Internal Changes>. |
9378886b | 485 | |
5076a392 FC |
486 | =head1 Security |
487 | ||
948b8455 | 488 | =head2 User-defined regular expression properties |
5076a392 FC |
489 | |
490 | In L<perlunicode/"User-Defined Character Properties">, it says you can | |
491 | create custom properties by defining subroutines whose names begin with | |
948b8455 FC |
492 | "In" or "Is". However, Perl did not actually enforce that naming |
493 | restriction, so \p{foo::bar} could call foo::bar() if it existed. Now this | |
494 | convention has been enforced. | |
5076a392 | 495 | |
948b8455 FC |
496 | Also, Perl no longer allows a tainted regular expression to invoke a |
497 | user-defined. It simply dies instead [perl #82616]. | |
5076a392 FC |
498 | |
499 | =head1 Incompatible Changes | |
500 | ||
61752d82 FC |
501 | Perl 5.14.0 is not binary-compatible with any previous stable release. |
502 | ||
1e463951 FC |
503 | In addition to the sections that follow, see L</C API Changes>. |
504 | ||
61752d82 FC |
505 | =head2 Regular Expressions and String Escapes |
506 | ||
54c7bb16 | 507 | =head3 \400-\777 |
5076a392 | 508 | |
54c7bb16 | 509 | Use of C<\400>-C<\777> in regexes in certain circumstances has given |
5076a392 FC |
510 | different, anomalous behavior than their use in all other |
511 | double-quote-like contexts. Since 5.10.1, a deprecated warning message | |
512 | has been raised when this happens. Now, all double-quote-like contexts | |
513 | have the same behavior, namely to be equivalent to C<\x{100}> - | |
514 | C<\x{1FF}>, with no deprecation warning. Use of these values in the | |
515 | command line option C<"-0"> retains the current meaning to slurp input | |
516 | files whole; previously, this was documented only for C<"-0777">. It is | |
517 | recommended, however, because of various ambiguities, to use the new | |
518 | C<\o{...}> construct to represent characters in octal. | |
5076a392 | 519 | |
61752d82 | 520 | =head3 Most C<\p{}> properties are now immune to case-insensitive matching |
5076a392 | 521 | |
61752d82 FC |
522 | For most Unicode properties, it doesn't make sense to have them match |
523 | differently under C</i> case-insensitive matching than not. And doing | |
524 | so leads to unexpected results and potential security holes. For | |
525 | example | |
5076a392 | 526 | |
61752d82 | 527 | m/\p{ASCII_Hex_Digit}+/i |
5076a392 | 528 | |
61752d82 | 529 | could previously match non-ASCII characters because of the Unicode |
4cf6a51f KW |
530 | matching rules (although there were a number of bugs with this). Now |
531 | matching under C</i> gives the same results as non-C</i> matching except | |
532 | for those few properties where people have come to expect differences, | |
533 | namely the ones where casing is an integral part of their meaning, such | |
534 | as C<m/\p{Uppercase}/i> and C<m/\p{Lowercase}/i>, both of which match | |
535 | the exact same code points, namely those matched by C<m/\p{Cased}/i>. | |
536 | Details are in L<perlrecharclass/Unicode Properties>. | |
5076a392 | 537 | |
61752d82 | 538 | User-defined property handlers that need to match differently under |
4cf6a51f | 539 | C</i> must change to read the new boolean parameter passed to them which is |
61752d82 FC |
540 | non-zero if case-insensitive matching is in effect or 0 otherwise. See |
541 | L<perluniprops/User-Defined Character Properties>. | |
5076a392 | 542 | |
61752d82 | 543 | =head3 \p{} implies Unicode semantics |
5076a392 | 544 | |
61752d82 FC |
545 | Now, a Unicode property match specified in the pattern will indicate |
546 | that the pattern is meant for matching according to Unicode rules, the way | |
bc15a0a0 | 547 | C<\N{}> does. |
5076a392 | 548 | |
61752d82 | 549 | =head3 Regular expressions retain their localeness when interpolated |
5076a392 | 550 | |
61752d82 FC |
551 | Regular expressions compiled under C<"use locale"> now retain this when |
552 | interpolated into a new regular expression compiled outside a | |
553 | C<"use locale">, and vice-versa. | |
5076a392 | 554 | |
61752d82 FC |
555 | Previously, a regular expression interpolated into another one inherited |
556 | the localeness of the surrounding one, losing whatever state it | |
557 | originally had. This is considered a bug fix, but may trip up code that | |
558 | has come to rely on the incorrect behavior. | |
5076a392 | 559 | |
61752d82 | 560 | =head3 Stringification of regexes has changed |
5076a392 FC |
561 | |
562 | Default regular expression modifiers are now notated by using | |
563 | C<(?^...)>. Code relying on the old stringification will fail. The | |
564 | purpose of this is so that when new modifiers are added, such code will | |
565 | not have to change (after this one time), as the stringification will | |
566 | automatically incorporate the new modifiers. | |
567 | ||
568 | Code that needs to work properly with both old- and new-style regexes | |
f318e2e6 | 569 | can avoid the whole issue by using (for Perls since 5.9.5; see L<re>): |
5076a392 FC |
570 | |
571 | use re qw(regexp_pattern); | |
572 | my ($pat, $mods) = regexp_pattern($re_ref); | |
573 | ||
5076a392 FC |
574 | If the actual stringification is important, or older Perls need to be |
575 | supported, you can use something like the following: | |
576 | ||
577 | # Accept both old and new-style stringification | |
578 | my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? '^' : '-xism'; | |
579 | ||
580 | And then use C<$modifiers> instead of C<-xism>. | |
581 | ||
61752d82 | 582 | =head3 Run-time code blocks in regular expressions inherit pragmata |
5076a392 | 583 | |
61752d82 FC |
584 | Code blocks in regular expressions (C<(?{...})> and C<(??{...})>) used not |
585 | to inherit any pragmata (strict, warnings, etc.) if the regular expression | |
586 | was compiled at run time as happens in cases like these two: | |
5076a392 | 587 | |
61752d82 FC |
588 | use re 'eval'; |
589 | $foo =~ $bar; # when $bar contains (?{...}) | |
590 | $foo =~ /$bar(?{ $finished = 1 })/; | |
591 | ||
592 | This was a bug, which has now been fixed. But it has the potential to break | |
593 | any code that was relying on it. | |
5076a392 | 594 | |
61752d82 | 595 | =head2 Stashes and Package Variables |
5076a392 | 596 | |
61752d82 | 597 | =head3 Localised tied hashes and arrays are no longed tied |
5076a392 | 598 | |
61752d82 | 599 | In the following: |
5076a392 | 600 | |
61752d82 FC |
601 | tie @a, ...; |
602 | { | |
603 | local @a; | |
604 | # here, @a is a now a new, untied array | |
605 | } | |
606 | # here, @a refers again to the old, tied array | |
5076a392 | 607 | |
61752d82 FC |
608 | The new local array used to be made tied too, which was fairly pointless, |
609 | and has now been fixed. This fix could however potentially cause a change | |
610 | in behaviour of some code. | |
5076a392 | 611 | |
61752d82 | 612 | =head3 Stashes are now always defined |
5076a392 | 613 | |
61752d82 FC |
614 | C<defined %Foo::> now always returns true, even when no symbols have yet been |
615 | defined in that package. | |
5076a392 | 616 | |
61752d82 FC |
617 | This is a side effect of removing a special case kludge in the tokeniser, |
618 | added for 5.10.0, to hide side effects of changes to the internal storage of | |
619 | hashes that drastically reduce their memory usage overhead. | |
620 | ||
621 | Calling defined on a stash has been deprecated since 5.6.0, warned on | |
622 | lexicals since 5.6.0, and warned for stashes (and other package | |
623 | variables) since 5.12.0. C<defined %hash> has always exposed an | |
624 | implementation detail - emptying a hash by deleting all entries from it does | |
625 | not make C<defined %hash> false, hence C<defined %hash> is not valid code to | |
626 | determine whether an arbitrary hash is empty. Instead, use the behaviour | |
627 | that an empty C<%hash> always returns false in a scalar context. | |
628 | ||
629 | =head3 Dereferencing typeglobs | |
5076a392 FC |
630 | |
631 | If you assign a typeglob to a scalar variable: | |
632 | ||
633 | $glob = *foo; | |
634 | ||
635 | the glob that is copied to C<$glob> is marked with a special flag | |
636 | indicating that the glob is just a copy. This allows subsequent assignments | |
637 | to C<$glob> to overwrite the glob. The original glob, however, is | |
638 | immutable. | |
639 | ||
640 | Many Perl operators did not distinguish between these two types of globs. | |
641 | This would result in strange behaviour in edge cases: C<untie $scalar> | |
642 | would do nothing if the last thing assigned to the scalar was a glob | |
643 | (because it treated it as C<untie *$scalar>, which unties a handle). | |
f318e2e6 | 644 | Assignment to a glob slot (e.g., C<*$glob = \@some_array>) would simply |
5076a392 FC |
645 | assign C<\@some_array> to C<$glob>. |
646 | ||
647 | To fix this, the C<*{}> operator (including the C<*foo> and C<*$foo> forms) | |
648 | has been modified to make a new immutable glob if its operand is a glob | |
e262cb24 FC |
649 | copy. This allows operators that make a distinction between globs and |
650 | scalars to be modified to treat only immutable globs as globs. (C<tie>, | |
651 | C<tied> and C<untie> have been left as they are for compatibility's sake, | |
61752d82 | 652 | but will warn. See L</Deprecations>.) |
5076a392 FC |
653 | |
654 | This causes an incompatible change in code that assigns a glob to the | |
655 | return value of C<*{}> when that operator was passed a glob copy. Take the | |
656 | following code, for instance: | |
657 | ||
658 | $glob = *foo; | |
659 | *$glob = *bar; | |
660 | ||
661 | The C<*$glob> on the second line returns a new immutable glob. That new | |
662 | glob is made an alias to C<*bar>. Then it is discarded. So the second | |
663 | assignment has no effect. | |
664 | ||
5076a392 FC |
665 | See L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for even |
666 | more detail. | |
667 | ||
61752d82 | 668 | =head3 Clearing stashes |
5076a392 FC |
669 | |
670 | Stash list assignment C<%foo:: = ()> used to make the stash anonymous | |
671 | temporarily while it was being emptied. Consequently, any of its | |
672 | subroutines referenced elsewhere would become anonymous (showing up as | |
673 | "(unknown)" in C<caller>). Now they retain their package names, such that | |
674 | C<caller> will return the original sub name if there is still a reference | |
675 | to its typeglob, or "foo::__ANON__" otherwise [perl #79208]. | |
676 | ||
61752d82 FC |
677 | =head3 Magic variables outside the main package |
678 | ||
679 | In previous versions of Perl, magic variables like C<$!>, C<%SIG>, etc. would | |
680 | 'leak' into other packages. So C<%foo::SIG> could be used to access signals, | |
681 | C<${"foo::!"}> (with strict mode off) to access C's C<errno>, etc. | |
682 | ||
683 | This was a bug, or an 'unintentional' feature, which caused various ill effects, | |
684 | such as signal handlers being wiped when modules were loaded, etc. | |
685 | ||
686 | This has been fixed (or the feature has been removed, depending on how you see | |
687 | it). | |
688 | ||
689 | =head2 Changes to Syntax or to Perl Operators | |
690 | ||
691 | =head3 C<given> return values | |
692 | ||
693 | C<given> blocks now return the last evaluated | |
694 | expression, or an empty list if the block was exited by C<break>. Thus you | |
695 | can now write: | |
696 | ||
697 | my $type = do { | |
698 | given ($num) { | |
699 | break when undef; | |
700 | 'integer' when /^[+-]?[0-9]+$/; | |
701 | 'float' when /^[+-]?[0-9]+(?:\.[0-9]+)?$/; | |
702 | 'unknown'; | |
703 | } | |
704 | }; | |
705 | ||
706 | See L<perlsyn/Return value> for details. | |
707 | ||
708 | =head3 Change in the parsing of certain prototypes | |
709 | ||
710 | Functions declared with the following prototypes now behave correctly as unary | |
711 | functions: | |
712 | ||
713 | * | |
714 | \$ \% \@ \* \& | |
715 | \[...] | |
716 | ;$ ;* | |
717 | ;\$ ;\% etc. | |
718 | ;\[...] | |
719 | ||
720 | Due to this bug fix [perl #75904], functions | |
721 | using the C<(*)>, C<(;$)> and C<(;*)> prototypes | |
722 | are parsed with higher precedence than before. So in the following example: | |
723 | ||
724 | sub foo($); | |
725 | foo $a < $b; | |
726 | ||
727 | the second line is now parsed correctly as C<< foo($a) < $b >>, rather than | |
728 | C<< foo($a < $b) >>. This happens when one of these operators is used in | |
729 | an unparenthesised argument: | |
730 | ||
731 | < > <= >= lt gt le ge | |
732 | == != <=> eq ne cmp ~~ | |
733 | & | |
734 | | ^ | |
735 | && | |
736 | || // | |
737 | .. ... | |
738 | ?: | |
739 | = += -= *= etc. | |
740 | ||
741 | =head3 Smart-matching against array slices | |
742 | ||
743 | Previously, the following code resulted in a successful match: | |
744 | ||
745 | my @a = qw(a y0 z); | |
746 | my @b = qw(a x0 z); | |
747 | @a[0 .. $#b] ~~ @b; | |
748 | ||
749 | This odd behaviour has now been fixed [perl #77468]. | |
750 | ||
751 | =head3 Negation treats strings differently from before | |
752 | ||
753 | The unary negation operator C<-> now treats strings that look like numbers | |
754 | as numbers [perl #57706]. | |
755 | ||
756 | =head3 Negative zero | |
757 | ||
758 | Negative zero (-0.0), when converted to a string, now becomes "0" on all | |
759 | platforms. It used to become "-0" on some, but "0" on others. | |
760 | ||
761 | If you still need to determine whether a zero is negative, use | |
762 | C<sprintf("%g", $zero) =~ /^-/> or the L<Data::Float> module on CPAN. | |
763 | ||
764 | =head3 C<:=> is now a syntax error | |
5076a392 FC |
765 | |
766 | Previously C<my $pi := 4;> was exactly equivalent to C<my $pi : = 4;>, | |
767 | with the C<:> being treated as the start of an attribute list, ending before | |
768 | the C<=>. The use of C<:=> to mean C<: => was deprecated in 5.12.0, and is now | |
769 | a syntax error. This will allow the future use of C<:=> as a new token. | |
770 | ||
771 | We find no Perl 5 code on CPAN using this construction, outside the core's | |
772 | tests for it, so we believe that this change will have very little impact on | |
773 | real-world codebases. | |
774 | ||
775 | If it is absolutely necessary to have empty attribute lists (for example, | |
776 | because of a code generator) then avoid the error by adding a space before | |
777 | the C<=>. | |
778 | ||
61752d82 | 779 | =head2 Threads and Processes |
5076a392 | 780 | |
61752d82 | 781 | =head3 Directory handles not copied to threads |
5076a392 | 782 | |
61752d82 FC |
783 | On systems other than Windows that do not have |
784 | a C<fchdir> function, newly-created threads no | |
785 | longer inherit directory handles from their parent threads. Such programs | |
786 | would usually have crashed anyway [perl #75154]. | |
5076a392 | 787 | |
61752d82 | 788 | =head3 C<close> on shared pipes |
5076a392 | 789 | |
61752d82 FC |
790 | The C<close> function no longer waits for the child process to exit if the |
791 | underlying file descriptor is still in use by another thread, to avoid | |
792 | deadlocks. It returns true in such cases. | |
5076a392 | 793 | |
144b6ea2 FC |
794 | =head3 fork() emulation will not wait for signalled children |
795 | ||
796 | On Windows parent processes would not terminate until all forked | |
797 | childred had terminated first. However, C<kill('KILL', ...)> is | |
798 | inherently unstable on pseudo-processes, and C<kill('TERM', ...)> | |
799 | might not get delivered if the child if blocked in a system call. | |
800 | ||
801 | To avoid the deadlock and still provide a safe mechanism to terminate | |
802 | the hosting process, Perl will now no longer wait for children that | |
803 | have been sent a SIGTERM signal. It is up to the parent process to | |
804 | waitpid() for these children if child clean-up processing must be | |
805 | allowed to finish. However, it is also the responsibility of the | |
806 | parent then to avoid the deadlock by making sure the child process | |
807 | can't be blocked on I/O either. | |
808 | ||
809 | See L<perlfork> for more information about the fork() emulation on | |
810 | Windows. | |
811 | ||
61752d82 | 812 | =head2 Configuration |
5076a392 | 813 | |
61752d82 | 814 | =head3 Naming fixes in Policy_sh.SH may invalidate Policy.sh |
5076a392 | 815 | |
61752d82 FC |
816 | Several long-standing typos and naming confusions in Policy_sh.SH have |
817 | been fixed, standardizing on the variable names used in config.sh. | |
5076a392 | 818 | |
61752d82 FC |
819 | This will change the behavior of Policy.sh if you happen to have been |
820 | accidentally relying on the Policy.sh incorrect behavior. | |
f318e2e6 | 821 | |
5a1f7719 FC |
822 | =head3 Perl source code is read in text mode on Windows |
823 | ||
824 | Perl scripts used to be read in binary mode on Windows for the benefit | |
825 | of the ByteLoader module (which is no longer part of core Perl). This | |
826 | had the side effect of breaking various operations on the DATA filehandle, | |
827 | including seek()/tell(), and even simply reading from DATA after file handles | |
828 | have been flushed by a call to system(), backticks, fork() etc. | |
829 | ||
830 | The default build options for Windows have been changed to read Perl source | |
831 | code on Windows in text mode now. Hopefully ByteLoader will be updated on | |
832 | CPAN to automatically handle this situation [perl #28106]. | |
833 | ||
5076a392 FC |
834 | =head1 Deprecations |
835 | ||
1e463951 FC |
836 | See also L</Deprecated C APIs>. |
837 | ||
5076a392 FC |
838 | =head2 Omitting a space between a regular expression and subsequent word |
839 | ||
18139a1b FC |
840 | Omitting a space between a regular expression operator or |
841 | its modifiers and the following word is deprecated. For | |
842 | example, C<< m/foo/sand $bar >> will still be parsed | |
843 | as C<< m/foo/s and $bar >> but will issue a warning. | |
5076a392 | 844 | |
e683df94 KW |
845 | =head2 C<\cI<X>> |
846 | ||
847 | The backslash-c construct was designed as a way of specifying | |
848 | non-printable characters, but there were no restrictions (on ASCII | |
849 | platforms) on what the character following the C<c> could be. Now, | |
850 | a deprecation warning is raised if that character isn't an ASCII character. | |
851 | Also, a deprecation warning is raised for C<"\c{"> (which is the same | |
852 | as simply saying C<";">). | |
853 | ||
4528361d KW |
854 | =head2 C<"\b{"> and C<"\B{"> |
855 | ||
856 | In regular expressions, a literal C<"{"> immediately following a C<"\b"> | |
857 | (not in a bracketed character class) or a C<"\B{"> is now deprecated | |
858 | to allow for its future use by Perl itself. | |
859 | ||
5076a392 FC |
860 | =head2 Deprecation warning added for deprecated-in-core .pl libs |
861 | ||
862 | This is a mandatory warning, not obeying -X or lexical warning bits. | |
863 | The warning is modelled on that supplied by deprecate.pm for | |
864 | deprecated-in-core .pm libraries. It points to the specific CPAN | |
823d0e46 FC |
865 | distribution that contains the .pl libraries. The CPAN version, of |
866 | course, does not generate the warning. | |
5076a392 FC |
867 | |
868 | =head2 List assignment to C<$[> | |
869 | ||
823d0e46 FC |
870 | Assignment to C<$[> was deprecated and started to give warnings in |
871 | Perl version 5.12.0. This version of perl also starts to emit a warning when | |
872 | assigning to C<$[> in list context. This fixes an oversight in 5.12.0. | |
5076a392 FC |
873 | |
874 | =head2 Use of qw(...) as parentheses | |
875 | ||
876 | Historically the parser fooled itself into thinking that C<qw(...)> literals | |
877 | were always enclosed in parentheses, and as a result you could sometimes omit | |
878 | parentheses around them: | |
879 | ||
880 | for $x qw(a b c) { ... } | |
881 | ||
882 | The parser no longer lies to itself in this way. Wrap the list literal in | |
823d0e46 | 883 | parentheses, like this: |
5076a392 FC |
884 | |
885 | for $x (qw(a b c)) { ... } | |
886 | ||
887 | =head2 C<\N{BELL}> is deprecated | |
888 | ||
889 | This is because Unicode is using that name for a different character. | |
890 | See L</Unicode Version 6.0 is now supported (mostly)> for more | |
891 | explanation. | |
892 | ||
893 | =head2 C<?PATTERN?> is deprecated | |
894 | ||
895 | C<?PATTERN?> (without the initial m) has been deprecated and now produces | |
896 | a warning. This is to allow future use of C<?> in new operators. | |
897 | The match-once functionality is still available in the form of C<m?PATTERN?>. | |
898 | ||
5076a392 FC |
899 | =head2 Tie functions on scalars holding typeglobs |
900 | ||
901 | Calling a tie function (C<tie>, C<tied>, C<untie>) with a scalar argument | |
902 | acts on a file handle if the scalar happens to hold a typeglob. | |
903 | ||
904 | This is a long-standing bug that will be removed in Perl 5.16, as | |
905 | there is currently no way to tie the scalar itself when it holds | |
906 | a typeglob, and no way to untie a scalar that has had a typeglob | |
907 | assigned to it. | |
908 | ||
823d0e46 | 909 | Now there is a deprecation warning whenever a tie |
5076a392 FC |
910 | function is used on a handle without an explicit C<*>. |
911 | ||
18139a1b | 912 | =head2 User-defined case-mapping |
5076a392 | 913 | |
18139a1b FC |
914 | This feature is being deprecated due to its many issues, as documented in |
915 | L<perlunicode/User-Defined Case Mappings (for serious hackers only)>. | |
e48f36f0 KW |
916 | It is planned to remove this feature in Perl 5.16. Instead use the CPAN module |
917 | L<Unicode::Casing>, which provides improved functionality. | |
823d0e46 | 918 | |
18139a1b | 919 | =head2 Deprecated modules |
5076a392 FC |
920 | |
921 | The following modules will be removed from the core distribution in a | |
922 | future release, and should be installed from CPAN instead. Distributions | |
923 | on CPAN which require these should add them to their prerequisites. The | |
823d0e46 | 924 | core versions of these modules will issue a deprecation warning. |
5076a392 FC |
925 | |
926 | If you ship a packaged version of Perl, either alone or as part of a | |
927 | larger system, then you should carefully consider the repercussions of | |
823d0e46 | 928 | core module deprecations. You may want to consider shipping your default |
5076a392 | 929 | build of Perl with packages for some or all deprecated modules which |
823d0e46 | 930 | install into C<vendor> or C<site> perl library directories. This will |
5076a392 FC |
931 | inhibit the deprecation warnings. |
932 | ||
933 | Alternatively, you may want to consider patching F<lib/deprecate.pm> | |
934 | to provide deprecation warnings specific to your packaging system | |
935 | or distribution of Perl, consistent with how your packaging system | |
936 | or distribution manages a staged transition from a release where the | |
937 | installation of a single package provides the given functionality, to | |
938 | a later release where the system administrator needs to know to install | |
939 | multiple packages to get that same functionality. | |
940 | ||
941 | You can silence these deprecation warnings by installing the modules | |
942 | in question from CPAN. To install the latest version of all of them, | |
943 | just install C<Task::Deprecations::5_14>. | |
944 | ||
945 | =over | |
946 | ||
947 | =item L<Devel::DProf> | |
948 | ||
949 | We strongly recommend that you install and used L<Devel::NYTProf> in | |
950 | preference, as it offers significantly improved profiling and reporting. | |
951 | ||
952 | =back | |
953 | ||
5076a392 FC |
954 | =head1 Performance Enhancements |
955 | ||
54c7bb16 | 956 | =head2 "Safe signals" optimisation |
df91d470 FC |
957 | |
958 | Signal dispatch has been moved from the runloop into control ops. This | |
959 | should give a few percent speed increase, and eliminates almost all of | |
960 | the speed penalty caused by the introduction of "safe signals" in | |
961 | 5.8.0. Signals should still be dispatched within the same statement as | |
962 | they were previously - if this is not the case, or it is possible to | |
963 | create uninterruptible loops, this is a bug, and reports are encouraged | |
964 | of how to recreate such issues. | |
965 | ||
54c7bb16 | 966 | =head2 Optimisation of shift; and pop; calls without arguments |
df91d470 | 967 | |
111b6aa7 FC |
968 | Two fewer OPs are used for shift and pop calls with no argument (with |
969 | implicit C<@_>). This change makes C<shift;> 5% faster than C<shift @_;> | |
970 | on non-threaded perls and 25% faster on threaded. | |
df91d470 | 971 | |
fa232254 | 972 | =head2 Optimisation of regexp engine string comparison work |
df91d470 | 973 | |
fa232254 FC |
974 | The foldEQ_utf8 API function for case-insensitive comparison of strings (which |
975 | is used heavily by the regexp engine) was substantially refactored and | |
976 | optimised - and its documentation much improved as a free bonus gift. | |
df91d470 | 977 | |
fa232254 | 978 | =head2 Regular expression compilation speed-up |
df91d470 | 979 | |
fa232254 FC |
980 | Compiling regular expressions has been made faster for the case where upgrading |
981 | the regex to utf8 is necessary but that isn't known when the compilation begins. | |
df91d470 | 982 | |
fa232254 | 983 | =head2 String appending is 100 times faster |
df91d470 | 984 | |
fa232254 FC |
985 | When doing a lot of string appending, perl could end up allocating a lot more |
986 | memory than needed in a very inefficient way, if perl was configured to use the | |
987 | system's C<malloc> implementation instead of its own. | |
988 | ||
989 | C<sv_grow>, which is what's being used to allocate more memory if necessary | |
990 | when appending to a string, has now been taught how to round up the memory | |
991 | it requests to a certain geometric progression, making it much faster on | |
992 | certain platforms and configurations. On Win32, it's now about 100 times | |
993 | faster. | |
994 | ||
995 | =head2 Eliminate C<PL_*> accessor functions under ithreads | |
996 | ||
997 | When C<MULTIPLICITY> was first developed, and interpreter state moved into | |
998 | an interpreter struct, thread and interpreter local C<PL_*> variables were | |
999 | defined as macros that called accessor functions, returning the address of | |
1000 | the value, outside of the perl core. The intent was to allow members | |
1001 | within the interpreter struct to change size without breaking binary | |
1002 | compatibility, so that bug fixes could be merged to a maintenance branch | |
1003 | that necessitated such a size change. | |
1004 | ||
1005 | However, some non-core code defines C<PERL_CORE>, sometimes intentionally | |
1006 | to bypass this mechanism for speed reasons, sometimes for other reasons but | |
1007 | with the inadvertent side effect of bypassing this mechanism. As some of | |
1008 | this code is widespread in production use, the result is that the core | |
1009 | I<can't> change the size of members of the interpreter struct, as it will | |
1010 | break such modules compiled against a previous release on that maintenance | |
1011 | branch. The upshot is that this mechanism is redundant, and well-behaved | |
1012 | code is penalised by it. Hence it can and should be removed (and has | |
1013 | been). | |
1014 | ||
1015 | =head2 Freeing weak references | |
1016 | ||
1017 | When an object has many weak references to it, freeing that object | |
1018 | can under some some circumstances take O(N^2) time to free (where N is the | |
1019 | number of references). The number of circumstances has been reduced | |
1020 | [perl #75254] | |
1021 | ||
1022 | =head2 Lexical array and hash assignments | |
1023 | ||
1024 | An earlier optimisation to speed up C<my @array = ...> and | |
1025 | C<my %hash = ...> assignments caused a bug and was disabled in Perl 5.12.0. | |
1026 | ||
1027 | Now we have found another way to speed up these assignments [perl #82110]. | |
df91d470 | 1028 | |
111b6aa7 | 1029 | =head2 C<@_> uses less memory |
df91d470 | 1030 | |
111b6aa7 FC |
1031 | Previously, C<@_> was allocated for every subroutine at compile time with |
1032 | enough space for four entries. Now this allocation is done on demand when | |
1033 | the subroutine is called [perl #72416]. | |
5076a392 | 1034 | |
5076a392 FC |
1035 | =head2 Size optimisations to SV and HV structures |
1036 | ||
1037 | xhv_fill has been eliminated from struct xpvhv, saving 1 IV per hash and | |
111b6aa7 | 1038 | on some systems will cause struct xpvhv to become cache-aligned. To avoid |
5076a392 FC |
1039 | this memory saving causing a slowdown elsewhere, boolean use of HvFILL |
1040 | now calls HvTOTALKEYS instead (which is equivalent) - so while the fill | |
111b6aa7 FC |
1041 | data when actually required are now calculated on demand, the cases when |
1042 | this needs to be done should be few and far between. | |
5076a392 | 1043 | |
111b6aa7 FC |
1044 | The order of structure elements in SV bodies has changed. Effectively, |
1045 | the NV slot has swapped location with STASH and MAGIC. As all access to | |
1046 | SV members is via macros, this should be completely transparent. This | |
5076a392 FC |
1047 | change allows the space saving for PVHVs documented above, and may reduce |
1048 | the memory allocation needed for PVIVs on some architectures. | |
1049 | ||
fa232254 FC |
1050 | C<XPV>, C<XPVIV>, and C<XPVNV> now only allocate the parts of the C<SV> body |
1051 | they actually use, saving some space. | |
5076a392 | 1052 | |
fa232254 FC |
1053 | Scalars containing regular expressions now only allocate the part of the C<SV> |
1054 | body they actually use, saving some space. | |
5076a392 FC |
1055 | |
1056 | =head2 Memory consumption improvements to Exporter | |
1057 | ||
1058 | The @EXPORT_FAIL AV is no longer created unless required, hence neither is | |
111b6aa7 FC |
1059 | the typeglob backing it. This saves about 200 bytes for every package that |
1060 | uses Exporter but doesn't use this functionality. | |
5076a392 | 1061 | |
111b6aa7 | 1062 | =head2 Memory savings for weak references |
5076a392 FC |
1063 | |
1064 | For weak references, the common case of just a single weak reference per | |
1065 | referent has been optimised to reduce the storage required. In this case it | |
111b6aa7 | 1066 | saves the equivalent of one small Perl array per referent. |
5076a392 | 1067 | |
111b6aa7 | 1068 | =head2 C<%+> and C<%-> use less memory |
5076a392 FC |
1069 | |
1070 | The bulk of the C<Tie::Hash::NamedCapture> module used to be in the perl | |
111b6aa7 | 1071 | core. It has now been moved to an XS module, to reduce the overhead for |
5076a392 FC |
1072 | programs that do not use C<%+> or C<%->. |
1073 | ||
fa232254 | 1074 | =head2 Multiple small improvements to threads |
5076a392 | 1075 | |
fa232254 FC |
1076 | The internal structures of threading now make fewer API calls and fewer |
1077 | allocations, resulting in noticeably smaller object code. Additionally, | |
1078 | many thread context checks have been deferred so that they're only done | |
1079 | when required (although this is only possible for non-debugging builds). | |
5076a392 | 1080 | |
fa232254 | 1081 | =head2 Adjacent pairs of nextstate opcodes are now optimized away |
5076a392 | 1082 | |
fa232254 | 1083 | Previously, in code such as |
5076a392 | 1084 | |
fa232254 | 1085 | use constant DEBUG => 0; |
5076a392 | 1086 | |
fa232254 FC |
1087 | sub GAK { |
1088 | warn if DEBUG; | |
1089 | print "stuff\n"; | |
1090 | } | |
5076a392 | 1091 | |
fa232254 FC |
1092 | the ops for C<warn if DEBUG;> would be folded to a C<null> op (C<ex-const>), but |
1093 | the C<nextstate> op would remain, resulting in a runtime op dispatch of | |
1094 | C<nextstate>, C<nextstate>, .... | |
5076a392 | 1095 | |
fa232254 FC |
1096 | The execution of a sequence of C<nextstate> ops is indistinguishable from just |
1097 | the last C<nextstate> op so the peephole optimizer now eliminates the first of | |
1098 | a pair of C<nextstate> ops, except where the first carries a label, since labels | |
1099 | must not be eliminated by the optimizer and label usage isn't conclusively known | |
1100 | at compile time. | |
5076a392 FC |
1101 | |
1102 | =head1 Modules and Pragmata | |
1103 | ||
1104 | =head2 New Modules and Pragmata | |
1105 | ||
1106 | =over 4 | |
1107 | ||
1108 | =item * | |
1109 | ||
1110 | C<CPAN::Meta::YAML> 0.003 has been added as a dual-life module. It supports a | |
1111 | subset of YAML sufficient for reading and writing META.yml and MYMETA.yml files | |
1112 | included with CPAN distributions or generated by the module installation | |
1113 | toolchain. It should not be used for any other general YAML parsing or | |
1114 | generation task. | |
1115 | ||
1116 | =item * | |
1117 | ||
1118 | C<CPAN::Meta> version 2.110440 has been added as a dual-life module. It | |
1119 | provides a standard library to read, interpret and write CPAN distribution | |
1120 | metadata files (e.g. META.json and META.yml) which describes a | |
1121 | distribution, its contents, and the requirements for building it and | |
1122 | installing it. The latest CPAN distribution metadata specification is | |
1123 | included as C<CPAN::Meta::Spec> and notes on changes in the specification | |
1124 | over time are given in C<CPAN::Meta::History>. | |
1125 | ||
1126 | =item * | |
1127 | ||
5a553547 | 1128 | C<HTTP::Tiny> 0.011 has been added as a dual-life module. It is a very |
5076a392 FC |
1129 | small, simple HTTP/1.1 client designed for simple GET requests and file |
1130 | mirroring. It has has been added to enable CPAN.pm and CPANPLUS to | |
1131 | "bootstrap" HTTP access to CPAN using pure Perl without relying on external | |
1132 | binaries like F<curl> or F<wget>. | |
1133 | ||
1134 | =item * | |
1135 | ||
1136 | C<JSON::PP> 2.27105 has been added as a dual-life module, for the sake of | |
1137 | reading F<META.json> files in CPAN distributions. | |
1138 | ||
1139 | =item * | |
1140 | ||
21ef4e45 | 1141 | C<Module::Metadata> 1.000004 has been added as a dual-life module. It gathers |
5076a392 FC |
1142 | package and POD information from Perl module files. It is a standalone module |
1143 | based on Module::Build::ModuleInfo for use by other module installation | |
1144 | toolchain components. Module::Build::ModuleInfo has been deprecated in | |
1145 | favor of this module instead. | |
1146 | ||
1147 | =item * | |
1148 | ||
1149 | C<Perl::OSType> 1.002 has been added as a dual-life module. It maps Perl | |
1150 | operating system names (e.g. 'dragonfly' or 'MSWin32') to more generic types | |
1151 | with standardized names (e.g. "Unix" or "Windows"). It has been refactored | |
1152 | out of Module::Build and ExtUtils::CBuilder and consolidates such mappings into | |
1153 | a single location for easier maintenance. | |
1154 | ||
1155 | =item * | |
1156 | ||
1157 | The following modules were added by the C<Unicode::Collate> | |
1158 | upgrade. See below for details. | |
1159 | ||
1160 | C<Unicode::Collate::CJK::Big5> | |
1161 | ||
1162 | C<Unicode::Collate::CJK::GB2312> | |
1163 | ||
1164 | C<Unicode::Collate::CJK::JISX0208> | |
1165 | ||
1166 | C<Unicode::Collate::CJK::Korean> | |
1167 | ||
1168 | C<Unicode::Collate::CJK::Pinyin> | |
1169 | ||
1170 | C<Unicode::Collate::CJK::Stroke> | |
1171 | ||
1172 | =item * | |
1173 | ||
1174 | C<Version::Requirements> version 0.101020 has been added as a dual-life | |
1175 | module. It provides a standard library to model and manipulates module | |
1176 | prerequisites and version constraints as defined in the L<CPAN::Meta::Spec>. | |
1177 | ||
1178 | =back | |
1179 | ||
a5794e94 | 1180 | =head2 Updated Modules and Pragma |
5076a392 FC |
1181 | |
1182 | =over 4 | |
1183 | ||
1184 | =item * | |
1185 | ||
5076a392 FC |
1186 | C<Archive::Extract> has been upgraded from version 0.38 to 0.48. |
1187 | ||
1188 | Updates since 0.38 include: a safe print method that guards | |
1189 | Archive::Extract from changes to $\; a fix to the tests when run in core | |
1984204c FC |
1190 | perl; support for TZ files; a modification for the lzma |
1191 | logic to favour IO::Uncompress::Unlzma; and a fix | |
1192 | for an issue with NetBSD-current and its new unzip | |
5076a392 FC |
1193 | executable. |
1194 | ||
1195 | =item * | |
1196 | ||
1197 | C<Archive::Tar> has been upgraded from version 1.54 to 1.76. | |
1198 | ||
1984204c FC |
1199 | Important changes since 1.54 include the following: |
1200 | ||
1201 | =over | |
1202 | ||
1203 | =item * | |
1204 | ||
1205 | Compatibility with busybox implementations of tar | |
1206 | ||
1207 | =item * | |
1208 | ||
1209 | A fix so that C<write()> and C<create_archive()> | |
1210 | close only handles they opened | |
1211 | ||
1212 | =item * | |
1213 | ||
1214 | A bug was fixed regarding the exit code of extract_archive. | |
5076a392 | 1215 | |
1984204c FC |
1216 | =item * |
1217 | ||
4f978a3b | 1218 | The C<ptar> utility has a new option to allow safe |
5076a392 FC |
1219 | creation of tarballs without world-writable files on Windows, allowing those |
1220 | archives to be uploaded to CPAN. | |
1221 | ||
1984204c FC |
1222 | =item * |
1223 | ||
1224 | A new ptargrep utility for using regular expressions against | |
5076a392 FC |
1225 | the contents of files in a tar archive. |
1226 | ||
1984204c FC |
1227 | =item * |
1228 | ||
1229 | Pax extended headers are now skipped. | |
1230 | ||
1231 | =back | |
5076a392 FC |
1232 | |
1233 | =item * | |
1234 | ||
5076a392 FC |
1235 | C<B> has been upgraded from version 1.23 to 1.27. |
1236 | ||
1237 | It no longer crashes when taking apart a C<y///> containing characters | |
1238 | outside the octet range or compiled in a C<use utf8> scope. | |
1239 | ||
1240 | The size of the shared object has been reduced by about 40%, with no | |
1241 | reduction in functionality. | |
1242 | ||
1243 | =item * | |
1244 | ||
1245 | C<B::Concise> has been upgraded from version 0.78 to 0.82. | |
1246 | ||
1247 | B::Concise marks rv2sv, rv2av and rv2hv ops with the new OPpDEREF flag | |
1248 | as "DREFed". | |
1249 | ||
1250 | It no longer produces mangled output with the C<-tree> option | |
1251 | [perl #80632]. | |
1252 | ||
1253 | =item * | |
1254 | ||
5076a392 FC |
1255 | C<B::Deparse> has been upgraded from version 0.96 to 1.02. |
1256 | ||
1984204c | 1257 | The deparsing of a nextstate op has changed when it has both a |
5076a392 FC |
1258 | change of package (relative to the previous nextstate), or a change of |
1259 | C<%^H> or other state, and a label. Previously the label was emitted | |
cdc10f43 | 1260 | first, but now the label is emitted last (5.12.1). |
5076a392 | 1261 | |
5a553547 FC |
1262 | The C<no 5.13.2> or similar form is now correctly handled by B::Deparse |
1263 | (5.12.3). | |
5076a392 FC |
1264 | |
1265 | B::Deparse now properly handles the code that applies a conditional | |
1266 | pattern match against implicit C<$_> as it was fixed in [perl #20444]. | |
1267 | ||
1984204c FC |
1268 | Deparsing of C<our> followed by a variable with funny characters |
1269 | (as permitted under the C<utf8> pragma) has also been fixed [perl #33752]. | |
5076a392 FC |
1270 | |
1271 | =item * | |
1272 | ||
c74c1fa8 | 1273 | C<Carp> has been upgraded from version 1.15 to 1.20. |
5076a392 FC |
1274 | |
1275 | L<Carp> now detects incomplete L<caller()|perlfunc/"caller EXPR"> overrides and | |
d430b8e7 FC |
1276 | avoids using bogus C<@DB::args>. To provide backtraces, |
1277 | Carp relies on particular behaviour of the C<caller> | |
1278 | built-in. Carp now detects if other code has | |
5076a392 | 1279 | overridden this with an incomplete implementation, and modifies its backtrace |
d430b8e7 FC |
1280 | accordingly. Previously incomplete overrides would cause incorrect values |
1281 | in backtraces (best case), or obscure fatal errors (worst case). | |
5076a392 FC |
1282 | |
1283 | This fixes certain cases of C<Bizarre copy of ARRAY> caused by modules | |
d430b8e7 | 1284 | overriding C<caller()> incorrectly (5.12.2). |
5076a392 | 1285 | |
1984204c | 1286 | It now also avoids using regular expressions that cause perl to |
5076a392 FC |
1287 | load its Unicode tables, in order to avoid the 'BEGIN not safe after |
1288 | errors' error that will ensue if there has been a syntax error | |
1289 | [perl #82854]. | |
1290 | ||
1291 | =item * | |
1292 | ||
9eb7ad55 | 1293 | C<CGI> has been upgraded from version 3.48 to 3.52. |
5076a392 FC |
1294 | |
1295 | This provides the following security fixes: the MIME boundary in | |
1984204c FC |
1296 | multipart_init is now random and the handling of |
1297 | newlines embedded in header values has been improved. | |
5076a392 FC |
1298 | |
1299 | =item * | |
1300 | ||
5076a392 FC |
1301 | C<Compress::Raw::Bzip2> has been upgraded from version 2.024 to 2.033. |
1302 | ||
1984204c | 1303 | It has been updated to use bzip2 1.0.6. |
5076a392 FC |
1304 | |
1305 | =item * | |
1306 | ||
51090521 FR |
1307 | C<Compress::Raw::Zlib> has been upgraded from version 2.024 to 2.033. |
1308 | ||
1309 | =item * | |
1310 | ||
f75b7efc | 1311 | C<CPAN> has been upgraded from version 1.94_56 to 1.9600. |
1984204c FC |
1312 | |
1313 | Major highlights: | |
5076a392 FC |
1314 | |
1315 | =over 4 | |
1316 | ||
1984204c | 1317 | =item * much less configuration dialog hassle |
5076a392 | 1318 | |
1984204c | 1319 | =item * support for META/MYMETA.json |
5076a392 | 1320 | |
1984204c | 1321 | =item * support for local::lib |
5076a392 | 1322 | |
1984204c | 1323 | =item * support for HTTP::Tiny to reduce the dependency on ftp sites |
5076a392 | 1324 | |
1984204c | 1325 | =item * automatic mirror selection |
5076a392 | 1326 | |
1984204c | 1327 | =item * iron out all known bugs in configure_requires |
5076a392 | 1328 | |
1984204c FC |
1329 | =item * support for distributions compressed with bzip2 |
1330 | ||
1331 | =item * allow Foo/Bar.pm on the commandline to mean Foo::Bar | |
1332 | ||
1333 | =back | |
5076a392 FC |
1334 | |
1335 | =item * | |
1336 | ||
d430b8e7 FC |
1337 | C<CPANPLUS> has been upgraded from version 0.90 to 0.9103. |
1338 | ||
1339 | A change to F<cpanp-run-perl> | |
1340 | resolves L<RT #55964|http://rt.cpan.org/Public/Bug/Display.html?id=55964> | |
1341 | and L<RT #57106|http://rt.cpan.org/Public/Bug/Display.html?id=57106>, both | |
1342 | of which related to failures to install distributions that use | |
1343 | C<Module::Install::DSL> (5.12.2). | |
5076a392 | 1344 | |
1984204c FC |
1345 | A dependency on Config was not recognised as a |
1346 | core module dependency. This has been fixed. | |
5076a392 | 1347 | |
1984204c | 1348 | CPANPLUS now includes support for META.json and MYMETA.json. |
5076a392 FC |
1349 | |
1350 | =item * | |
1351 | ||
4467e8f7 FR |
1352 | C<CPANPLUS::Dist::Build> has been upgraded from version 0.46 to 0.54. |
1353 | ||
1354 | =item * | |
1355 | ||
5076a392 FC |
1356 | C<Data::Dumper> has been upgraded from version 2.125 to 2.130_02. |
1357 | ||
4ed2cea4 FC |
1358 | The indentation used to be off when C<$Data::Dumper::Terse> was set. This |
1359 | has been fixed [perl #73604]. | |
1360 | ||
1984204c FC |
1361 | This upgrade also fixes a crash when using custom sort functions that might |
1362 | cause the stack to change [perl #74170]. | |
5076a392 FC |
1363 | |
1364 | C<Dumpxs> no longer crashes with globs returned by C<*$io_ref> | |
1365 | [perl #72332]. | |
1366 | ||
1367 | =item * | |
1368 | ||
549d34f5 FR |
1369 | C<DB_File> has been upgraded from version 1.820 to 1.821. |
1370 | ||
1371 | =item * | |
1372 | ||
5076a392 FC |
1373 | C<Devel::DProf> has been upgraded from version 20080331.00 to 20110228.00. |
1374 | ||
1375 | Merely loading C<Devel::DProf> now no longer triggers profiling to start. | |
1376 | C<use Devel::DProf> and C<perl -d:DProf ...> still behave as before and start | |
1377 | the profiler. | |
1378 | ||
1379 | NOTE: C<Devel::DProf> is deprecated and will be removed from a future | |
1984204c | 1380 | version of Perl. We strongly recommend that you install and use |
5076a392 FC |
1381 | L<Devel::NYTProf> instead, as it offers significantly improved |
1382 | profiling and reporting. | |
1383 | ||
1384 | =item * | |
1385 | ||
66899ca3 FR |
1386 | C<Devel::SelfStubber> has been upgraded from version 1.03 to 1.05. |
1387 | ||
1388 | =item * | |
1389 | ||
5076a392 FC |
1390 | C<diagnostics> has been upgraded from version 1.19 to 1.22. |
1391 | ||
1392 | It now renders pod links slightly better, and has been taught to find | |
1393 | descriptions for messages that share their descriptions with other | |
1394 | messages. | |
1395 | ||
1396 | =item * | |
1397 | ||
1398 | C<Digest::MD5> has been upgraded from version 2.39 to 2.51. | |
1399 | ||
1400 | It is now safe to use this module in combination with threads. | |
1401 | ||
1402 | =item * | |
1403 | ||
1404 | C<Digest::SHA> has been upgraded from version 5.47 to 5.61. | |
1405 | ||
1406 | C<shasum> now more closely mimics C<sha1sum>/C<md5sum>. | |
1407 | ||
1408 | C<Addfile> accepts all POSIX filenames. | |
1409 | ||
1984204c FC |
1410 | New SHA-512/224 and SHA-512/256 transforms (ref. NIST Draft FIPS 180-4 |
1411 | [February 2011]) | |
5076a392 FC |
1412 | |
1413 | =item * | |
1414 | ||
e53cbaa3 FR |
1415 | C<Dumpvalue> has been upgraded from version 1.13 to 1.16. |
1416 | ||
1417 | =item * | |
1418 | ||
31e8b85a | 1419 | C<DynaLoader> has been upgraded from version 1.10 to 1.13. |
5076a392 FC |
1420 | |
1421 | It fixes a buffer overflow when passed a very long file name. | |
1422 | ||
1423 | It no longer inherits from AutoLoader; hence it no longer | |
1424 | produces weird error messages for unsuccessful method calls on classes that | |
1425 | inherit from DynaLoader [perl #84358]. | |
1426 | ||
1427 | =item * | |
1428 | ||
1429 | C<Encode> has been upgraded from version 2.39 to 2.42. | |
1430 | ||
1431 | Now, all 66 Unicode non-characters are treated the same way U+FFFF has | |
1984204c FC |
1432 | always been treated; in cases when it was disallowed, all 66 are |
1433 | disallowed; in those cases where it warned, all 66 warn. | |
5076a392 FC |
1434 | |
1435 | =item * | |
1436 | ||
68f90ac3 FR |
1437 | C<Env> has been upgraded from version 1.01 to 1.02. |
1438 | ||
1439 | =item * | |
1440 | ||
5076a392 FC |
1441 | C<Errno> has been upgraded from version 1.11 to 1.13. |
1442 | ||
1443 | The implementation of C<Errno> has been refactored to use about 55% less memory. | |
5076a392 FC |
1444 | |
1445 | On some platforms with unusual header files, like Win32/gcc using mingw64 | |
1446 | headers, some constants which weren't actually error numbers have been exposed | |
1447 | by C<Errno>. This has been fixed [perl #77416]. | |
1448 | ||
1449 | =item * | |
1450 | ||
1451 | C<Exporter> has been upgraded from version 5.64_01 to 5.64_03. | |
1452 | ||
1453 | Exporter no longer overrides C<$SIG{__WARN__}> [perl #74472] | |
1454 | ||
1455 | =item * | |
1456 | ||
25fe7f8f FR |
1457 | C<ExtUtils::CBuilder> has been upgraded from version 0.27 to 0.280202. |
1458 | ||
1459 | =item * | |
1460 | ||
2292e71e FR |
1461 | C<ExtUtils::Command> has been upgraded from version 1.16 to 1.17. |
1462 | ||
1463 | =item * | |
1464 | ||
5076a392 FC |
1465 | C<ExtUtils::Constant> has been upgraded from 0.22 to 0.23. |
1466 | ||
1467 | The C<AUTOLOAD> helper code generated by C<ExtUtils::Constant::ProxySubs> | |
1468 | can now C<croak> for missing constants, or generate a complete C<AUTOLOAD> | |
1984204c FC |
1469 | subroutine in XS, allowing simplification of many modules that use it |
1470 | (C<Fcntl>, C<File::Glob>, C<GDBM_File>, C<I18N::Langinfo>, C<POSIX>, | |
1471 | C<Socket>). | |
5076a392 FC |
1472 | |
1473 | C<ExtUtils::Constant::ProxySubs> can now optionally push the names of all | |
1984204c | 1474 | constants onto the package's C<@EXPORT_OK>. |
5076a392 FC |
1475 | |
1476 | =item * | |
1477 | ||
588c5853 FR |
1478 | C<ExtUtils::Install> has been upgraded from version 1.55 to 1.56. |
1479 | ||
1480 | =item * | |
1481 | ||
5418ffb3 FR |
1482 | C<ExtUtils::MakeMaker> has been upgraded from version 6.56 to 6.57_05. |
1483 | ||
1484 | =item * | |
1485 | ||
f40ab45f FR |
1486 | C<ExtUtils::Manifest> has been upgraded from version 1.57 to 1.58. |
1487 | ||
1488 | =item * | |
1489 | ||
b7064dd7 FR |
1490 | C<ExtUtils::ParseXS> has been upgraded from version 2.21 to 2.2209. |
1491 | ||
1492 | =item * | |
1493 | ||
05102622 FR |
1494 | C<File::CheckTree> has been upgraded from version 4.4 to 4.41. |
1495 | ||
1496 | =item * | |
1497 | ||
e12786fa | 1498 | C<File::DosGlob> has been upgraded from version 1.01 to 1.04. |
5076a392 FC |
1499 | |
1500 | It allows patterns containing literal parentheses (they no longer need to | |
1984204c FC |
1501 | be escaped). On Windows, it no longer |
1502 | adds an extra F<./> to the file names | |
5076a392 FC |
1503 | returned when the pattern is a relative glob with a drive specification, |
1504 | like F<c:*.pl> [perl #71712]. | |
1505 | ||
1506 | =item * | |
1507 | ||
1508 | C<File::Fetch> has been upgraded from version 0.24 to 0.32. | |
1509 | ||
1510 | C<HTTP::Lite> is now supported for 'http' scheme. | |
1511 | ||
1512 | The C<fetch> utility is supported on FreeBSD, NetBSD and | |
1513 | Dragonfly BSD for the C<http> and C<ftp> schemes. | |
1514 | ||
1515 | =item * | |
1516 | ||
23f2cbb1 | 1517 | C<File::Find> has been upgraded from version 1.15 to 1.19. |
5076a392 | 1518 | |
1984204c | 1519 | It improves handling of backslashes on Windows, so that paths like |
5076a392 FC |
1520 | F<c:\dir\/file> are no longer generated [perl #71710]. |
1521 | ||
1522 | =item * | |
1523 | ||
d430b8e7 FC |
1524 | C<File::Spec> has been upgraded from version 3.31 to 3.33. |
1525 | ||
1526 | Several portability fixes were made in C<File::Spec::VMS>: a colon is now | |
1527 | recognized as a delimiter in native filespecs; caret-escaped delimiters are | |
1528 | recognized for better handling of extended filespecs; C<catpath()> returns | |
1529 | an empty directory rather than the current directory if the input directory | |
1530 | name is empty; C<abs2rel()> properly handles Unix-style input (5.12.2). | |
1531 | ||
1532 | =item * | |
1533 | ||
46ba0657 | 1534 | C<File::stat> has been upgraded from 1.02 to 1.05. |
5076a392 FC |
1535 | |
1536 | The C<-x> and C<-X> file test operators now work correctly under the root | |
1537 | user. | |
1538 | ||
1539 | =item * | |
1540 | ||
b7edcc3c FR |
1541 | C<Filter::Simple> has been upgraded from version 0.84 to 0.86. |
1542 | ||
1543 | =item * | |
1544 | ||
dc6857fd | 1545 | C<GDBM_File> has been upgraded from 1.10 to 1.14. |
5076a392 FC |
1546 | |
1547 | This fixes a memory leak when DBM filters are used. | |
1548 | ||
1549 | =item * | |
1550 | ||
6e107b45 | 1551 | C<Hash::Util> has been upgraded from 0.07 to 0.11. |
5076a392 | 1552 | |
1984204c FC |
1553 | Hash::Util no longer emits spurious "uninitialized" warnings when |
1554 | recursively locking hashes that have undefined values [perl #74280]. | |
5076a392 FC |
1555 | |
1556 | =item * | |
1557 | ||
eec33fe6 FR |
1558 | C<I18N::Collate> has been upgraded from version 1.01 to 1.02. |
1559 | ||
1560 | =item * | |
1561 | ||
ad5f8f47 | 1562 | C<I18N::Langinfo> has been upgraded from version 0.03 to 0.08. |
5076a392 FC |
1563 | |
1564 | C<langinfo()> now defaults to using C<$_> if there is no argument given, just | |
5334145a | 1565 | as the documentation has always claimed. |
5076a392 FC |
1566 | |
1567 | =item * | |
1568 | ||
c41635f7 FR |
1569 | C<I18N::LangTags> has been upgraded from version 0.35 to 0.35_01. |
1570 | ||
1571 | =item * | |
1572 | ||
98a6a4ff FR |
1573 | C<if> has been upgraded from version 0.05 to 0.0601. |
1574 | ||
1575 | =item * | |
1576 | ||
f6ff7fb6 FR |
1577 | C<IO> has been upgraded from version 1.25_02 to 1.25_04. |
1578 | ||
1579 | =item * | |
1580 | ||
d13528c5 | 1581 | C<IO::Select> has been upgraded from version 1.17 to 1.20. |
5076a392 FC |
1582 | |
1583 | It now allows IO::Handle objects (and objects in derived classes) to be | |
1584 | removed from an IO::Select set even if the underlying file descriptor is | |
1585 | closed or invalid. | |
1586 | ||
1587 | =item * | |
1588 | ||
d07561d3 | 1589 | C<IPC::Cmd> has been upgraded from version 0.54 to 0.70. |
5076a392 | 1590 | |
1984204c FC |
1591 | Resolves an issue with splitting Win32 command lines. An argument |
1592 | consisting of the single character "0" used to be omitted (CPAN RT #62961). | |
5076a392 FC |
1593 | |
1594 | =item * | |
1595 | ||
3f16e4eb | 1596 | C<IPC::Open3> has been upgraded from 1.05 to 1.09. |
5076a392 | 1597 | |
4ed2cea4 FC |
1598 | C<open3> now produces an error if the C<exec> call fails, allowing this |
1599 | condition to be distinguished from a child process that exited with a | |
1600 | non-zero status [perl #72016]. | |
1601 | ||
5076a392 FC |
1602 | The internal C<xclose> routine now knows how to handle file descriptors, as |
1603 | documented, so duplicating STDIN in a child process using its file | |
1604 | descriptor now works [perl #76474]. | |
1605 | ||
1606 | =item * | |
1607 | ||
c8b41807 FR |
1608 | C<IPC::SysV> has been upgraded from version 2.01 to 2.03. |
1609 | ||
1610 | =item * | |
1611 | ||
ef79f038 FR |
1612 | C<lib> has been upgraded from version 0.62 to 0.63. |
1613 | ||
1614 | =item * | |
1615 | ||
5b1884f4 | 1616 | C<Locale::Maketext> has been upgraded from version 1.14 to 1.19. |
5076a392 | 1617 | |
1984204c | 1618 | Locale::Maketext now supports external caches. |
5076a392 | 1619 | |
1984204c FC |
1620 | This upgrade also fixes an infinite loop in |
1621 | C<Locale::Maketext::Guts::_compile()> when | |
5076a392 FC |
1622 | working with tainted values (CPAN RT #40727). |
1623 | ||
1984204c | 1624 | C<< ->maketext >> calls will now back up and restore C<$@> so that error |
5076a392 FC |
1625 | messages are not suppressed (CPAN RT #34182). |
1626 | ||
1627 | =item * | |
1628 | ||
3811bd2b FR |
1629 | C<Log::Message> has been upgraded from version 0.02 to 0.04. |
1630 | ||
1631 | =item * | |
1632 | ||
8eb65377 FR |
1633 | C<Log::Message::Simple> has been upgraded from version 0.06 to 0.08. |
1634 | ||
1635 | =item * | |
1636 | ||
5076a392 FC |
1637 | C<Math::BigInt> has been upgraded from version 1.89_01 to 1.994. |
1638 | ||
1639 | This fixes, among other things, incorrect results when computing binomial | |
1640 | coefficients [perl #77640]. | |
1641 | ||
1984204c | 1642 | It also prevents C<sqrt($int)> from crashing under C<use bigrat;> |
5076a392 FC |
1643 | [perl #73534]. |
1644 | ||
1645 | =item * | |
1646 | ||
846c1cec FR |
1647 | C<Math::BigInt::FastCalc> has been upgraded from version 0.19 to 0.28. |
1648 | ||
1649 | =item * | |
1650 | ||
fce4aef3 FR |
1651 | C<Math::BigRat> has been upgraded from version 0.24 to 0.26_02. |
1652 | ||
1653 | =item * | |
1654 | ||
12e26027 FR |
1655 | C<Memoize> has been upgraded from version 1.01_03 to 1.02. |
1656 | ||
1657 | =item * | |
1658 | ||
5076a392 FC |
1659 | C<MIME::Base64> has been upgraded from 3.08 to 3.13. |
1660 | ||
1661 | Includes new functions to calculate the length of encoded and decoded | |
1662 | base64 strings. | |
1663 | ||
1664 | Now provides C<encode_base64url> and C<decode_base64url> functions to process | |
1665 | the base64 scheme for "URL applications". | |
1666 | ||
1667 | =item * | |
1668 | ||
1669 | C<Module::Build> has been upgraded from version 0.3603 to 0.3800. | |
1670 | ||
1671 | A notable change is the deprecation of several modules. | |
1672 | Module::Build::Version has been deprecated and Module::Build now relies | |
1673 | directly upon L<version>. Module::Build::ModuleInfo has been deprecated in | |
1674 | favor of a standalone copy of it called L<Module::Metadata>. | |
1675 | Module::Build::YAML has been deprecated in favor of L<CPAN::Meta::YAML>. | |
1676 | ||
1677 | Module::Build now also generates META.json and MYMETA.json files | |
1678 | in accordance with version 2 of the CPAN distribution metadata specification, | |
1679 | L<CPAN::Meta::Spec>. The older format META.yml and MYMETA.yml files are | |
1680 | still generated, as well. | |
1681 | ||
1682 | =item * | |
1683 | ||
7259fe26 | 1684 | C<Module::CoreList> has been upgraded from version 2.29 to 2.47. |
5076a392 FC |
1685 | |
1686 | Besides listing the updated core modules of this release, it also stops listing | |
1984204c | 1687 | the C<Filespec> module. That module never existed in core. The scripts |
5076a392 | 1688 | generating C<Module::CoreList> confused it with C<VMS::Filespec>, which actually |
1984204c | 1689 | is a core module as of perl 5.8.7. |
5076a392 FC |
1690 | |
1691 | =item * | |
1692 | ||
193af05b FR |
1693 | C<Module::Load> has been upgraded from version 0.16 to 0.18. |
1694 | ||
1695 | =item * | |
1696 | ||
5b3a054f FR |
1697 | C<Module::Load::Conditional> has been upgraded from version 0.34 to 0.44. |
1698 | ||
1699 | =item * | |
1700 | ||
4f978a3b FR |
1701 | C<NDBM_File> has been upgraded from version 1.08 to 1.11. |
1702 | ||
1703 | This fixes a memory leak when DBM filters are used. | |
1704 | ||
1705 | =item * | |
1706 | ||
d0aa5c91 FR |
1707 | C<Net::Ping> has been upgraded from version 2.36 to 2.38. |
1708 | ||
1709 | =item * | |
1710 | ||
d44b8a8c FR |
1711 | C<NEXT> has been upgraded from version 0.64 to 0.65. |
1712 | ||
1713 | =item * | |
1714 | ||
678d4fd4 FR |
1715 | C<Object::Accessor> has been upgraded from version 0.36 to 0.38. |
1716 | ||
1717 | =item * | |
1718 | ||
34188656 | 1719 | C<ODBM_File> have been upgraded from version 1.07 to 1.10. |
5076a392 FC |
1720 | |
1721 | This fixes a memory leak when DBM filters are used. | |
1722 | ||
1723 | =item * | |
1724 | ||
77be713d | 1725 | C<overload> has been upgraded from 1.10 to 1.12. |
5076a392 FC |
1726 | |
1727 | C<overload::Method> can now handle subroutines that are themselves blessed | |
1728 | into overloaded classes [perl #71998]. | |
1729 | ||
5076a392 FC |
1730 | The documentation has greatly improved. See L</Documentation> below. |
1731 | ||
1732 | =item * | |
1733 | ||
f84c796e FR |
1734 | C<Params::Check> has been upgraded from version 0.26 to 0.28. |
1735 | ||
1736 | =item * | |
1737 | ||
550ee92b FR |
1738 | C<parent> has been upgraded from version 0.223 to 0.225. |
1739 | ||
1740 | =item * | |
1741 | ||
5076a392 FC |
1742 | C<Parse::CPAN::Meta> has been upgraded from version 1.40 to 1.4401. |
1743 | ||
1984204c | 1744 | The latest Parse::CPAN::Meta can now read YAML and JSON files using |
5076a392 FC |
1745 | L<CPAN::Meta::YAML> and L<JSON::PP>, which are now part of the Perl core. |
1746 | ||
1747 | =item * | |
1748 | ||
5076a392 FC |
1749 | C<PerlIO::scalar> has been upgraded from 0.07 to 0.11. |
1750 | ||
1751 | A C<read> after a C<seek> beyond the end of the string no longer thinks it | |
1752 | has data to read [perl #78716]. | |
1753 | ||
1754 | =item * | |
1755 | ||
be3c8498 FR |
1756 | C<Pod::LaTeX> has been upgraded from version 0.58 to 0.59. |
1757 | ||
1758 | =item * | |
1759 | ||
fd8a2e89 FR |
1760 | C<Pod::Perldoc> has been upgraded from version 3.15_02 to 3.15_03. |
1761 | ||
1762 | =item * | |
1763 | ||
5bcb6583 FR |
1764 | C<Pod::Simple> has been upgraded from version 3.13 to 3.16. |
1765 | ||
1766 | =item * | |
1767 | ||
abb8c779 | 1768 | C<POSIX> has been upgraded from 1.19 to 1.24. |
5076a392 FC |
1769 | |
1770 | It now includes constants for POSIX signal constants. | |
1771 | ||
1772 | =item * | |
1773 | ||
1984204c | 1774 | C<re> has been upgraded from version 0.11 to 0.17. |
5076a392 FC |
1775 | |
1776 | New C<use re "/flags"> pragma | |
1777 | ||
5076a392 | 1778 | The C<regmust> function used to crash when called on a regular expression |
1984204c | 1779 | belonging to a pluggable engine. Now it croaks instead. |
5076a392 FC |
1780 | |
1781 | C<regmust> no longer leaks memory. | |
1782 | ||
1783 | =item * | |
1784 | ||
1785 | C<Safe> has been upgraded from version 2.25 to 2.29. | |
1786 | ||
cdc10f43 FC |
1787 | Coderefs returned by C<reval()> and C<rdo()> are now wrapped via |
1788 | C<wrap_code_refs> (5.12.1). | |
1789 | ||
5076a392 FC |
1790 | This fixes a possible infinite loop when looking for coderefs. |
1791 | ||
cdc10f43 | 1792 | It adds several version::vxs::* routines to the default share. |
5076a392 FC |
1793 | |
1794 | =item * | |
1795 | ||
5076a392 FC |
1796 | C<SelfLoader> has been upgraded from 1.17 to 1.18. |
1797 | ||
1798 | It now works in taint mode [perl #72062]. | |
1799 | ||
1800 | =item * | |
1801 | ||
1802 | C<sigtrap> has been upgraded from version 1.04 to 1.05. | |
1803 | ||
1804 | It no longer tries to modify read-only arguments when generating a | |
1805 | backtrace [perl #72340]. | |
1806 | ||
1807 | =item * | |
1808 | ||
1984204c | 1809 | C<Socket> has been upgraded from version 1.87 to 1.94. |
5076a392 | 1810 | |
1984204c | 1811 | See L</IPv6 support>, above. |
5076a392 FC |
1812 | |
1813 | =item * | |
1814 | ||
1815 | C<Storable> has been upgraded from version 2.22 to 2.27. | |
1816 | ||
1817 | Includes performance improvement for overloaded classes. | |
1818 | ||
5076a392 | 1819 | This adds support for serialising code references that contain UTF-8 strings |
1984204c FC |
1820 | correctly. The Storable minor version |
1821 | number changed as a result, meaning that | |
5076a392 FC |
1822 | Storable users who set C<$Storable::accept_future_minor> to a C<FALSE> value |
1823 | will see errors (see L<Storable/FORWARD COMPATIBILITY> for more details). | |
1824 | ||
1825 | Freezing no longer gets confused if the Perl stack gets reallocated | |
1826 | during freezing [perl #80074]. | |
1827 | ||
1828 | =item * | |
1829 | ||
90c6e78f FR |
1830 | C<Term::ANSIColor> has been upgraded from version 2.02 to 3.00. |
1831 | ||
1832 | =item * | |
1833 | ||
d9f2f059 FR |
1834 | C<Term::UI> has been upgraded from version 0.20 to 0.26. |
1835 | ||
1836 | =item * | |
1837 | ||
80ebb519 FR |
1838 | C<Test::Harness> has been upgraded from version 3.17 to 3.23. |
1839 | ||
1840 | =item * | |
1841 | ||
5076a392 FC |
1842 | C<Test::Simple> has been upgraded from version 0.94 to 0.98. |
1843 | ||
1844 | Among many other things, subtests without a C<plan> or C<no_plan> now have an | |
1845 | implicit C<done_testing()> added to them. | |
1846 | ||
1847 | =item * | |
1848 | ||
5076a392 FC |
1849 | C<Thread::Semaphore> has been upgraded from version 2.09 to 2.12. |
1850 | ||
1984204c FC |
1851 | It provides two new methods that give more control over the decrementing of |
1852 | semaphores: C<down_nb> and C<down_force>. | |
5076a392 FC |
1853 | |
1854 | =item * | |
1855 | ||
f0d895e1 FR |
1856 | C<Thread::Queue> has been upgraded from version 2.11 to 2.12. |
1857 | ||
1858 | =item * | |
1859 | ||
1a6b954e FR |
1860 | C<threads> has been upgraded from version 1.75 to 1.83. |
1861 | ||
1862 | =item * | |
1863 | ||
55816daa FR |
1864 | C<threads::shared> has been upgraded from version 1.32 to 1.36. |
1865 | ||
1866 | =item * | |
1867 | ||
5076a392 FC |
1868 | C<Tie::Hash> has been upgraded from version 1.03 to 1.04. |
1869 | ||
1870 | Calling C<< Tie::Hash-E<gt>TIEHASH() >> used to loop forever. Now it C<croak>s. | |
1871 | ||
1872 | =item * | |
1873 | ||
ed68b07e FR |
1874 | C<Tie::RefHash> has been upgraded from version 1.38 to 1.39. |
1875 | ||
1876 | =item * | |
1877 | ||
bb3c221a FR |
1878 | C<Time::HiRes> has been upgraded from version 1.9719 to 1.9721_01. |
1879 | ||
1880 | =item * | |
1881 | ||
97fa568b FR |
1882 | C<Time::Local> has been upgraded from version 1.1901_01 to 1.2000. |
1883 | ||
1884 | =item * | |
1885 | ||
a83cb732 FR |
1886 | C<Time::Piece> has been upgraded from version 1.15_01 to 1.20_01. |
1887 | ||
1888 | =item * | |
1889 | ||
5076a392 FC |
1890 | C<Unicode::Collate> has been upgraded from version 0.52_01 to 0.73. |
1891 | ||
1984204c | 1892 | Unicode::Collate has been updated to use Unicode 6.0.0. |
5076a392 | 1893 | |
1984204c FC |
1894 | Unicode::Collate::Locale now supports a plethora of new locales: ar, be, |
1895 | bg, de__phonebook, hu, hy, kk, mk, nso, om, tn, vi, hr, ig, ja, ko, ru, sq, | |
1896 | se, sr, to, uk, zh, zh__big5han, zh__gb2312han, zh__pinyin and zh__stroke. | |
5076a392 FC |
1897 | |
1898 | The following modules have been added: | |
1899 | ||
1900 | C<Unicode::Collate::CJK::Big5> for C<zh__big5han> which makes | |
1901 | tailoring of CJK Unified Ideographs in the order of CLDR's big5han ordering. | |
1902 | ||
1903 | C<Unicode::Collate::CJK::GB2312> for C<zh__gb2312han> which makes | |
1904 | tailoring of CJK Unified Ideographs in the order of CLDR's gb2312han ordering. | |
1905 | ||
1906 | C<Unicode::Collate::CJK::JISX0208> which makes tailoring of 6355 kanji | |
1907 | (CJK Unified Ideographs) in the JIS X 0208 order. | |
1908 | ||
1909 | C<Unicode::Collate::CJK::Korean> which makes tailoring of CJK Unified Ideographs | |
1910 | in the order of CLDR's Korean ordering. | |
1911 | ||
1912 | C<Unicode::Collate::CJK::Pinyin> for C<zh__pinyin> which makes | |
1913 | tailoring of CJK Unified Ideographs in the order of CLDR's pinyin ordering. | |
1914 | ||
1915 | C<Unicode::Collate::CJK::Stroke> for C<zh__stroke> which makes | |
1916 | tailoring of CJK Unified Ideographs in the order of CLDR's stroke ordering. | |
1917 | ||
5076a392 FC |
1918 | This also sees the switch from using the pure-perl version of this |
1919 | module to the XS version. | |
1920 | ||
1921 | =item * | |
1922 | ||
ec52b54b FR |
1923 | C<Unicode::Normalize> has been upgraded from version 1.03 to 1.10. |
1924 | ||
1925 | =item * | |
1926 | ||
5076a392 FC |
1927 | C<Unicode::UCD> has been upgraded from version 0.27 to 0.32. |
1928 | ||
1984204c FC |
1929 | A new function, C<Unicode::UCD::num()>, has been added. This function |
1930 | returns the numeric value of the string passed it or C<undef> if the string | |
1931 | in its entirety has no "safe" numeric value. (For more detail, and for the | |
1932 | definition of "safe", see L<Unicode::UCD/num>.) | |
5076a392 | 1933 | |
1984204c | 1934 | This upgrade also includes a number of bug fixes: |
5076a392 FC |
1935 | |
1936 | =over 4 | |
1937 | ||
1938 | =item charinfo() | |
1939 | ||
1940 | =over 4 | |
1941 | ||
1942 | =item * | |
1943 | ||
1944 | It is now updated to Unicode Version 6 with Corrigendum #8, except, | |
1945 | as with Perl 5.14, the code point at U+1F514 has no name. | |
1946 | ||
1947 | =item * | |
1948 | ||
1949 | The Hangul syllable code points have the correct names, and their | |
1950 | decompositions are always output without requiring L<Lingua::KO::Hangul::Util> | |
1951 | to be installed. | |
1952 | ||
1953 | =item * | |
1954 | ||
54c7bb16 FC |
1955 | The CJK (Chinese-Japanese-Korean) code points U+2A700 to U+2B734 |
1956 | and U+2B740 to U+2B81D are now properly handled. | |
5076a392 FC |
1957 | |
1958 | =item * | |
1959 | ||
1960 | The numeric values are now output for those CJK code points that have them. | |
1961 | ||
1962 | =item * | |
1963 | ||
1964 | The names that are output for code points with multiple aliases are now the | |
1965 | corrected ones. | |
1966 | ||
1967 | =back | |
1968 | ||
1969 | =item charscript() | |
1970 | ||
1971 | This now correctly returns "Unknown" instead of C<undef> for the script | |
1972 | of a code point that hasn't been assigned another one. | |
1973 | ||
1974 | =item charblock() | |
1975 | ||
1976 | This now correctly returns "No_Block" instead of C<undef> for the block | |
1977 | of a code point that hasn't been assigned to another one. | |
1978 | ||
1979 | =back | |
1980 | ||
5076a392 FC |
1981 | =item * |
1982 | ||
1983 | C<version> has been upgraded from 0.82 to 0.88. | |
1984 | ||
1984204c | 1985 | Due to a bug, now fixed, the C<is_strict> and C<is_lax> functions did not |
cdc10f43 | 1986 | work when exported (5.12.1). |
5076a392 FC |
1987 | |
1988 | =item * | |
1989 | ||
3e625598 | 1990 | C<warnings> has been upgraded from version 1.09 to 1.12. |
5076a392 FC |
1991 | |
1992 | Calling C<use warnings> without arguments is now significantly more efficient. | |
1993 | ||
4f978a3b FR |
1994 | =item * |
1995 | ||
1996 | C<warnings::register> have been upgraded from version 1.01 to 1.02. | |
1997 | ||
5076a392 FC |
1998 | It is now possible to register warning categories other than the names of |
1999 | packages using C<warnings::register>. See L<perllexwarn> for more information. | |
2000 | ||
2001 | =item * | |
2002 | ||
62e270c2 FR |
2003 | C<XSLoader> has been upgraded from version 0.10 to 0.13. |
2004 | ||
2005 | =item * | |
2006 | ||
5076a392 FC |
2007 | C<VMS::DCLsym> has been upgraded from version 1.03 to 1.05. |
2008 | ||
2009 | Two bugs have been fixed [perl #84086]: | |
2010 | ||
2011 | The symbol table name was lost when tying a hash, due to a thinko in | |
2012 | C<TIEHASH>. The result was that all tied hashes interacted with the | |
2013 | local symbol table. | |
2014 | ||
2015 | Unless a symbol table name had been explicitly specified in the call | |
2016 | to the constructor, querying the special key ':LOCAL' failed to | |
2017 | identify objects connected to the local symbol table. | |
2018 | ||
2019 | =item * | |
2020 | ||
2021 | C<Win32> has been upgraded from version 0.39 to 0.44. | |
2022 | ||
1984204c FC |
2023 | This release has several new functions: C<Win32::GetSystemMetrics>, |
2024 | C<Win32::GetProductInfo>, C<Win32::GetOSDisplayName>. | |
5076a392 | 2025 | |
1984204c FC |
2026 | The names returned by C<Win32::GetOSName> and C<Win32::GetOSDisplayName> |
2027 | have been corrected. | |
5076a392 | 2028 | |
5076a392 FC |
2029 | =back |
2030 | ||
5076a392 FC |
2031 | =head2 Removed Modules and Pragmata |
2032 | ||
2033 | The following modules have been removed from the core distribution, and if | |
2034 | needed should be installed from CPAN instead. | |
2035 | ||
2036 | =over | |
2037 | ||
4f978a3b FR |
2038 | =item * |
2039 | ||
2040 | C<Class::ISA> has been removed from the Perl core. Prior version was 0.36. | |
5076a392 | 2041 | |
4f978a3b FR |
2042 | =item * |
2043 | ||
2044 | C<Pod::Plainer> has been removed from the Perl core. Prior version was 1.02. | |
2045 | ||
2046 | =item * | |
5076a392 | 2047 | |
4f978a3b | 2048 | C<Switch> has been removed from the Perl core. Prior version was 2.16. |
5076a392 FC |
2049 | |
2050 | =back | |
2051 | ||
2052 | The removal of C<Shell> has been deferred until after 5.14, as the | |
2053 | implementation of C<Shell> shipped with 5.12.0 did not correctly issue the | |
2054 | warning that it was to be removed from core. | |
2055 | ||
2056 | =head1 Documentation | |
2057 | ||
5076a392 FC |
2058 | =head2 New Documentation |
2059 | ||
41e29def | 2060 | =head3 L<perlgpl> |
5076a392 FC |
2061 | |
2062 | L<perlgpl> has been updated to contain GPL version 1, as is included in the | |
cdc10f43 | 2063 | F<README> distributed with perl (5.12.1). |
5076a392 | 2064 | |
41e29def | 2065 | =head3 Perl 5.12.x delta files |
5076a392 | 2066 | |
41e29def FC |
2067 | The perldelta files for Perl 5.12.1 to 5.12.3 have been added from the |
2068 | maintenance branch: L<perl5121delta>, L<perl5122delta>, L<perl5123delta>. | |
5076a392 FC |
2069 | |
2070 | =head3 L<perlpodstyle> | |
2071 | ||
2072 | New style guide for POD documentation, | |
2073 | split mostly from the NOTES section of the pod2man man page. | |
2074 | ||
41e29def FC |
2075 | =head3 L<perlsource>, L<perlinterp>, L<perlhacktut>, and L<perlhacktips> |
2076 | ||
2077 | See L</L<perlhack> and perlrepository revamp>, below. | |
5076a392 FC |
2078 | |
2079 | =head2 Changes to Existing Documentation | |
2080 | ||
41e29def | 2081 | =head3 L<perlmodlib> is now complete |
4ed2cea4 FC |
2082 | |
2083 | The perlmodlib page that came with Perl 5.12.0 was missing a lot of | |
2084 | modules, due to a bug in the script that generates the list. This has been | |
cdc10f43 | 2085 | fixed [perl #74332] (5.12.1). |
4ed2cea4 | 2086 | |
41e29def | 2087 | =head3 Replace wrong tr/// table in L<perlebcdic> |
5076a392 | 2088 | |
41e29def | 2089 | L<perlebcdic> contains a helpful table to use in tr/// to convert |
5076a392 FC |
2090 | between EBCDIC and Latin1/ASCII. Unfortunately, the table was the |
2091 | inverse of the one it describes, though the code that used the table | |
2092 | worked correctly for the specific example given. | |
2093 | ||
2094 | The table has been changed to its inverse, and the sample code changed | |
2095 | to correspond, as this is easier for the person trying to follow the | |
2096 | instructions since deriving the old table is somewhat more complicated. | |
2097 | ||
2098 | The table has also been changed to hex from octal, as that is more the norm | |
2099 | these days, and the recipes in the pod altered to print out leading | |
41e29def | 2100 | zeros to make all the values the same length. |
5076a392 | 2101 | |
41e29def | 2102 | =head3 Tricks for user-defined casing |
5076a392 | 2103 | |
41e29def FC |
2104 | L<perlunicode> now contains an explanation of how to override, mangle |
2105 | and otherwise tweak the way perl handles upper-, lower- and other-case | |
2106 | conversions on Unicode data, and how to provide scoped changes to alter | |
2107 | one's own code's behaviour without stomping on anybody else. | |
5076a392 FC |
2108 | |
2109 | =head3 INSTALL explicitly states the requirement for C89 | |
2110 | ||
d430b8e7 FC |
2111 | This was already true but it's now Officially Stated For The Record |
2112 | (5.12.2). | |
5076a392 | 2113 | |
41e29def | 2114 | =head3 Explanation of C<\xI<HH>> and C<\oI<OOO>> escapes |
5076a392 | 2115 | |
41e29def FC |
2116 | L<perlop> has been updated with more detailed explanation of these two |
2117 | character escapes. | |
5076a392 | 2118 | |
41e29def | 2119 | =head3 C<-0I<NNN>> switch |
5076a392 | 2120 | |
41e29def | 2121 | In L<perlrun>, the behavior of the C<-0NNN> switch for C<-0400> or higher |
d430b8e7 | 2122 | has been clarified (5.12.2). |
5076a392 | 2123 | |
cdc10f43 FC |
2124 | =head3 Maintenance policy |
2125 | ||
2126 | L<perlpolicy> now contains the policy on what patches are acceptable for | |
2127 | maintenance branches (5.12.1). | |
2128 | ||
41e29def | 2129 | =head3 Deprecation policy |
5076a392 | 2130 | |
41e29def | 2131 | L<perlpolicy> now contains the policy on compatibility and deprecation |
d430b8e7 | 2132 | along with definitions of terms like "deprecation" (5.12.2). |
5076a392 | 2133 | |
41e29def | 2134 | =head3 New descriptions in L<perldiag> |
5076a392 FC |
2135 | |
2136 | The following existing diagnostics are now documented: | |
2137 | ||
2138 | =over 4 | |
2139 | ||
2140 | =item * | |
2141 | ||
2142 | L<Ambiguous use of %c resolved as operator %c|perldiag/"Ambiguous use of %c resolved as operator %c"> | |
2143 | ||
2144 | =item * | |
2145 | ||
2146 | L<Ambiguous use of %c{%s} resolved to %c%s|perldiag/"Ambiguous use of %c{%s} resolved to %c%s"> | |
2147 | ||
2148 | =item * | |
2149 | ||
2150 | L<Ambiguous use of %c{%s%s} resolved to %c%s%s|perldiag/"Ambiguous use of %c{%s%s} resolved to %c%s%s"> | |
2151 | ||
2152 | =item * | |
2153 | ||
2154 | L<Ambiguous use of -%s resolved as -&%s()|perldiag/"Ambiguous use of -%s resolved as -&%s()"> | |
2155 | ||
2156 | =item * | |
2157 | ||
2158 | L<Invalid strict version format (%s)|perldiag/"Invalid strict version format (%s)"> | |
2159 | ||
2160 | =item * | |
2161 | ||
2162 | L<Invalid version format (%s)|perldiag/"Invalid version format (%s)"> | |
2163 | ||
2164 | =item * | |
2165 | ||
2166 | L<Invalid version object|perldiag/"Invalid version object"> | |
2167 | ||
2168 | =back | |
2169 | ||
5076a392 FC |
2170 | =head3 L<perlbook> |
2171 | ||
41e29def | 2172 | L<perlbook> has been expanded to cover many more popular books. |
5076a392 | 2173 | |
41e29def | 2174 | =head3 C<SvTRUE> macro |
5076a392 | 2175 | |
41e29def FC |
2176 | The documentation for the C<SvTRUE> macro in |
2177 | L<perlapi> was simply wrong in stating that | |
5076a392 FC |
2178 | get-magic is not processed. It has been corrected. |
2179 | ||
41e29def | 2180 | =head3 L<perlvar> revamp |
5076a392 | 2181 | |
41e29def | 2182 | L<perlvar> reorders the variables and groups them by topic. Each variable |
5076a392 | 2183 | introduced after Perl 5.000 notes the first version in which it is |
41e29def | 2184 | available. L<perlvar> also has a new section for deprecated variables to |
5076a392 FC |
2185 | note when they were removed. |
2186 | ||
41e29def | 2187 | =head3 Array and hash slices in scalar context |
5076a392 | 2188 | |
41e29def | 2189 | These are now documented in L<perldata>. |
5076a392 | 2190 | |
41e29def | 2191 | =head3 C<use locale> and formats |
5076a392 FC |
2192 | |
2193 | L<perlform> and L<perllocale> have been corrected to state that | |
2194 | C<use locale> affects formats. | |
2195 | ||
5076a392 FC |
2196 | =head3 L<overload> |
2197 | ||
5076a392 FC |
2198 | L<overload>'s documentation has practically undergone a rewrite. It |
2199 | is now much more straightforward and clear. | |
2200 | ||
41e29def | 2201 | =head3 L<perlhack> and perlrepository revamp |
5076a392 FC |
2202 | |
2203 | The L<perlhack> and perlrepository documents have been heavily edited and | |
2204 | split up into several new documents. | |
2205 | ||
2206 | The L<perlhack> document is now much shorter, and focuses on the Perl 5 | |
2207 | development process and submitting patches to Perl. The technical content has | |
2208 | been moved to several new documents, L<perlsource>, L<perlinterp>, | |
2209 | L<perlhacktut>, and L<perlhacktips>. This technical content has only been | |
2210 | lightly edited. | |
2211 | ||
2212 | The perlrepository document has been renamed to L<perlgit>. This new document | |
2213 | is just a how-to on using git with the Perl source code. Any other content | |
2214 | that used to be in perlrepository has been moved to perlhack. | |
2215 | ||
41e29def | 2216 | =head3 Time::Piece examples |
5076a392 FC |
2217 | |
2218 | Examples in L<perlfaq4> have been updated to show the use of | |
41e29def | 2219 | L<Time::Piece>. |
5076a392 FC |
2220 | |
2221 | =head1 Diagnostics | |
2222 | ||
2223 | The following additions or changes have been made to diagnostic output, | |
2224 | including warnings and fatal error messages. For the complete list of | |
2225 | diagnostic messages, see L<perldiag>. | |
2226 | ||
2227 | =head2 New Diagnostics | |
2228 | ||
a593b319 FC |
2229 | =head3 New Errors |
2230 | ||
5076a392 FC |
2231 | =over |
2232 | ||
a593b319 | 2233 | =item Closure prototype called |
5076a392 | 2234 | |
a593b319 FC |
2235 | This error occurs when a subroutine reference passed to an attribute |
2236 | handler is called, if the subroutine is a closure [perl #68560]. | |
5076a392 | 2237 | |
a593b319 | 2238 | =item Insecure user-defined property %s |
5076a392 | 2239 | |
a593b319 FC |
2240 | Perl detected tainted data when trying to compile a regular |
2241 | expression that contains a call to a user-defined character property | |
2242 | function, i.e. C<\p{IsFoo}> or C<\p{InFoo}>. | |
2243 | See L<perlunicode/User-Defined Character Properties> and L<perlsec>. | |
5076a392 | 2244 | |
a593b319 | 2245 | =item panic: gp_free failed to free glob pointer - something is repeatedly re-creating entries |
5076a392 | 2246 | |
a593b319 FC |
2247 | This new error is triggered if a destructor called on an object in a |
2248 | typeglob that is being freed creates a new typeglob entry containing an | |
2249 | object with a destructor that creates a new entry containing an object.... | |
5076a392 | 2250 | |
a593b319 | 2251 | =item Parsing code internal error (%s) |
5076a392 | 2252 | |
a593b319 FC |
2253 | This new fatal error is produced when parsing |
2254 | code supplied by an extension violates the | |
2255 | parser's API in a detectable way. | |
5076a392 | 2256 | |
a593b319 | 2257 | =item refcnt: fd %d%s |
5076a392 | 2258 | |
a593b319 FC |
2259 | This new error only occurs if a internal consistency check fails when a |
2260 | pipe is about to be closed. | |
5076a392 | 2261 | |
a593b319 | 2262 | =item Regexp modifier "/%c" may not appear twice |
5076a392 | 2263 | |
a593b319 FC |
2264 | The regular expression pattern has one of the |
2265 | mutually exclusive modifiers repeated. | |
5076a392 | 2266 | |
a593b319 | 2267 | =item Regexp modifiers "/%c" and "/%c" are mutually exclusive |
5076a392 | 2268 | |
a593b319 FC |
2269 | The regular expression pattern has more than one of the mutually |
2270 | exclusive modifiers. | |
5076a392 | 2271 | |
a593b319 | 2272 | =item Using !~ with %s doesn't make sense |
5076a392 | 2273 | |
a593b319 | 2274 | This error occurs when C<!~> is used with C<s///r> or C<y///r>. |
5076a392 | 2275 | |
a593b319 | 2276 | =back |
5076a392 | 2277 | |
a593b319 | 2278 | =head3 New Warnings |
5076a392 | 2279 | |
a593b319 | 2280 | =over |
5076a392 | 2281 | |
a593b319 | 2282 | =item "\b{" is deprecated; use "\b\{" instead |
5076a392 | 2283 | |
a593b319 | 2284 | =item "\B{" is deprecated; use "\B\{" instead |
5076a392 | 2285 | |
a593b319 FC |
2286 | Use of an unescaped "{" immediately following a C<\b> or C<\B> is now |
2287 | deprecated so as to reserve its use for Perl itself in a future release. | |
5076a392 | 2288 | |
a593b319 | 2289 | =item Operation "%s" returns its argument for ... |
5076a392 | 2290 | |
a593b319 FC |
2291 | Performing an operation requiring Unicode semantics (such as case-folding) |
2292 | on a Unicode surrogate or a non-Unicode character now triggers a warning: | |
2293 | 'Operation "%s" returns its argument for ...'. | |
5076a392 | 2294 | |
a593b319 FC |
2295 | =item Use of qw(...) as parentheses is deprecated |
2296 | ||
2297 | See L</"Use of qw(...) as parentheses">, above, for details. | |
5076a392 FC |
2298 | |
2299 | =back | |
2300 | ||
2301 | =head2 Changes to Existing Diagnostics | |
2302 | ||
2303 | =over 4 | |
2304 | ||
2305 | =item * | |
2306 | ||
4ed2cea4 FC |
2307 | The "Variable $foo is not imported" warning that precedes a |
2308 | C<strict 'vars'> error has now been assigned the "misc" category, so that | |
2309 | C<no warnings> will suppress it [perl #73712]. | |
2310 | ||
2311 | =item * | |
2312 | ||
5076a392 FC |
2313 | C<warn> and C<die> now produce 'Wide character' warnings when fed a |
2314 | character outside the byte range if STDERR is a byte-sized handle. | |
2315 | ||
2316 | =item * | |
2317 | ||
2318 | The 'Layer does not match this perl' error message has been replaced with | |
a593b319 | 2319 | these more helpful messages [perl #73754]: |
5076a392 FC |
2320 | |
2321 | =over 4 | |
2322 | ||
2323 | =item * | |
2324 | ||
2325 | PerlIO layer function table size (%d) does not match size expected by this | |
2326 | perl (%d) | |
2327 | ||
2328 | =item * | |
2329 | ||
2330 | PerlIO layer instance size (%d) does not match size expected by this perl | |
2331 | (%d) | |
2332 | ||
2333 | =back | |
2334 | ||
5076a392 FC |
2335 | =item * |
2336 | ||
2337 | The "Found = in conditional" warning that is emitted when a constant is | |
2338 | assigned to a variable in a condition is now withheld if the constant is | |
2339 | actually a subroutine or one generated by C<use constant>, since the value | |
2340 | of the constant may not be known at the time the program is written | |
2341 | [perl #77762]. | |
2342 | ||
2343 | =item * | |
2344 | ||
2345 | Previously, if none of the C<gethostbyaddr>, C<gethostbyname> and | |
2346 | C<gethostent> functions were implemented on a given platform, they would | |
2347 | all die with the message 'Unsupported socket function "gethostent" called', | |
2348 | with analogous messages for C<getnet*> and C<getserv*>. This has been | |
2349 | corrected. | |
2350 | ||
2351 | =item * | |
2352 | ||
a593b319 FC |
2353 | The warning message about unrecognized regular expression escapes passed |
2354 | through has been changed to include any literal '{' following the | |
2355 | two-character escape. E.g., "\q{" is now emitted instead of "\q". | |
5076a392 FC |
2356 | |
2357 | =back | |
2358 | ||
2359 | =head1 Utility Changes | |
2360 | ||
0b88cc74 | 2361 | =head3 L<perlbug> |
5076a392 FC |
2362 | |
2363 | =over 4 | |
2364 | ||
2365 | =item * | |
2366 | ||
0b88cc74 FC |
2367 | L<perlbug> now looks in the EMAIL environment variable for a return address |
2368 | if the REPLY-TO and REPLYTO variables are empty. | |
5076a392 FC |
2369 | |
2370 | =item * | |
2371 | ||
0b88cc74 FC |
2372 | L<perlbug> did not previously generate a From: header, potentially |
2373 | resulting in dropped mail. Now it does include that header. | |
5076a392 FC |
2374 | |
2375 | =item * | |
2376 | ||
0b88cc74 | 2377 | The user's address is now used as the return-path. |
4ed2cea4 | 2378 | |
0b88cc74 FC |
2379 | Many systems these days don't have a valid Internet domain name and |
2380 | perlbug@perl.org does not accept email with a return-path that does | |
2381 | not resolve. So the user's address is now passed to sendmail so it's | |
2382 | less likely to get stuck in a mail queue somewhere [perl #82996]. | |
5076a392 | 2383 | |
2c389f6c FC |
2384 | =item * |
2385 | ||
d430b8e7 FC |
2386 | L<perlbug> now always gives the reporter a chance to change the email |
2387 | address it guesses for them (5.12.2). | |
2388 | ||
2389 | =item * | |
2390 | ||
2391 | L<perlbug> should no longer warn about uninitialized values when using the C<-d> | |
2392 | and C<-v> options (5.12.2). | |
2c389f6c | 2393 | |
5076a392 FC |
2394 | =back |
2395 | ||
0b88cc74 | 2396 | =head3 L<perl5db.pl> |
5076a392 | 2397 | |
0b88cc74 | 2398 | =over |
5076a392 FC |
2399 | |
2400 | =item * | |
2401 | ||
0b88cc74 FC |
2402 | The remote terminal works after forking and spawns new sessions - one |
2403 | for each forked process. | |
5076a392 FC |
2404 | |
2405 | =back | |
2406 | ||
0b88cc74 | 2407 | =head3 L<ptargrep> |
5076a392 FC |
2408 | |
2409 | =over 4 | |
2410 | ||
2411 | =item * | |
2412 | ||
0b88cc74 FC |
2413 | L<ptargrep> is a new utility to apply pattern matching to the contents of |
2414 | files in a tar archive. It comes with C<Archive::Tar>. | |
5076a392 FC |
2415 | |
2416 | =back | |
2417 | ||
2418 | =head1 Configuration and Compilation | |
2419 | ||
61752d82 FC |
2420 | See also L</"Naming fixes in Policy_sh.SH may invalidate Policy.sh">, |
2421 | above. | |
2422 | ||
5076a392 FC |
2423 | =over 4 |
2424 | ||
2425 | =item * | |
2426 | ||
87595b22 FC |
2427 | CCINCDIR and CCLIBDIR for the mingw64 |
2428 | cross-compiler are now correctly under | |
5076a392 FC |
2429 | $(CCHOME)\mingw\include and \lib rather than immediately below $(CCHOME). |
2430 | ||
5076a392 FC |
2431 | This means the 'incpath', 'libpth', 'ldflags', 'lddlflags' and |
2432 | 'ldflags_nolargefiles' values in Config.pm and Config_heavy.pl are now | |
87595b22 | 2433 | set correctly. |
5076a392 FC |
2434 | |
2435 | =item * | |
2436 | ||
87595b22 FC |
2437 | 'make test.valgrind' has been adjusted to account for cpan/dist/ext |
2438 | separation. | |
5076a392 FC |
2439 | |
2440 | =item * | |
2441 | ||
2442 | On compilers that support it, C<-Wwrite-strings> is now added to cflags by | |
2443 | default. | |
2444 | ||
2445 | =item * | |
2446 | ||
2447 | The C<Encode> module can now (once again) be included in a static Perl | |
2448 | build. The special-case handling for this situation got broken in Perl | |
2449 | 5.11.0, and has now been repaired. | |
2450 | ||
1e463951 FC |
2451 | =item * |
2452 | ||
2453 | The previous default size of a PerlIO buffer (4096 bytes) has been increased | |
2454 | to the larger of 8192 bytes and your local BUFSIZ. Benchmarks show that doubling | |
2455 | this decade-old default increases read and write performance in the neighborhood | |
2456 | of 25% to 50% when using the default layers of perlio on top of unix. To choose | |
2457 | a non-default size, such as to get back the old value or to obtain an even | |
2458 | larger value, configure with: | |
2459 | ||
2460 | ./Configure -Accflags=-DPERLIOBUF_DEFAULT_BUFSIZ=N | |
2461 | ||
2462 | where N is the desired size in bytes; it should probably be a multiple of | |
2463 | your page size. | |
2464 | ||
d430b8e7 FC |
2465 | =item * |
2466 | ||
2467 | An "incompatible operand types" error in ternary expressions when building | |
2468 | with C<clang> has been fixed (5.12.2). | |
2469 | ||
2470 | =item * | |
2471 | ||
2472 | Perl now skips setuid C<File::Copy> tests on partitions it detects to be mounted | |
2473 | as C<nosuid> (5.12.2). | |
2474 | ||
5076a392 FC |
2475 | =back |
2476 | ||
5076a392 FC |
2477 | =head1 Platform Support |
2478 | ||
5076a392 FC |
2479 | =head2 New Platforms |
2480 | ||
5076a392 FC |
2481 | =over 4 |
2482 | ||
2483 | =item AIX | |
2484 | ||
cdc10f43 | 2485 | Perl now builds on AIX 4.2 (5.12.1). |
5076a392 FC |
2486 | |
2487 | =back | |
2488 | ||
2489 | =head2 Discontinued Platforms | |
2490 | ||
2491 | =over 4 | |
2492 | ||
5076a392 FC |
2493 | =item Apollo DomainOS |
2494 | ||
2495 | The last vestiges of support for this platform have been excised from the | |
2496 | Perl distribution. It was officially discontinued in version 5.12.0. It had | |
2497 | not worked for years before that. | |
2498 | ||
2499 | =item MacOS Classic | |
2500 | ||
2501 | The last vestiges of support for this platform have been excised from the | |
2502 | Perl distribution. It was officially discontinued in an earlier version. | |
2503 | ||
2504 | =back | |
2505 | ||
2506 | =head2 Platform-Specific Notes | |
2507 | ||
d430b8e7 FC |
2508 | =head3 AIX |
2509 | ||
2510 | =over | |
2511 | ||
2512 | =item * | |
2513 | ||
2514 | F<README.aix> has been updated with information about the XL C/C++ V11 compiler | |
2515 | suite (5.12.2). | |
2516 | ||
2517 | =back | |
2518 | ||
2519 | =head3 ARM | |
2520 | ||
2521 | =over | |
2522 | ||
2523 | =item * | |
2524 | ||
2525 | The C<d_u32align> configuration probe on ARM has been fixed (5.12.2). | |
2526 | ||
2527 | =back | |
2528 | ||
554003a2 | 2529 | =head3 Cygwin |
5076a392 FC |
2530 | |
2531 | =over 4 | |
2532 | ||
2533 | =item * | |
2534 | ||
554003a2 | 2535 | MakeMaker has been updated to build man pages on cygwin. |
5076a392 FC |
2536 | |
2537 | =item * | |
2538 | ||
554003a2 FC |
2539 | Improved rebase behaviour |
2540 | ||
2541 | If a dll is updated on cygwin the old imagebase address is reused. | |
2542 | This solves most rebase errors, especially when updating on core dll's. | |
2543 | See L<http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README> for more information. | |
5076a392 FC |
2544 | |
2545 | =item * | |
2546 | ||
554003a2 | 2547 | Support for the standard cygwin dll prefix, which is e.g. needed for FFI's |
5076a392 FC |
2548 | |
2549 | =item * | |
2550 | ||
554003a2 | 2551 | Updated build hints file |
5076a392 FC |
2552 | |
2553 | =back | |
2554 | ||
cdc10f43 FC |
2555 | =head3 FreeBSD 7 |
2556 | ||
2557 | =over | |
2558 | ||
2559 | =item * | |
2560 | ||
2561 | FreeBSD 7 no longer contains F</usr/bin/objformat>. At build time, | |
2562 | Perl now skips the F<objformat> check for versions 7 and higher and | |
2563 | assumes ELF (5.12.1). | |
2564 | ||
2565 | =back | |
2566 | ||
2567 | =head3 HP-UX | |
2568 | ||
2569 | =over | |
2570 | ||
2571 | =item * | |
2572 | ||
2573 | Perl now allows -Duse64bitint without promoting to use64bitall on HP-UX | |
2574 | (5.12.1). | |
2575 | ||
2576 | =back | |
2577 | ||
554003a2 | 2578 | =head3 IRIX |
5076a392 FC |
2579 | |
2580 | Conversion of strings to floating-point numbers is now more accurate on | |
2581 | IRIX systems [perl #32380]. | |
2582 | ||
554003a2 | 2583 | =head3 Mac OS X |
5076a392 FC |
2584 | |
2585 | Early versions of Mac OS X (Darwin) had buggy implementations of the | |
2586 | C<setregid>, C<setreuid>, C<setrgid> and C<setruid> functions, so perl | |
2587 | would pretend they did not exist. | |
2588 | ||
2589 | These functions are now recognised on Mac OS 10.5 (Leopard; Darwin 9) and | |
2590 | higher, as they have been fixed [perl #72990]. | |
2591 | ||
554003a2 | 2592 | =head3 MirBSD |
5076a392 | 2593 | |
554003a2 FC |
2594 | Previously if you built perl with a shared libperl.so on MirBSD (the |
2595 | default config), it would work up to the installation; however, once | |
2596 | installed, it would be unable to find libperl. So path handling is now | |
2597 | treated as in the other BSD dialects. | |
5076a392 | 2598 | |
554003a2 | 2599 | =head3 NetBSD |
5076a392 | 2600 | |
554003a2 FC |
2601 | The NetBSD hints file has been changed to make the system's malloc the |
2602 | default. | |
5076a392 | 2603 | |
554003a2 | 2604 | =head3 Recent OpenBSDs now use perl's malloc |
5076a392 | 2605 | |
554003a2 FC |
2606 | OpenBSD E<gt> 3.7 has a new malloc implementation which is mmap-based |
2607 | and as such can release memory back to the OS; however, perl's use of | |
2608 | this malloc causes a substantial slowdown so we now default to using | |
2609 | perl's malloc instead [perl #75742]. | |
5076a392 | 2610 | |
554003a2 | 2611 | =head3 OpenVOS |
5076a392 | 2612 | |
554003a2 | 2613 | perl now builds again with OpenVOS (formerly known as Stratus VOS) |
5a553547 | 2614 | [perl #78132] (5.12.3). |
5076a392 | 2615 | |
554003a2 | 2616 | =head3 Solaris |
5076a392 | 2617 | |
554003a2 | 2618 | DTrace is now supported on Solaris. There used to be build failures, but |
5a553547 | 2619 | these have been fixed [perl #73630] (5.12.3). |
5076a392 | 2620 | |
554003a2 | 2621 | =head3 VMS |
5076a392 FC |
2622 | |
2623 | =over | |
2624 | ||
2625 | =item * | |
2626 | ||
cdc10f43 FC |
2627 | It's now possible to build extensions on older (pre 7.3-2) VMS systems. |
2628 | ||
2629 | DCL symbol length was limited to 1K up until about seven years or | |
2630 | so ago, but there was no particularly deep reason to prevent those | |
2631 | older systems from configuring and building Perl (5.12.1). | |
2632 | ||
2633 | =item * | |
2634 | ||
2635 | We fixed the previously-broken C<-Uuseperlio> build on VMS. | |
2636 | ||
2637 | We were checking a variable that doesn't exist in the non-default | |
2638 | case of disabling perlio. Now we only look at it when it exists (5.12.1). | |
2639 | ||
2640 | =item * | |
2641 | ||
2642 | We fixed the -Uuseperlio command-line option in configure.com. | |
2643 | ||
2644 | Formerly it only worked if you went through all the questions | |
2645 | interactively and explicitly answered no (5.12.1). | |
2646 | ||
2647 | =item * | |
2648 | ||
554003a2 | 2649 | C<PerlIOUnix_open> now honours the default permissions on VMS. |
5076a392 | 2650 | |
554003a2 FC |
2651 | When C<perlio> became the default and C<unixio> became the default bottom layer, |
2652 | the most common path for creating files from Perl became C<PerlIOUnix_open>, | |
2653 | which has always explicitly used C<0666> as the permission mask. | |
5076a392 | 2654 | |
554003a2 FC |
2655 | To avoid this, C<0777> is now passed as the permissions to C<open()>. In the |
2656 | VMS CRTL, C<0777> has a special meaning over and above intersecting with the | |
2657 | current umask; specifically, it allows Unix syscalls to preserve native default | |
5a553547 FC |
2658 | permissions (5.12.3). |
2659 | ||
2660 | =item * | |
2661 | ||
2662 | Spurious record boundaries are no longer | |
2663 | introduced by the PerlIO layer during output (5.12.3). | |
5076a392 FC |
2664 | |
2665 | =item * | |
2666 | ||
554003a2 FC |
2667 | The shortening of symbols longer than 31 characters in the C sources is |
2668 | now done by the compiler rather than by xsubpp (which could only do so | |
2669 | for generated symbols in XS code). | |
5076a392 FC |
2670 | |
2671 | =item * | |
2672 | ||
554003a2 FC |
2673 | Record-oriented files (record format variable or variable with fixed control) |
2674 | opened for write by the perlio layer will now be line-buffered to prevent the | |
2675 | introduction of spurious line breaks whenever the perlio buffer fills up. | |
5076a392 | 2676 | |
d430b8e7 FC |
2677 | =item * |
2678 | ||
2679 | F<git_version.h> is now installed on VMS. This was an oversight in v5.12.0 which | |
2680 | caused some extensions to fail to build (5.12.2). | |
2681 | ||
2682 | =item * | |
2683 | ||
2684 | Several memory leaks in L<stat()|perlfunc/"stat FILEHANDLE"> have been fixed (5.12.2). | |
2685 | ||
2686 | =item * | |
2687 | ||
2688 | A memory leak in C<Perl_rename()> due to a double allocation has been | |
2689 | fixed (5.12.2). | |
2690 | ||
2691 | =item * | |
2692 | ||
2693 | A memory leak in C<vms_fid_to_name()> (used by C<realpath()> and | |
2694 | C<realname()>) has been fixed (5.12.2). | |
2695 | ||
5076a392 FC |
2696 | =back |
2697 | ||
554003a2 | 2698 | =head3 Windows |
5076a392 | 2699 | |
5a1f7719 FC |
2700 | See also L</"fork() emulation will not wait for signalled children"> and |
2701 | L</"Perl source code is read in text mode on Windows">, above. | |
2702 | ||
5076a392 FC |
2703 | =over 4 |
2704 | ||
2705 | =item * | |
2706 | ||
554003a2 | 2707 | Fixed build process for SDK2003SP1 compilers. |
5076a392 | 2708 | |
554003a2 | 2709 | =item * |
5076a392 | 2710 | |
01b1a9e4 FC |
2711 | Compilation with Visual Studio 2010 is now supported. |
2712 | ||
2713 | =item * | |
2714 | ||
554003a2 FC |
2715 | When using old 32-bit compilers, the define C<_USE_32BIT_TIME_T> will now |
2716 | be set in C<$Config{ccflags}>. This improves portability when compiling | |
2717 | XS extensions using new compilers, but for a perl compiled with old 32-bit | |
2718 | compilers. | |
5076a392 FC |
2719 | |
2720 | =item * | |
2721 | ||
554003a2 FC |
2722 | C<$Config{gccversion}> is now set correctly when perl is built using the |
2723 | mingw64 compiler from L<http://mingw64.org> [perl #73754]. | |
5076a392 | 2724 | |
554003a2 FC |
2725 | =item * |
2726 | ||
d430b8e7 FC |
2727 | When building Perl with the mingw64 x64 cross-compiler C<incpath>, |
2728 | C<libpth>, C<ldflags>, C<lddlflags> and C<ldflags_nolargefiles> values | |
2729 | in F<Config.pm> and F<Config_heavy.pl> were not previously being set | |
2730 | correctly because, with that compiler, the include and lib directories | |
2731 | are not immediately below C<$(CCHOME)> (5.12.2). | |
2732 | ||
2733 | =item * | |
2734 | ||
554003a2 FC |
2735 | The build process proceeds more smoothly with mingw and dmake when |
2736 | F<C:\MSYS\bin> is in the PATH, due to a C<Cwd> fix. | |
5076a392 FC |
2737 | |
2738 | =item * | |
2739 | ||
554003a2 FC |
2740 | Support for building with Visual C++ 2010 is now underway, but is not yet |
2741 | complete. See F<README.win32> or L<perlwin32> for more details. | |
5076a392 | 2742 | |
554003a2 FC |
2743 | =item * |
2744 | ||
2745 | The option to use an externally-supplied C<crypt()>, or to build with no | |
2746 | C<crypt()> at all, has been removed. Perl supplies its own C<crypt()> | |
2747 | implementation for Windows, and the political situation that required | |
2748 | this part of the distribution to sometimes be omitted is long gone. | |
5076a392 FC |
2749 | |
2750 | =back | |
2751 | ||
2752 | =head1 Internal Changes | |
2753 | ||
1e463951 | 2754 | =head2 New APIs |
5076a392 | 2755 | |
1e463951 | 2756 | =head3 CLONE_PARAMS structure added to ease correct thread creation |
5076a392 | 2757 | |
1e463951 FC |
2758 | Modules that create threads should now create C<CLONE_PARAMS> structures |
2759 | by calling the new function C<Perl_clone_params_new()>, and free them with | |
2760 | C<Perl_clone_params_del()>. This will ensure compatibility with any future | |
2761 | changes to the internals of the C<CLONE_PARAMS> structure layout, and that | |
2762 | it is correctly allocated and initialised. | |
5076a392 | 2763 | |
1e463951 | 2764 | =head3 New parsing functions |
5076a392 | 2765 | |
1e463951 FC |
2766 | Several functions have been added for parsing statements or multiple |
2767 | statements: | |
5076a392 | 2768 | |
1e463951 | 2769 | =over |
5076a392 FC |
2770 | |
2771 | =item * | |
2772 | ||
1e463951 | 2773 | C<parse_fullstmt> parses a complete Perl statement. |
5076a392 FC |
2774 | |
2775 | =item * | |
2776 | ||
1e463951 FC |
2777 | C<parse_stmtseq> parses a sequence of statements, up |
2778 | to closing brace or EOF. | |
5076a392 FC |
2779 | |
2780 | =item * | |
2781 | ||
1e463951 | 2782 | C<parse_block> parses a block [perl #78222]. |
5076a392 FC |
2783 | |
2784 | =item * | |
2785 | ||
1e463951 FC |
2786 | C<parse_barestmt> parses a statement |
2787 | without a label. | |
5076a392 FC |
2788 | |
2789 | =item * | |
2790 | ||
1e463951 | 2791 | C<parse_label> parses a statement label, separate from statements. |
5076a392 | 2792 | |
1e463951 | 2793 | =back |
5076a392 | 2794 | |
1e463951 FC |
2795 | The |
2796 | L<C<parse_fullexpr()>|perlapi/parse_fullexpr>, | |
2797 | L<C<parse_listexpr()>|perlapi/parse_listexpr>, | |
2798 | L<C<parse_termexpr()>|perlapi/parse_termexpr>, and | |
2799 | L<C<parse_arithexpr()>|perlapi/parse_arithexpr> | |
2800 | functions have been added to the API. They perform | |
2801 | recursive-descent parsing of expressions at various precedence levels. | |
2802 | They are expected to be used by syntax plugins. | |
5076a392 | 2803 | |
1e463951 | 2804 | See L<perlapi> for details. |
5076a392 | 2805 | |
1e463951 | 2806 | =head3 Hints hash API |
5076a392 | 2807 | |
1e463951 FC |
2808 | A new C API for introspecting the hinthash C<%^H> at runtime has been |
2809 | added. See C<cop_hints_2hv>, C<cop_hints_fetchpvn>, C<cop_hints_fetchpvs>, | |
2810 | C<cop_hints_fetchsv>, and C<hv_copy_hints_hv> in L<perlapi> for details. | |
5076a392 | 2811 | |
1e463951 FC |
2812 | A new, experimental API has been added for accessing the internal |
2813 | structure that Perl uses for C<%^H>. See the functions beginning with | |
2814 | C<cophh_> in L<perlapi>. | |
5076a392 | 2815 | |
1e463951 | 2816 | =head3 C interface to C<caller()> |
5076a392 | 2817 | |
1e463951 FC |
2818 | The C<caller_cx> function has been added as an XSUB-writer's equivalent of |
2819 | C<caller()>. See L<perlapi> for details. | |
5076a392 | 2820 | |
1e463951 | 2821 | =head3 Custom per-subroutine check hooks |
5076a392 | 2822 | |
1e463951 FC |
2823 | XS code in an extension module can now annotate a subroutine (whether |
2824 | implemented in XS or in Perl) so that nominated XS code will be called | |
2825 | at compile time (specifically as part of op checking) to change the op | |
2826 | tree of that subroutine. The compile-time check function (supplied by | |
2827 | the extension module) can implement argument processing that can't be | |
2828 | expressed as a prototype, generate customised compile-time warnings, | |
2829 | perform constant folding for a pure function, inline a subroutine | |
2830 | consisting of sufficiently simple ops, replace the whole call with a | |
2831 | custom op, and so on. This was previously all possible by hooking the | |
2832 | C<entersub> op checker, but the new mechanism makes it easy to tie the | |
2833 | hook to a specific subroutine. See L<perlapi/cv_set_call_checker>. | |
5076a392 | 2834 | |
1e463951 FC |
2835 | To help in writing custom check hooks, several subtasks within standard |
2836 | C<entersub> op checking have been separated out and exposed in the API. | |
5076a392 | 2837 | |
1e463951 | 2838 | =head3 Improved support for custom OPs |
5076a392 | 2839 | |
1e463951 FC |
2840 | Custom ops can now be registered with the new C<custom_op_register> C |
2841 | function and the C<XOP> structure. This will make it easier to add new | |
2842 | properties of custom ops in the future. Two new properties have been added | |
2843 | already, C<xop_class> and C<xop_peep>. | |
5076a392 | 2844 | |
1e463951 FC |
2845 | C<xop_class> is one of the OA_*OP constants, and allows L<B> and other |
2846 | introspection mechanisms to work with custom ops | |
2847 | that aren't BASEOPs. C<xop_peep> is a pointer to | |
2848 | a function that will be called for ops of this | |
2849 | type from C<Perl_rpeep>. | |
5076a392 | 2850 | |
1e463951 FC |
2851 | See L<perlguts/Custom Operators> and L<perlapi/Custom Operators> for more |
2852 | detail. | |
5076a392 | 2853 | |
1e463951 FC |
2854 | The old C<PL_custom_op_names>/C<PL_custom_op_descs> interface is still |
2855 | supported but discouraged. | |
5076a392 | 2856 | |
1e463951 | 2857 | =head3 Scope hooks |
5076a392 | 2858 | |
1e463951 FC |
2859 | It is now possible for XS code to hook into Perl's lexical scope |
2860 | mechanism at compile time, using the new C<Perl_blockhook_register> | |
2861 | function. See L<perlguts/"Compile-time scope hooks">. | |
5076a392 | 2862 | |
1e463951 | 2863 | =head3 The recursive part of the peephole optimizer is now hookable |
5076a392 FC |
2864 | |
2865 | In addition to C<PL_peepp>, for hooking into the toplevel peephole optimizer, a | |
2866 | C<PL_rpeepp> is now available to hook into the optimizer recursing into | |
2867 | side-chains of the optree. | |
2868 | ||
1e463951 | 2869 | =head3 New non-magical variants of existing functions |
5076a392 | 2870 | |
1e463951 FC |
2871 | The following functions/macros have been added to the API. The C<*_nomg> |
2872 | macros are equivalent to their non-_nomg variants, except that they ignore | |
2873 | get-magic. Those ending in C<_flags> allow one to specify whether | |
2874 | get-magic is processed. | |
5076a392 | 2875 | |
1e463951 FC |
2876 | sv_2bool_flags |
2877 | SvTRUE_nomg | |
2878 | sv_2nv_flags | |
2879 | SvNV_nomg | |
2880 | sv_cmp_flags | |
2881 | sv_cmp_locale_flags | |
2882 | sv_eq_flags | |
2883 | sv_collxfrm_flags | |
5076a392 | 2884 | |
1e463951 | 2885 | In some of these cases, the non-_flags functions have |
5076a392 FC |
2886 | been replaced with wrappers around the new functions. |
2887 | ||
1e463951 | 2888 | =head3 pv/pvs/sv versions of existing functions |
5076a392 | 2889 | |
1e463951 | 2890 | Many functions ending with pvn now have equivalent pv/pvs/sv versions. |
5076a392 | 2891 | |
1e463951 | 2892 | =head3 List op-building functions |
5076a392 | 2893 | |
1e463951 FC |
2894 | List op-building functions have been added to the |
2895 | API. See L<op_append_elem|perlapi/op_append_elem>, | |
2896 | L<op_append_list|perlapi/op_append_list>, and | |
2897 | L<op_prepend_elem|perlapi/op_prepend_elem> in L<perlapi>. | |
5076a392 | 2898 | |
1e463951 | 2899 | =head3 C<LINKLIST> |
5076a392 | 2900 | |
1e463951 FC |
2901 | The L<LINKLIST|perlapi/LINKLIST> macro, part of op building that |
2902 | constructs the execution-order op chain, has been added to the API. | |
5076a392 | 2903 | |
1e463951 | 2904 | =head3 Localisation functions |
5076a392 | 2905 | |
1e463951 FC |
2906 | The C<save_freeop>, C<save_op>, C<save_pushi32ptr> and C<save_pushptrptr> |
2907 | functions have been added to the API. | |
5076a392 | 2908 | |
1e463951 | 2909 | =head3 Stash names |
5076a392 | 2910 | |
1e463951 FC |
2911 | A stash can now have a list of effective names in addition to its usual |
2912 | name. The first effective name can be accessed via the C<HvENAME> macro, | |
2913 | which is now the recommended name to use in MRO linearisations (C<HvNAME> | |
2914 | being a fallback if there is no C<HvENAME>). | |
5076a392 | 2915 | |
1e463951 FC |
2916 | These names are added and deleted via C<hv_ename_add> and |
2917 | C<hv_ename_delete>. These two functions are I<not> part of the API. | |
5076a392 | 2918 | |
1e463951 | 2919 | =head3 New functions for finding and removing magic |
5076a392 | 2920 | |
1e463951 FC |
2921 | The L<C<mg_findext()>|perlapi/mg_findext> and |
2922 | L<C<sv_unmagicext()>|perlapi/sv_unmagicext> | |
2923 | functions have been added to the API. | |
2924 | They allow extension authors to find and remove magic attached to | |
2925 | scalars based on both the magic type and the magic virtual table, similar to how | |
2926 | C<sv_magicext()> attaches magic of a certain type and with a given virtual table | |
2927 | to a scalar. This eliminates the need for extensions to walk the list of | |
2928 | C<MAGIC> pointers of an C<SV> to find the magic that belongs to them. | |
5076a392 | 2929 | |
1e463951 | 2930 | =head3 C<find_rundefsv> |
5076a392 | 2931 | |
1e463951 FC |
2932 | This function returns the SV representing C<$_>, whether it's lexical |
2933 | or dynamic. | |
5076a392 | 2934 | |
1e463951 | 2935 | =head3 C<Perl_croak_no_modify> |
5076a392 | 2936 | |
1e463951 FC |
2937 | C<Perl_croak_no_modify()> is short-hand for |
2938 | C<Perl_croak("%s", PL_no_modify)>. | |
5076a392 | 2939 | |
1e463951 | 2940 | =head3 C<PERL_STATIC_INLINE> define |
5076a392 | 2941 | |
1e463951 FC |
2942 | The C<PERL_STATIC_INLINE> define has been added to provide the best-guess |
2943 | incantation to use for static inline functions, if the C compiler supports | |
2944 | C99-style static inline. If it doesn't, it'll give a plain C<static>. | |
5076a392 | 2945 | |
1e463951 FC |
2946 | C<HAS_STATIC_INLINE> can be used to check if the compiler actually supports |
2947 | inline functions. | |
5076a392 | 2948 | |
1e463951 | 2949 | =head3 New C<pv_escape> option for hexadecimal escapes |
5076a392 | 2950 | |
1e463951 FC |
2951 | A new option, C<PERL_PV_ESCAPE_NONASCII>, has been added to C<pv_escape> to |
2952 | dump all characters above ASCII in hexadecimal. Before, one could get all | |
2953 | characters as hexadecimal or the Latin1 non-ASCII as octal. | |
5076a392 | 2954 | |
1e463951 | 2955 | =head3 C<lex_start> |
5076a392 | 2956 | |
1e463951 | 2957 | C<lex_start> has been added to the API, but is considered experimental. |
5076a392 | 2958 | |
1e463951 | 2959 | =head3 C<op_scope()> and C<op_lvalue()> |
5076a392 | 2960 | |
1e463951 FC |
2961 | The C<op_scope()> and C<op_lvalue()> functions have been added to the API, |
2962 | but are considered experimental. | |
5076a392 | 2963 | |
1e463951 | 2964 | =head2 C API Changes |
5076a392 | 2965 | |
1e463951 | 2966 | =head3 C<PERL_POLLUTE> has been removed |
5076a392 | 2967 | |
1e463951 FC |
2968 | The option to define C<PERL_POLLUTE> to expose older 5.005 symbols for |
2969 | backwards compatibility has been removed. It's use was always discouraged, | |
2970 | and MakeMaker contains a more specific escape hatch: | |
5076a392 | 2971 | |
1e463951 | 2972 | perl Makefile.PL POLLUTE=1 |
5076a392 | 2973 | |
1e463951 FC |
2974 | This can be used for modules that have not been upgraded to 5.6 naming |
2975 | conventions (and really should be completely obsolete by now). | |
5076a392 | 2976 | |
1e463951 | 2977 | =head3 Check API compatibility when loading XS modules |
5076a392 | 2978 | |
1e463951 FC |
2979 | When perl's API changes in incompatible ways (which usually happens between |
2980 | major releases), XS modules compiled for previous versions of perl will not | |
2981 | work anymore. They will need to be recompiled against the new perl. | |
5076a392 | 2982 | |
1e463951 FC |
2983 | In order to ensure that modules are recompiled, and to prevent users from |
2984 | accidentally loading modules compiled for old perls into newer ones, the | |
2985 | C<XS_APIVERSION_BOOTCHECK> macro has been added. That macro, which is | |
2986 | called when loading every newly compiled extension, compares the API | |
2987 | version of the running perl with the version a module has been compiled for | |
2988 | and raises an exception if they don't match. | |
5076a392 | 2989 | |
1e463951 | 2990 | =head3 Perl_fetch_cop_label |
5076a392 | 2991 | |
1e463951 FC |
2992 | The first argument of the C API function C<Perl_fetch_cop_label> has changed |
2993 | from C<struct refcounted he *> to C<COP *>, to insulate the user from | |
2994 | implementation details. | |
5076a392 | 2995 | |
1e463951 FC |
2996 | This API function was marked as "may change", and likely isn't in use outside |
2997 | the core. (Neither an unpacked CPAN, nor Google's codesearch, finds any other | |
2998 | references to it.) | |
5076a392 | 2999 | |
1e463951 | 3000 | =head3 GvCV() and GvGP() are no longer lvalues |
5076a392 | 3001 | |
1e463951 FC |
3002 | The new GvCV_set() and GvGP_set() macros are now provided to replace |
3003 | assignment to those two macros. | |
5076a392 | 3004 | |
1e463951 FC |
3005 | This allows a future commit to eliminate some backref magic between GV |
3006 | and CVs, which will require complete control over assignment to the | |
3007 | gp_cv slot. | |
5076a392 | 3008 | |
1e463951 | 3009 | =head3 CvGV() is no longer an lvalue |
5076a392 | 3010 | |
1e463951 FC |
3011 | Under some circumstances, the C<CvGV()> field of a CV is now |
3012 | reference-counted. To ensure consistent behaviour, direct assignment to | |
3013 | it, for example C<CvGV(cv) = gv> is now a compile-time error. A new macro, | |
3014 | C<CvGV_set(cv,gv)> has been introduced to perform this operation | |
3015 | safely. Note that modification of this field is not part of the public | |
3016 | API, regardless of this new macro (and despite its being listed in this section). | |
5076a392 | 3017 | |
1e463951 | 3018 | =head3 CvSTASH() is no longer an lvalue |
5076a392 | 3019 | |
1e463951 FC |
3020 | The C<CvSTASH()> macro can now only be used as an rvalue. C<CvSTASH_set()> |
3021 | has been added to replace assignment to C<CvSTASH()>. This is to ensure | |
3022 | that backreferences are handled properly. These macros are not part of the | |
3023 | API. | |
5076a392 | 3024 | |
1e463951 | 3025 | =head3 Calling conventions for C<newFOROP> and C<newWHILEOP> |
5076a392 | 3026 | |
1e463951 FC |
3027 | The way the parser handles labels has been cleaned up and refactored. As a |
3028 | result, the C<newFOROP()> constructor function no longer takes a parameter | |
3029 | stating what label is to go in the state op. | |
5076a392 | 3030 | |
1e463951 FC |
3031 | The C<newWHILEOP()> and C<newFOROP()> functions no longer accept a line |
3032 | number as a parameter. | |
5076a392 | 3033 | |
1e463951 | 3034 | =head3 Flags passed to C<uvuni_to_utf8_flags> and C<utf8n_to_uvuni> |
5076a392 | 3035 | |
1e463951 FC |
3036 | Some of the flags parameters to uvuni_to_utf8_flags() and |
3037 | utf8n_to_uvuni() have changed. This is a result of Perl's now allowing | |
5076a392 FC |
3038 | internal storage and manipulation of code points that are problematic |
3039 | in some situations. Hence, the default actions for these functions has | |
3040 | been complemented to allow these code points. The new flags are | |
3041 | documented in L<perlapi>. Code that requires the problematic code | |
483b16f3 | 3042 | points to be rejected needs to change to use the new flags. Some flag |
5076a392 FC |
3043 | names are retained for backward source compatibility, though they do |
3044 | nothing, as they are now the default. However the flags | |
3045 | C<UNICODE_ALLOW_FDD0>, C<UNICODE_ALLOW_FFFF>, C<UNICODE_ILLEGAL>, and | |
3046 | C<UNICODE_IS_ILLEGAL> have been removed, as they stem from a | |
3047 | fundamentally broken model of how the Unicode non-character code points | |
3048 | should be handled, which is now described in | |
3049 | L<perlunicode/Non-character code points>. See also L</Selected Bug Fixes>. | |
3050 | ||
1e463951 | 3051 | XXX Which bugs in particular? Selected Bug Fixes is too long for this link |
483b16f3 KW |
3052 | to be meaningful right now |
3053 | I don't see the bugs in that section currently -- khw | |
5076a392 | 3054 | |
1e463951 | 3055 | =head2 Deprecated C APIs |
5076a392 | 3056 | |
1e463951 | 3057 | =over |
5076a392 | 3058 | |
1e463951 | 3059 | =item C<Perl_ptr_table_clear> |
5076a392 | 3060 | |
1e463951 FC |
3061 | C<Perl_ptr_table_clear> is no longer part of Perl's public API. Calling it |
3062 | now generates a deprecation warning, and it will be removed in a future | |
3063 | release. | |
5076a392 | 3064 | |
1e463951 | 3065 | =item C<sv_compile_2op> |
5076a392 | 3066 | |
1e463951 FC |
3067 | The C<sv_compile_2op()> API function is now deprecated. Searches suggest |
3068 | that nothing on CPAN is using it, so this should have zero impact. | |
5076a392 | 3069 | |
1e463951 FC |
3070 | It attempted to provide an API to compile code down to an optree, but failed |
3071 | to bind correctly to lexicals in the enclosing scope. It's not possible to | |
3072 | fix this problem within the constraints of its parameters and return value. | |
5076a392 | 3073 | |
1e463951 | 3074 | =item C<find_rundefsvoffset> |
5076a392 | 3075 | |
1e463951 FC |
3076 | The C<find_rundefsvoffset> function has been deprecated. It appeared that |
3077 | its design was insufficient for reliably getting the lexical C<$_> at | |
3078 | run-time. | |
5076a392 | 3079 | |
1e463951 FC |
3080 | Use the new C<find_rundefsv> function or the C<UNDERBAR> macro |
3081 | instead. They directly return the right SV representing C<$_>, whether it's | |
3082 | lexical or dynamic. | |
5076a392 | 3083 | |
1e463951 | 3084 | =item C<CALL_FPTR> and C<CPERLscope> |
5076a392 | 3085 | |
1e463951 FC |
3086 | Those are left from an old implementation of C<MULTIPLICITY> using C++ objects, |
3087 | which was removed in Perl 5.8. Nowadays these macros do exactly nothing, so | |
3088 | they shouldn't be used anymore. | |
5076a392 | 3089 | |
1e463951 FC |
3090 | For compatibility, they are still defined for external C<XS> code. Only |
3091 | extensions defining C<PERL_CORE> must be updated now. | |
5076a392 | 3092 | |
1e463951 | 3093 | =back |
5076a392 | 3094 | |
1e463951 | 3095 | =head2 Other Internal Changes |
5076a392 | 3096 | |
1e463951 | 3097 | =head3 Stack unwinding |
5076a392 | 3098 | |
1e463951 FC |
3099 | The protocol for unwinding the C stack at the last stage of a C<die> |
3100 | has changed how it identifies the target stack frame. This now uses | |
3101 | a separate variable C<PL_restartjmpenv>, where previously it relied on | |
3102 | the C<blk_eval.cur_top_env> pointer in the C<eval> context frame that | |
3103 | has nominally just been discarded. This change means that code running | |
3104 | during various stages of Perl-level unwinding no longer needs to take | |
3105 | care to avoid destroying the ghost frame. | |
5076a392 | 3106 | |
1e463951 | 3107 | =head3 Scope stack entries |
5076a392 | 3108 | |
1e463951 FC |
3109 | The format of entries on the scope stack has been changed, resulting in a |
3110 | reduction of memory usage of about 10%. In particular, the memory used by | |
3111 | the scope stack to record each active lexical variable has been halved. | |
5076a392 | 3112 | |
1e463951 | 3113 | =head3 Memory allocation for pointer tables |
5076a392 | 3114 | |
1e463951 FC |
3115 | Memory allocation for pointer tables has been changed. Previously |
3116 | C<Perl_ptr_table_store> allocated memory from the same arena system as | |
3117 | C<SV> bodies and C<HE>s, with freed memory remaining bound to those arenas | |
3118 | until interpreter exit. Now it allocates memory from arenas private to the | |
3119 | specific pointer table, and that memory is returned to the system when | |
3120 | C<Perl_ptr_table_free> is called. Additionally, allocation and release are | |
3121 | both less CPU intensive. | |
5076a392 | 3122 | |
1e463951 | 3123 | =head3 C<UNDERBAR> |
5076a392 | 3124 | |
1e463951 FC |
3125 | The C<UNDERBAR> macro now calls C<find_rundefsv>. C<dUNDERBAR> is now a |
3126 | noop but should still be used to ensure past and future compatibility. | |
5076a392 | 3127 | |
1e463951 | 3128 | =head3 String comparison routines renamed |
5076a392 | 3129 | |
1e463951 FC |
3130 | The ibcmp_* functions have been renamed and are now called foldEQ, |
3131 | foldEQ_locale and foldEQ_utf8. The old names are still available as | |
3132 | macros. | |
3133 | ||
3134 | =head3 C<chop> and C<chomp> implementations merged | |
3135 | ||
3136 | The opcode bodies for C<chop> and C<chomp> and for C<schop> and C<schomp> | |
3137 | have been merged. The implementation functions C<Perl_do_chop()> and | |
3138 | C<Perl_do_chomp()>, never part of the public API, have been merged and | |
3139 | moved to a static function in F<pp.c>. This shrinks the perl binary | |
3140 | slightly, and should not affect any code outside the core (unless it is | |
3141 | relying on the order of side effects when C<chomp> is passed a I<list> of | |
3142 | values). | |
5076a392 FC |
3143 | |
3144 | =head1 Selected Bug Fixes | |
3145 | ||
e8e35311 FC |
3146 | =head2 I/O |
3147 | ||
5076a392 FC |
3148 | =over 4 |
3149 | ||
3150 | =item * | |
3151 | ||
e8e35311 | 3152 | Perl no longer produces this warning: |
a593b319 FC |
3153 | |
3154 | $ perl -we 'open my $f, ">", \my $x; binmode $f, "scalar"' | |
3155 | Use of uninitialized value in binmode at -e line 1. | |
3156 | ||
3157 | =item * | |
3158 | ||
e8e35311 FC |
3159 | Opening a glob reference via C<< open $fh, "E<gt>", \*glob >> will no longer |
3160 | cause the glob to be corrupted when the filehandle is printed to. This would | |
3161 | cause perl to crash whenever the glob's contents were accessed | |
3162 | [perl #77492]. | |
4ed2cea4 FC |
3163 | |
3164 | =item * | |
3165 | ||
e8e35311 FC |
3166 | PerlIO no longer crashes when called recursively, e.g., from a signal |
3167 | handler. Now it just leaks memory [perl #75556]. | |
4ed2cea4 FC |
3168 | |
3169 | =item * | |
3170 | ||
e8e35311 FC |
3171 | Most I/O functions were not warning for unopened handles unless the |
3172 | 'closed' and 'unopened' warnings categories were both enabled. Now only | |
3173 | C<use warnings 'unopened'> is necessary to trigger these warnings (as was | |
438c239f | 3174 | always meant to be the case). |
4ed2cea4 FC |
3175 | |
3176 | =item * | |
3177 | ||
438c239f | 3178 | There have been several fixes to PerlIO layers: |
e8e35311 | 3179 | |
438c239f FC |
3180 | When C<binmode FH, ":crlf"> pushes the C<:crlf> layer on top of the stack, |
3181 | it no longer enables crlf layers lower in the stack, to avoid unexpected | |
3182 | results [perl #38456]. | |
4ed2cea4 | 3183 | |
438c239f FC |
3184 | Opening a file in C<:raw> mode now does what it advertises to do (first |
3185 | open the file, then binmode it), instead of simply leaving off the top | |
3186 | layer [perl #80764]. | |
5076a392 | 3187 | |
438c239f FC |
3188 | The three layers C<:pop>, C<:utf8> and C<:bytes> didn't allow stacking when |
3189 | opening a file. For example | |
e8e35311 | 3190 | this: |
5076a392 | 3191 | |
e8e35311 | 3192 | open FH, '>:pop:perlio', 'some.file' or die $!; |
5076a392 | 3193 | |
438c239f FC |
3194 | Would throw an error: "Invalid argument". This has been fixed in this |
3195 | release [perl #82484]. | |
5076a392 | 3196 | |
e8e35311 FC |
3197 | =back |
3198 | ||
3199 | =head2 Regular Expression Bug Fixes | |
3200 | ||
3201 | =over | |
5076a392 FC |
3202 | |
3203 | =item * | |
3204 | ||
e8e35311 FC |
3205 | The regular expression engine no longer loops when matching |
3206 | C<"\N{LATIN SMALL LIGATURE FF}" =~ /f+/i> and similar expressions | |
cdc10f43 | 3207 | [perl #72998] (5.12.1). |
5076a392 FC |
3208 | |
3209 | =item * | |
3210 | ||
e8e35311 FC |
3211 | The trie runtime code should no longer allocate massive amounts of memory, |
3212 | fixing #74484. | |
5076a392 FC |
3213 | |
3214 | =item * | |
3215 | ||
438c239f FC |
3216 | Syntax errors in C<< (?{...}) >> blocks no longer cause panic messages |
3217 | [perl #2353]. | |
5076a392 FC |
3218 | |
3219 | =item * | |
3220 | ||
438c239f FC |
3221 | A pattern like C<(?:(o){2})?> no longer causes a "panic" error |
3222 | [perl #39233]. | |
5076a392 FC |
3223 | |
3224 | =item * | |
3225 | ||
438c239f | 3226 | A fatal error in regular expressions containing C<(.*?)> when processing |
d430b8e7 | 3227 | UTF-8 data has been fixed [perl #75680] (5.12.2). |
5076a392 FC |
3228 | |
3229 | =item * | |
3230 | ||
e8e35311 | 3231 | An erroneous regular expression engine optimisation that caused regex verbs like |
438c239f | 3232 | C<*COMMIT> sometimes to be ignored has been removed. |
5076a392 FC |
3233 | |
3234 | =item * | |
3235 | ||
e8e35311 FC |
3236 | The regular expression bracketed character class C<[\8\9]> was effectively the |
3237 | same as C<[89\000]>, incorrectly matching a NULL character. It also gave | |
3238 | incorrect warnings that the C<8> and C<9> were ignored. Now C<[\8\9]> is the | |
3239 | same as C<[89]> and gives legitimate warnings that C<\8> and C<\9> are | |
3240 | unrecognized escape sequences, passed-through. | |
5076a392 FC |
3241 | |
3242 | =item * | |
3243 | ||
e8e35311 FC |
3244 | A regular expression match in the right-hand side of a global substitution |
3245 | (C<s///g>) that is in the same scope will no longer cause match variables | |
3246 | to have the wrong values on subsequent iterations. This can happen when an | |
3247 | array or hash subscript is interpolated in the right-hand side, as in | |
3248 | C<s|(.)|@a{ print($1), /./ }|g> [perl #19078]. | |
5076a392 FC |
3249 | |
3250 | =item * | |
3251 | ||
438c239f FC |
3252 | Several cases in which characters in the Latin-1 non-ASCII range (0x80 to |
3253 | 0xFF) used not to match themselves or used to match both a character class | |
3254 | and its complement have been fixed. For instance, U+00E2 could match both | |
3255 | C<\w> and C<\W> [perl #78464] [perl #18281] [perl #60156]. | |
5076a392 FC |
3256 | |
3257 | =item * | |
3258 | ||
e8e35311 FC |
3259 | Matching a Unicode character against an alternation containing characters |
3260 | that happened to match continuation bytes in the former's UTF8 | |
3261 | representation (C<qq{\x{30ab}} =~ /\xab|\xa9/>) would cause erroneous | |
3262 | warnings [perl #70998]. | |
5076a392 FC |
3263 | |
3264 | =item * | |
3265 | ||
e8e35311 FC |
3266 | The trie optimisation was not taking empty groups into account, preventing |
3267 | 'foo' from matching C</\A(?:(?:)foo|bar|zot)\z/> [perl #78356]. | |
5076a392 FC |
3268 | |
3269 | =item * | |
3270 | ||
e8e35311 FC |
3271 | A pattern containing a C<+> inside a lookahead would sometimes cause an |
3272 | incorrect match failure in a global match (e.g., C</(?=(\S+))/g>) | |
3273 | [perl #68564]. | |
5076a392 FC |
3274 | |
3275 | =item * | |
3276 | ||
e8e35311 FC |
3277 | A regular expression optimisation would sometimes cause a match with a |
3278 | C<{n,m}> quantifier to fail when it should match [perl #79152]. | |
5076a392 FC |
3279 | |
3280 | =item * | |
3281 | ||
e8e35311 | 3282 | Case insensitive matching in regular expressions compiled under C<use |
438c239f FC |
3283 | locale> now works much more sanely when the pattern or |
3284 | target string is encoded internally in | |
3285 | UTF8. Previously, under these conditions the localeness | |
e8e35311 FC |
3286 | was completely lost. Now, code points above 255 are treated as Unicode, |
3287 | but code points between 0 and 255 are treated using the current locale | |
438c239f FC |
3288 | rules, regardless of whether the pattern or the string is encoded in UTF8. |
3289 | The few case-insensitive matches that cross the 255/256 boundary are not | |
e8e35311 FC |
3290 | allowed. For example, 0xFF does not caselessly match the character at |
3291 | 0x178, LATIN CAPITAL LETTER Y WITH DIAERESIS, because 0xFF may not be | |
3292 | LATIN SMALL LETTER Y in the current locale, and Perl has no way of | |
3293 | knowing if that character even exists in the locale, much less what code | |
3294 | point it is. | |
5076a392 FC |
3295 | |
3296 | =item * | |
3297 | ||
e8e35311 FC |
3298 | The C<(?|...)> regular expression construct no longer crashes if the final |
3299 | branch has more sets of capturing parentheses than any other branch. This | |
3300 | was fixed in Perl 5.10.1 for the case of a single branch, but that fix did | |
3301 | not take multiple branches into account [perl #84746]. | |
5076a392 FC |
3302 | |
3303 | =item * | |
3304 | ||
e8e35311 FC |
3305 | A bug has been fixed in the implementation of C<{...}> quantifiers in |
3306 | regular expressions that prevented the code block in | |
3307 | C</((\w+)(?{ print $2 })){2}/> from seeing the C<$2> sometimes | |
3308 | [perl #84294]. | |
5076a392 | 3309 | |
e8e35311 | 3310 | =back |
5076a392 | 3311 | |
e8e35311 FC |
3312 | =head2 Syntax/Parsing Bugs |
3313 | ||
3314 | =over | |
5076a392 FC |
3315 | |
3316 | =item * | |
3317 | ||
e8e35311 | 3318 | C<when(scalar){...}> no longer crashes, but produces a syntax error |
cdc10f43 | 3319 | [perl #74114] (5.12.1). |
5076a392 FC |
3320 | |
3321 | =item * | |
3322 | ||
e8e35311 FC |
3323 | A label right before a string eval (C<foo: eval $string>) no longer causes |
3324 | the label to be associated also with the first statement inside the eval | |
3325 | [perl #74290] (5.12.1). | |
5076a392 FC |
3326 | |
3327 | =item * | |
3328 | ||
b2c076b5 | 3329 | The C<no 5.13.2;> form of C<no> no longer tries to turn on features or |
d430b8e7 | 3330 | pragmata (i.e., strict) [perl #70075] (5.12.2). |
5076a392 FC |
3331 | |
3332 | =item * | |
3333 | ||
b2c076b5 FC |
3334 | C<BEGIN {require 5.12.0}> now behaves as documented, rather than behaving |
3335 | identically to C<use 5.12.0;>. Previously, C<require> in a C<BEGIN> block | |
3336 | was erroneously executing the C<use feature ':5.12.0'> and | |
3337 | C<use strict;> behaviour, which only C<use> was documented to | |
3338 | provide [perl #69050]. | |
5076a392 FC |
3339 | |
3340 | =item * | |
3341 | ||
5076a392 FC |
3342 | A regression introduced in Perl 5.12.0, making |
3343 | C<< my $x = 3; $x = length(undef) >> result in C<$x> set to C<3> has been | |
d430b8e7 | 3344 | fixed. C<$x> will now be C<undef> [perl #85508] (5.12.2). |
b2c076b5 FC |
3345 | |
3346 | =item * | |
3347 | ||
3348 | When strict 'refs' mode is off, C<%{...}> in rvalue context returns | |
3349 | C<undef> if its argument is undefined. An optimisation introduced in perl | |
3350 | 5.12.0 to make C<keys %{...}> faster when used as a boolean did not take | |
3351 | this into account, causing C<keys %{+undef}> (and C<keys %$foo> when | |
3352 | C<$foo> is undefined) to be an error, which it should only be in strict | |
3353 | mode [perl #81750]. | |
5076a392 FC |
3354 | |
3355 | =item * | |
3356 | ||
e8e35311 | 3357 | Constant-folding used to cause |
5076a392 | 3358 | |
e8e35311 | 3359 | $text =~ ( 1 ? /phoo/ : /bear/) |
5076a392 | 3360 | |
e8e35311 FC |
3361 | to turn into |
3362 | ||
3363 | $text =~ /phoo/ | |
3364 | ||
3365 | at compile time. Now it correctly matches against C<$_> [perl #20444]. | |
5076a392 FC |
3366 | |
3367 | =item * | |
3368 | ||
e8e35311 FC |
3369 | Parsing Perl code (either with string C<eval> or by loading modules) from |
3370 | within a C<UNITCHECK> block no longer causes the interpreter to crash | |
3371 | [perl #70614]. | |
5076a392 FC |
3372 | |
3373 | =item * | |
3374 | ||
b2c076b5 FC |
3375 | String evals no longer fail after 2 billion scopes have been |
3376 | compiled [perl #83364]. | |
3377 | ||
3378 | =item * | |
3379 | ||
e8e35311 FC |
3380 | The parser no longer hangs when encountering certain Unicode characters, |
3381 | such as U+387 [perl #74022]. | |
5076a392 FC |
3382 | |
3383 | =item * | |
3384 | ||
b2c076b5 FC |
3385 | Several contexts no longer allow a Unicode character to begin a word |
3386 | that should never begin words, for an example an accent that must follow | |
3387 | another character previously could precede all other characters. | |
5076a392 FC |
3388 | |
3389 | =item * | |
3390 | ||
e8e35311 FC |
3391 | Defining a constant with the same name as one of perl's special blocks |
3392 | (e.g., INIT) stopped working in 5.12.0, but has now been fixed | |
3393 | [perl #78634]. | |
5076a392 FC |
3394 | |
3395 | =item * | |
3396 | ||
e8e35311 FC |
3397 | A reference to a literal value used as a hash key (C<$hash{\"foo"}>) used |
3398 | to be stringified, even if the hash was tied [perl #79178]. | |
5076a392 FC |
3399 | |
3400 | =item * | |
3401 | ||
e8e35311 FC |
3402 | A closure containing an C<if> statement followed by a constant or variable |
3403 | is no longer treated as a constant [perl #63540]. | |
5076a392 FC |
3404 | |
3405 | =item * | |
3406 | ||
e8e35311 FC |
3407 | C<state> can now be used with attributes. It used to mean the same thing as |
3408 | C<my> if attributes were present [perl #68658]. | |
5076a392 FC |
3409 | |
3410 | =item * | |
3411 | ||
e8e35311 FC |
3412 | Expressions like C<< @$a > 3 >> no longer cause C<$a> to be mentioned in |
3413 | the "Use of uninitialized value in numeric gt" warning when C<$a> is | |
3414 | undefined (since it is not part of the C<E<gt>> expression, but the operand | |
3415 | of the C<@>) [perl #72090]. | |
5076a392 FC |
3416 | |
3417 | =item * | |
3418 | ||
e8e35311 FC |
3419 | Accessing an element of a package array with a hard-coded number (as |
3420 | opposed to an arbitrary expression) would crash if the array did not exist. | |
3421 | Usually the array would be autovivified during compilation, but typeglob | |
3422 | manipulation could remove it, as in these two cases which used to crash: | |
5076a392 | 3423 | |
e8e35311 FC |
3424 | *d = *a; print $d[0]; |
3425 | undef *d; print $d[0]; | |
5076a392 | 3426 | |
2c389f6c FC |
3427 | =item * |
3428 | ||
3429 | The C<-C> command line option, when used on the shebang line, can now be | |
3430 | followed by other options [perl #72434]. | |
3431 | ||
3432 | =item * | |
3433 | ||
3434 | The C<B> module was returning C<B::OP>s instead of C<B::LOGOP>s for C<entertry> [perl #80622]. | |
3435 | This was due to a bug in the perl core, not in C<B> itself. | |
3436 | ||
e8e35311 | 3437 | =back |
5076a392 | 3438 | |
e262cb24 FC |
3439 | =head2 Stashes, Globs and Method Lookup |
3440 | ||
3441 | Perl 5.10.0 introduced a new internal mechanism for caching MROs (method | |
3442 | resolution orders, or lists of parent classes; aka "isa" caches) to make | |
3443 | method lookup faster (so @ISA arrays would not have to be searched | |
3444 | repeatedly). Unfortunately, this brought with it quite a few bugs. Almost | |
3445 | all of these have been fixed now, along with a few MRO-related bugs that | |
3446 | existed before 5.10.0: | |
3447 | ||
3448 | =over | |
3449 | ||
3450 | =item * | |
3451 | ||
3452 | The following used to have erratic effects on method resolution, because | |
3453 | the "isa" caches were not reset or otherwise ended up listing the wrong | |
3454 | classes. These have been fixed. | |
3455 | ||
3456 | =over | |
3457 | ||
3458 | =item Aliasing packages by assigning to globs [perl #77358] | |
3459 | ||
3460 | =item Deleting packages by deleting their containing stash elements | |
3461 | ||
3462 | =item Undefining the glob containing a package (C<undef *Foo::>) | |
3463 | ||
3464 | =item Undefining an ISA glob (C<undef *Foo::ISA>) | |
3465 | ||
3466 | =item Deleting an ISA stash element (C<delete $Foo::{ISA}>) | |
3467 | ||
3468 | =item Sharing @ISA arrays between classes (via C<*Foo::ISA = \@Bar::ISA> or | |
3469 | C<*Foo::ISA = *Bar::ISA>) [perl #77238] | |
3470 | ||
3471 | =back | |
3472 | ||
3473 | C<undef *Foo::ISA> would even stop a new C<@Foo::ISA> array from updating | |
3474 | caches. | |
3475 | ||
3476 | =item * | |
3477 | ||
3478 | Typeglob assignments would crash if the glob's stash no longer existed, so | |
3479 | long as the glob assigned to was named 'ISA' or the glob on either side of | |
3480 | the assignment contained a subroutine. | |
3481 | ||
3482 | =item * | |
3483 | ||
3484 | C<PL_isarev>, which is accessible to Perl via C<mro::get_isarev> is now | |
3485 | updated properly when packages are deleted or removed from the C<@ISA> of | |
3486 | other classes. This allows many packages to be created and deleted without | |
3487 | causing a memory leak [perl #75176]. | |
3488 | ||
3489 | =back | |
3490 | ||
3491 | In addition, various other bugs related to typeglobs and stashes have been | |
3492 | fixed: | |
5076a392 | 3493 | |
e8e35311 | 3494 | =over |
5076a392 FC |
3495 | |
3496 | =item * | |
3497 | ||
e8e35311 | 3498 | Some work has been done on the internal pointers that link between symbol |
e262cb24 | 3499 | tables (stashes), typeglobs and subroutines. This has the effect that |
e8e35311 FC |
3500 | various edge cases related to deleting stashes or stash entries (e.g. |
3501 | <%FOO:: = ()>), and complex typeglob or code reference aliasing, will no | |
3502 | longer crash the interpreter. | |
5076a392 FC |
3503 | |
3504 | =item * | |
3505 | ||
e262cb24 FC |
3506 | Assigning a reference to a glob copy now assigns to a glob slot instead of |
3507 | overwriting the glob with a scalar [perl #1804] [perl #77508]. | |
5076a392 FC |
3508 | |
3509 | =item * | |
3510 | ||
e8e35311 FC |
3511 | A bug when replacing the glob of a loop variable within the loop has been fixed |
3512 | [perl #21469]. This | |
3513 | means the following code will no longer crash: | |
5076a392 | 3514 | |
e8e35311 FC |
3515 | for $x (...) { |
3516 | *x = *y; | |
3517 | } | |
5076a392 FC |
3518 | |
3519 | =item * | |
3520 | ||
3521 | Assigning a glob to a PVLV used to convert it to a plain string. Now it | |
3522 | works correctly, and a PVLV can hold a glob. This would happen when a | |
3523 | nonexistent hash or array element was passed to a subroutine: | |
3524 | ||
3525 | sub { $_[0] = *foo }->($hash{key}); | |
3526 | # $_[0] would have been the string "*main::foo" | |
3527 | ||
3528 | It also happened when a glob was assigned to, or returned from, an element | |
3529 | of a tied array or hash [perl #36051]. | |
3530 | ||
3531 | =item * | |
44691e6f | 3532 | |
e8e35311 | 3533 | When trying to report C<Use of uninitialized value $Foo::BAR>, crashes could |
e262cb24 FC |
3534 | occur if the glob holding the global variable in question had been detached |
3535 | from its original stash by, for example, C<delete $::{'Foo::'}>. This has | |
3536 | been fixed by disabling the reporting of variable names in those | |
e8e35311 | 3537 | cases. |
44691e6f AB |
3538 | |
3539 | =item * | |
3540 | ||
e8e35311 FC |
3541 | During the restoration of a localised typeglob on scope exit, any |
3542 | destructors called as a result would be able to see the typeglob in an | |
3543 | inconsistent state, containing freed entries, which could result in a | |
3544 | crash. This would affect code like this: | |
3545 | ||
3546 | local *@; | |
3547 | eval { die bless [] }; # puts an object in $@ | |
3548 | sub DESTROY { | |
3549 | local $@; # boom | |
3550 | } | |
3551 | ||
3552 | Now the glob entries are cleared before any destructors are called. This | |
3553 | also means that destructors can vivify entries in the glob. So perl tries | |
3554 | again and, if the entries are re-created too many times, dies with a | |
3555 | 'panic: gp_free...' error message. | |
3556 | ||
3557 | =back | |
3558 | ||
3559 | =head2 Unicode | |
3560 | ||
3561 | =over | |
44691e6f | 3562 | |
5076a392 | 3563 | =item * |
44691e6f | 3564 | |
e8e35311 FC |
3565 | What has become known as the "Unicode Bug" is mostly resolved in this release. |
3566 | Under C<use feature 'unicode_strings'>, the internal storage format of a | |
3567 | string no longer affects the external semantics. There are two known | |
3568 | exceptions. User-defined case changing functions, which are planned to | |
3569 | be deprecated in 5.14, require utf8-encoded strings to function; and the | |
3570 | character C<LATIN SMALL LETTER SHARP S> in regular expression | |
3571 | case-insensitive matching has a somewhat different set of bugs depending | |
3572 | on the internal storage format. Case-insensitive matching of all | |
3573 | characters that have multi-character matches, as this one does, is | |
3574 | problematical in Perl [perl #58182]. | |
911a3729 | 3575 | |
5076a392 | 3576 | =item * |
c8c13991 | 3577 | |
e8e35311 FC |
3578 | The handling of Unicode non-characters has changed. |
3579 | Previously they were mostly considered illegal, except that only one of | |
3580 | the 66 of them was known about in places. The Unicode standard | |
3581 | considers them legal, but forbids the "open interchange" of them. | |
3582 | This is part of the change to allow the internal use of any code point | |
3583 | (see L</Core Enhancements>). Together, these changes resolve | |
9a5a48b7 FC |
3584 | [perl #38722], [perl #51918], [perl #51936], [perl #63446]. |
3585 | ||
3586 | =item * | |
3587 | ||
3588 | Naming a deprecated character in \N{...} no longer leaks memory. | |
3589 | ||
3590 | =item * | |
3591 | ||
cdc10f43 FC |
3592 | We fixed a bug that could cause \N{} constructs followed by a single . to |
3593 | be parsed incorrectly [perl #74978] (5.12.1). | |
3594 | ||
3595 | =item * | |
3596 | ||
9a5a48b7 FC |
3597 | C<chop> now correctly handles characters above "\x{7fffffff}" |
3598 | [perl #73246]. | |
3599 | ||
3600 | =item * | |
3601 | ||
3602 | Passing to C<index> an offset beyond the end of the string when the string | |
3603 | is encoded internally in UTF8 no longer causes panics [perl #75898]. | |
3604 | ||
3605 | =item * | |
3606 | ||
3607 | C<warn()> and C<die()> now respect utf8-encoded scalars [perl #45549]. | |
c8c13991 | 3608 | |
5076a392 FC |
3609 | =item * |
3610 | ||
9a5a48b7 | 3611 | Sometimes the UTF8 length cache would not be reset on a value |
e8e35311 | 3612 | returned by substr, causing C<length(substr($uni_string,...))> to give |
9a5a48b7 FC |
3613 | wrong answers. With C<${^UTF8CACHE}> set to -1, it would produce a 'panic' |
3614 | error message, too [perl #77692]. | |
e8e35311 FC |
3615 | |
3616 | =back | |
3617 | ||
e9784f55 | 3618 | =head2 Ties, Overloading and Other Magic |
e8e35311 FC |
3619 | |
3620 | =over | |
35cdccfc | 3621 | |
5076a392 FC |
3622 | =item * |
3623 | ||
e8e35311 | 3624 | Overloading now works properly in conjunction with tied |
e9784f55 | 3625 | variables. What formerly happened was that most ops checked their |
e8e35311 FC |
3626 | arguments for overloading I<before> checking for magic, so for example |
3627 | an overloaded object returned by a tied array access would usually be | |
e9784f55 | 3628 | treated as not overloaded [RT #57012]. |
911a3729 | 3629 | |
5076a392 | 3630 | =item * |
58f55cb3 | 3631 | |
e9784f55 FC |
3632 | Various cases of magic (e.g., tie methods) being called on tied variables |
3633 | too many or too few times have been fixed: | |
3634 | ||
3635 | =over | |
58f55cb3 | 3636 | |
5076a392 | 3637 | =item * |
6b3df227 | 3638 | |
e9784f55 | 3639 | FETCH is no longer called on tied variables in void context. |
6b3df227 | 3640 | |
5076a392 | 3641 | =item * |
c9989a74 | 3642 | |
e9784f55 | 3643 | C<$tied-E<gt>()> did not always call FETCH [perl #8438]. |
c9989a74 | 3644 | |
5076a392 FC |
3645 | =item * |
3646 | ||
e9784f55 FC |
3647 | Filetest operators and C<y///> and C<tr///> were calling FETCH too |
3648 | many times. | |
b7188eb5 FC |
3649 | |
3650 | =item * | |
3651 | ||
e9784f55 FC |
3652 | The C<=> operator used to ignore magic on its right-hand side if the |
3653 | scalar happened to hold a typeglob (if a typeglob was the last thing | |
3654 | returned from or assigned to a tied scalar) [perl #77498]. | |
911a3729 | 3655 | |
5076a392 | 3656 | =item * |
c8c13991 | 3657 | |
e9784f55 FC |
3658 | Dereference operators used to ignore magic if the argument was a |
3659 | reference already (e.g., from a previous FETCH) [perl #72144]. | |
c8c13991 | 3660 | |
e8e35311 | 3661 | =item * |
f00d3350 | 3662 | |
e9784f55 FC |
3663 | C<splice> now calls set-magic (so changes made |
3664 | by C<splice @ISA> are respected by method calls) [perl #78400]. | |
3665 | ||
d430b8e7 FC |
3666 | =item * |
3667 | ||
3668 | In-memory files created by C<open $fh, 'E<gt>' \$buffer> were not calling | |
3669 | FETCH/STORE at all [perl #43789] (5.12.2). | |
3670 | ||
e9784f55 | 3671 | =back |
c34a735e | 3672 | |
5076a392 | 3673 | =item * |
b7188eb5 | 3674 | |
e9784f55 FC |
3675 | String C<eval> now detects taintedness of overloaded or tied |
3676 | arguments [perl #75716]. | |
b7188eb5 | 3677 | |
5076a392 | 3678 | =item * |
b7188eb5 | 3679 | |
e9784f55 FC |
3680 | String C<eval> and regular expression matches against objects with string |
3681 | overloading no longer cause memory corruption or crashes [perl 77084]. | |
c34a735e | 3682 | |
05dbc6f8 KW |
3683 | =item * |
3684 | ||
e9784f55 FC |
3685 | L<readline|perlfunc/"readline EXPR"> now honors C<< <> >> overloading on tied |
3686 | arguments. | |
7b98b857 | 3687 | |
5076a392 | 3688 | =item * |
05dbc6f8 | 3689 | |
e9784f55 FC |
3690 | C<< E<lt>exprE<gt> >> always respects overloading now if the expression is |
3691 | overloaded. | |
3692 | ||
3693 | Due to the way that 'E<lt>E<gt> as glob' was parsed differently from | |
3694 | 'E<lt>E<gt> as filehandle' from 5.6 onwards, something like C<< E<lt>$foo[0]E<gt> >> did | |
3695 | not handle overloading, even if C<$foo[0]> was an overloaded object. This | |
3696 | was contrary to the documentation for overload, and meant that C<< E<lt>E<gt> >> | |
3697 | could not be used as a general overloaded iterator operator. | |
05dbc6f8 KW |
3698 | |
3699 | =item * | |
3700 | ||
e8e35311 FC |
3701 | The fallback behaviour of overloading on binary operators was asymmetric |
3702 | [perl #71286]. | |
05dbc6f8 | 3703 | |
5076a392 | 3704 | =item * |
05dbc6f8 | 3705 | |
e9784f55 FC |
3706 | Magic applied to variables in the main package no longer affects other packages. |
3707 | See L</Magic variables outside the main package> above [perl #76138]. | |
05dbc6f8 | 3708 | |
5076a392 | 3709 | =item * |
05dbc6f8 | 3710 | |
e9784f55 FC |
3711 | Sometimes magic (ties, taintedness, etc.) attached to variables could cause |
3712 | an object to last longer than it should, or cause a crash if a tied | |
3713 | variable were freed from within a tie method. These have been fixed | |
3714 | [perl #81230]. | |
05dbc6f8 KW |
3715 | |
3716 | =item * | |
3717 | ||
e8e35311 FC |
3718 | DESTROY methods of objects implementing ties are no longer able to crash by |
3719 | accessing the tied variable through a weak reference [perl #86328]. | |
3720 | ||
2c389f6c FC |
3721 | =item * |
3722 | ||
3723 | Fixed a regression of kill() when a match variable is used for the | |
3724 | process ID to kill [perl #75812]. | |
3725 | ||
3726 | =item * | |
3727 | ||
3728 | C<$AUTOLOAD> used to remain tainted forever if it ever became tainted. Now | |
3729 | it is correctly untainted if an autoloaded method is called and the method | |
3730 | name was not tainted. | |
3731 | ||
3732 | =item * | |
3733 | ||
3734 | C<sprintf> now dies when passed a tainted scalar for the format. It did | |
3735 | already die for arbitrary expressions, but not for simple scalars | |
3736 | [perl #82250]. | |
3737 | ||
cdc10f43 FC |
3738 | =item * |
3739 | ||
3740 | utf8::is_utf8 now respects get-magic (e.g. $1) (5.12.1). | |
3741 | ||
e8e35311 FC |
3742 | =back |
3743 | ||
3744 | =head2 The Debugger | |
3745 | ||
3746 | =over | |
05dbc6f8 | 3747 | |
5076a392 | 3748 | =item * |
05dbc6f8 | 3749 | |
bdb0cce8 | 3750 | The Perl debugger now also works in taint mode [perl #76872]. |
4d56cd4f | 3751 | |
5076a392 FC |
3752 | =item * |
3753 | ||
bdb0cce8 | 3754 | Subroutine redefinition works once more in the debugger [perl #48332]. |
05dbc6f8 | 3755 | |
911a3729 FC |
3756 | =item * |
3757 | ||
e8e35311 | 3758 | When C<-d> is used on the shebang (C<#!>) line, the debugger now has access |
bdb0cce8 | 3759 | to the lines of the main program. In the past, this sometimes worked and |
e8e35311 FC |
3760 | sometimes did not, depending on what order things happened to be arranged |
3761 | in memory [perl #71806]. | |
911a3729 | 3762 | |
5076a392 | 3763 | =item * |
44691e6f | 3764 | |
bdb0cce8 | 3765 | A possible memory leak when using L<caller()|perlfunc/"caller EXPR"> to set |
d430b8e7 | 3766 | C<@DB::args> has been fixed (5.12.2). |
bdb0cce8 FC |
3767 | |
3768 | =item * | |
3769 | ||
3770 | Perl no longer stomps on $DB::single, $DB::trace and $DB::signal if they | |
3771 | already have values when $^P is assigned to [perl #72422]. | |
44691e6f | 3772 | |
5076a392 | 3773 | =item * |
44691e6f | 3774 | |
e8e35311 FC |
3775 | C<#line> directives in string evals were not properly updating the arrays |
3776 | of lines of code (C<< @{"_<..."} >>) that the debugger (or any debugging or | |
3777 | profiling module) uses. In threaded builds, they were not being updated at | |
3778 | all. In non-threaded builds, the line number was ignored, so any change to | |
3779 | the existing line number would cause the lines to be misnumbered | |
3780 | [perl #79442]. | |
3781 | ||
3782 | =back | |
3783 | ||
2c389f6c | 3784 | =head2 Threads |
e8e35311 FC |
3785 | |
3786 | =over | |
9dc513c5 | 3787 | |
5076a392 FC |
3788 | =item * |
3789 | ||
2c389f6c FC |
3790 | Perl no longer accidentally clones lexicals in scope within active stack |
3791 | frames in the parent when creating a child thread [perl #73086]. | |
44691e6f | 3792 | |
5076a392 | 3793 | =item * |
6d96b0fe | 3794 | |
e8e35311 FC |
3795 | Several memory leaks in cloning and freeing threaded Perl interpreters have been |
3796 | fixed [perl #77352]. | |
6d96b0fe | 3797 | |
5076a392 | 3798 | =item * |
6d96b0fe | 3799 | |
e8e35311 FC |
3800 | Creating a new thread when directory handles were open used to cause a |
3801 | crash, because the handles were not cloned, but simply passed to the new | |
3802 | thread, resulting in a double free. | |
3803 | ||
3804 | Now directory handles are cloned properly, on systems that have a C<fchdir> | |
3805 | function. On other systems, new threads simply do not inherit directory | |
3806 | handles from their parent threads [perl #75154]. | |
6d96b0fe | 3807 | |
5076a392 | 3808 | =item * |
b7188eb5 | 3809 | |
e8e35311 FC |
3810 | The typeglob C<*,>, which holds the scalar variable C<$,> (output field |
3811 | separator), had the wrong reference count in child threads. | |
b7188eb5 | 3812 | |
5076a392 | 3813 | =item * |
b7188eb5 | 3814 | |
e8e35311 FC |
3815 | [perl #78494] When pipes are shared between threads, the C<close> function |
3816 | (and any implicit close, such as on thread exit) no longer blocks. | |
3817 | ||
2c389f6c FC |
3818 | =item * |
3819 | ||
3820 | Perl now does a timely cleanup of SVs that are cloned into a new thread but | |
3821 | then discovered to be orphaned (i.e., their owners are I<not> cloned). This | |
3822 | eliminates several "scalars leaked" warnings when joining threads. | |
3823 | ||
e8e35311 FC |
3824 | =back |
3825 | ||
2c389f6c | 3826 | =head2 Scoping and Subroutines |
e8e35311 FC |
3827 | |
3828 | =over | |
44691e6f | 3829 | |
5076a392 | 3830 | =item * |
44691e6f | 3831 | |
2c389f6c | 3832 | Lvalue subroutines are again able to return copy-on-write scalars. This |
ec529ca2 | 3833 | had been broken since version 5.10.0 [perl #75656] (5.12.3). |
44691e6f | 3834 | |
5076a392 | 3835 | =item * |
44691e6f | 3836 | |
2c389f6c FC |
3837 | C<require> no longer causes C<caller> to return the wrong file name for |
3838 | the scope that called C<require> and other scopes higher up that had the | |
3839 | same file name [perl #68712]. | |
44691e6f | 3840 | |
5076a392 | 3841 | =item * |
b7188eb5 | 3842 | |
2c389f6c FC |
3843 | C<sort> with a ($$)-prototyped comparison routine used to cause the value |
3844 | of @_ to leak out of the sort. Taking a reference to @_ within the | |
3845 | sorting routine could cause a crash [perl #72334]. | |
b7188eb5 | 3846 | |
5076a392 | 3847 | =item * |
b7188eb5 | 3848 | |
2c389f6c FC |
3849 | Match variables (e.g., C<$1>) no longer persist between calls to a sort |
3850 | subroutine [perl #76026]. | |
b7188eb5 | 3851 | |
5076a392 | 3852 | =item * |
44691e6f | 3853 | |
2c389f6c FC |
3854 | Iterating with C<foreach> over an array returned by an lvalue sub now works |
3855 | [perl #23790]. | |
6c9cd4a1 | 3856 | |
5076a392 | 3857 | =item * |
6c9cd4a1 | 3858 | |
2c389f6c FC |
3859 | C<$@> is now localised during calls to C<binmode> to prevent action at a |
3860 | distance [perl #78844]. | |
44691e6f | 3861 | |
5076a392 | 3862 | =item * |
44691e6f | 3863 | |
2c389f6c FC |
3864 | Calling a closure prototype (what is passed to an attribute handler for a |
3865 | closure) now results in a "Closure prototype called" error message instead | |
3866 | of a crash [perl #68560]. | |
44691e6f | 3867 | |
5076a392 | 3868 | =item * |
44691e6f | 3869 | |
2c389f6c FC |
3870 | Mentioning a read-only lexical variable from the enclosing scope in a |
3871 | string C<eval> no longer causes the variable to become writable | |
3872 | [perl #19135]. | |
3873 | ||
3874 | =back | |
3875 | ||
3876 | =head2 Signals | |
3877 | ||
3878 | =over | |
b7188eb5 FC |
3879 | |
3880 | =item * | |
3881 | ||
2c389f6c | 3882 | Within signal handlers, C<$!> is now implicitly localized. |
b7188eb5 | 3883 | |
5076a392 | 3884 | =item * |
b7188eb5 | 3885 | |
2c389f6c FC |
3886 | CHLD signals are no longer unblocked after a signal handler is called if |
3887 | they were blocked before by C<POSIX::sigprocmask> [perl #82040]. | |
b7188eb5 | 3888 | |
5076a392 | 3889 | =item * |
b7188eb5 | 3890 | |
2c389f6c FC |
3891 | A signal handler called within a signal handler could cause leaks or |
3892 | double-frees. Now fixed. [perl #76248]. | |
b7188eb5 | 3893 | |
e8e35311 | 3894 | =back |
5076a392 | 3895 | |
2c389f6c | 3896 | =head2 Miscellaneous Memory Leaks |
e8e35311 FC |
3897 | |
3898 | =over | |
b7188eb5 FC |
3899 | |
3900 | =item * | |
3901 | ||
d430b8e7 | 3902 | Several memory leaks when loading XS modules were fixed (5.12.2). |
5076a392 FC |
3903 | |
3904 | =item * | |
3905 | ||
2c389f6c FC |
3906 | L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT">, |
3907 | L<pos()|perlfunc/"index STR,SUBSTR,POSITION">, L<keys()|perlfunc/"keys HASH">, | |
3908 | and L<vec()|perlfunc/"vec EXPR,OFFSET,BITS"> could, when used in combination | |
3909 | with lvalues, result in leaking the scalar value they operate on, and cause its | |
3910 | destruction to happen too late. This has now been fixed. | |
5076a392 FC |
3911 | |
3912 | =item * | |
3913 | ||
2c389f6c FC |
3914 | The postincrement and postdecrement operators, C<++> and C<-->, used to cause |
3915 | leaks when being used on references. This has now been fixed. | |
5076a392 FC |
3916 | |
3917 | =item * | |
3918 | ||
2c389f6c FC |
3919 | Nested C<map> and C<grep> blocks no longer leak memory when processing |
3920 | large lists [perl #48004]. | |
5076a392 FC |
3921 | |
3922 | =item * | |
3923 | ||
d430b8e7 | 3924 | C<use I<VERSION>> and C<no I<VERSION>> no longer leak memory [perl #78436] |
2c389f6c | 3925 | [perl #69050]. |
5076a392 | 3926 | |
2c389f6c | 3927 | =item * |
5076a392 | 3928 | |
2c389f6c FC |
3929 | C<.=> followed by C<< <> >> or C<readline> would leak memory if C<$/> |
3930 | contained characters beyond the octet range and the scalar assigned to | |
3931 | happened to be encoded as UTF8 internally [perl #72246]. | |
5076a392 FC |
3932 | |
3933 | =item * | |
3934 | ||
2c389f6c | 3935 | C<eval "BEGIN{die}"> no longer leaks memory on non-threaded builds. |
5076a392 | 3936 | |
2c389f6c | 3937 | =back |
e8e35311 | 3938 | |
2c389f6c FC |
3939 | =head2 Memory Corruption and Crashes |
3940 | ||
3941 | =over | |
5076a392 FC |
3942 | |
3943 | =item * | |
3944 | ||
2c389f6c | 3945 | glob() no longer crashes when %File::Glob:: is empty and |
d430b8e7 | 3946 | CORE::GLOBAL::glob isn't present [perl #75464] (5.12.2). |
5076a392 | 3947 | |
e8e35311 FC |
3948 | =item * |
3949 | ||
2c389f6c FC |
3950 | readline() has been fixed when interrupted by signals so it no longer |
3951 | returns the "same thing" as before or random memory. | |
5076a392 FC |
3952 | |
3953 | =item * | |
3954 | ||
2c389f6c FC |
3955 | When assigning a list with duplicated keys to a hash, the assignment used to |
3956 | return garbage and/or freed values: | |
3957 | ||
3958 | @a = %h = (list with some duplicate keys); | |
3959 | ||
3960 | This has now been fixed [perl #31865]. | |
5076a392 | 3961 | |
e8e35311 | 3962 | =item * |
5076a392 | 3963 | |
e8e35311 FC |
3964 | The mechanism for freeing objects in globs used to leave dangling |
3965 | pointers to freed SVs, meaning Perl users could see corrupted state | |
3966 | during destruction. | |
5076a392 | 3967 | |
e8e35311 | 3968 | Perl now only frees the affected slots of the GV, rather than freeing |
2c389f6c | 3969 | the GV itself. This makes sure that there are no dangling refs or |
e8e35311 | 3970 | corrupted state during destruction. |
5076a392 FC |
3971 | |
3972 | =item * | |
3973 | ||
2c389f6c FC |
3974 | The interpreter no longer crashes when freeing deeply-nested arrays of |
3975 | arrays. Hashes have not been fixed yet [perl #44225]. | |
5076a392 FC |
3976 | |
3977 | =item * | |
3978 | ||
e8e35311 FC |
3979 | Concatenating long strings under C<use encoding> no longer causes perl to |
3980 | crash [perl #78674]. | |
5076a392 FC |
3981 | |
3982 | =item * | |
3983 | ||
e8e35311 FC |
3984 | Calling C<< ->import >> on a class lacking an import method could corrupt |
3985 | the stack, resulting in strange behaviour. For instance, | |
3986 | ||
3987 | push @a, "foo", $b = bar->import; | |
3988 | ||
3989 | would assign 'foo' to C<$b> [perl #63790]. | |
5076a392 FC |
3990 | |
3991 | =item * | |
3992 | ||
e8e35311 FC |
3993 | The C<recv> function could crash when called with the MSG_TRUNC flag |
3994 | [perl #75082]. | |
5076a392 FC |
3995 | |
3996 | =item * | |
3997 | ||
e8e35311 FC |
3998 | C<formline> no longer crashes when passed a tainted format picture. It also |
3999 | taints C<$^A> now if its arguments are tainted [perl #79138]. | |
5076a392 | 4000 | |
cdc10f43 FC |
4001 | =item * |
4002 | ||
4003 | A bug in how we process filetest operations could cause a segfault. | |
4004 | Filetests don't always expect an op on the stack, so we now use | |
4005 | TOPs only if we're sure that we're not stat'ing the _ filehandle. | |
4006 | This is indicated by OPf_KIDS (as checked in ck_ftst) [perl #74542] | |
4007 | (5.12.1). | |
4008 | ||
d430b8e7 FC |
4009 | =item * |
4010 | ||
4011 | C<unpack()> now handles scalar context correctly for C<%32H> and C<%32u>, | |
4012 | fixing a potential crash. C<split()> would crash because the third item | |
4013 | on the stack wasn't the regular expression it expected. C<unpack("%2H", | |
4014 | ...)> would return both the unpacked result and the checksum on the stack, | |
4015 | as would C<unpack("%2u", ...)> [perl #73814] (5.12.2). | |
4016 | ||
2c389f6c | 4017 | =back |
5076a392 | 4018 | |
2c389f6c | 4019 | =head2 Fixes to Various Perl Operators |
5076a392 | 4020 | |
2c389f6c | 4021 | =over |
5076a392 FC |
4022 | |
4023 | =item * | |
4024 | ||
2c389f6c FC |
4025 | The C<&> C<|> C<^> bitwise operators no longer coerce read-only arguments |
4026 | [perl #20661]. | |
5076a392 FC |
4027 | |
4028 | =item * | |
4029 | ||
2c389f6c FC |
4030 | Stringifying a scalar containing -0.0 no longer has the affect of turning |
4031 | false into true [perl #45133]. | |
5076a392 | 4032 | |
e8e35311 FC |
4033 | =item * |
4034 | ||
4035 | Some numeric operators were converting integers to floating point, | |
4036 | resulting in loss of precision on 64-bit platforms [perl #77456]. | |
5076a392 FC |
4037 | |
4038 | =item * | |
4039 | ||
2c389f6c FC |
4040 | C<sprintf> was ignoring locales when called with constant arguments |
4041 | [perl #78632]. | |
e8e35311 FC |
4042 | |
4043 | =item * | |
4044 | ||
2c389f6c FC |
4045 | Combining the vector (%v) flag and dynamic precision would |
4046 | cause sprintf to confuse the order of its arguments, making it treat the | |
4047 | string as the precision and vice versa [perl #83194]. | |
1e463951 | 4048 | |
c71a852f | 4049 | =back |
b7188eb5 | 4050 | |
42a91c97 FC |
4051 | =head2 Bugs Relating to the C API |
4052 | ||
4053 | =over | |
4054 | ||
4055 | =item * | |
4056 | ||
4057 | The C-level C<lex_stuff_pvn> function would sometimes cause a spurious | |
4058 | syntax error on the last line of the file if it lacked a final semicolon | |
cdc10f43 | 4059 | [perl #74006] (5.12.1). |
42a91c97 FC |
4060 | |
4061 | =item * | |
4062 | ||
4063 | The C<eval_sv> and C<eval_pv> C functions now set C<$@> correctly when | |
4064 | there is a syntax error and no C<G_KEEPERR> flag, and never set it if the | |
4065 | C<G_KEEPERR> flag is present [perl #3719]. | |
4066 | ||
4067 | =item * | |
4068 | ||
4069 | The XS multicall API no longer causes subroutines to lose reference counts | |
4070 | if called via the multicall interface from within those very subroutines. | |
4071 | This affects modules like List::Util. Calling one of its functions with an | |
4072 | active subroutine as the first argument could cause a crash [perl #78070]. | |
4073 | ||
4074 | =item * | |
4075 | ||
4076 | The C<SvPVbyte> function available to XS modules now calls magic before | |
4077 | downgrading the SV, to avoid warnings about wide characters [perl #72398]. | |
4078 | ||
4079 | =item * | |
4080 | ||
4081 | The ref types in the typemap for XS bindings now support magical variables | |
4082 | [perl #72684]. | |
4083 | ||
4084 | =item * | |
4085 | ||
4086 | C<sv_catsv_flags> no longer calls C<mg_get> on its second argument (the | |
4087 | source string) if the flags passed to it do not include SV_GMAGIC. So it | |
4088 | now matches the documentation. | |
4089 | ||
2c389f6c FC |
4090 | =item * |
4091 | ||
4092 | C<my_strftime> no longer leaks memory. This fixes a memory leak in | |
4093 | C<POSIX::strftime> [perl #73520]. | |
4094 | ||
cdc10f43 FC |
4095 | =item * |
4096 | ||
4097 | XSUB.h now correctly redefines fgets under PERL_IMPLICIT_SYS [perl #55049] | |
4098 | (5.12.1). | |
4099 | ||
4100 | =item * | |
4101 | ||
4102 | XS code using C<fputc()> or C<fputs()>: on Windows could cause an error | |
4103 | due to their arguments being swapped [perl #72704] (5.12.1). | |
4104 | ||
d430b8e7 FC |
4105 | =item * |
4106 | ||
4107 | A possible segfault in the C<T_PRTOBJ> default typemap has been fixed | |
4108 | (5.12.2). | |
4109 | ||
4110 | =item * | |
4111 | ||
4112 | A bug that could cause "Unknown error" messages when | |
4113 | C<call_sv(code, G_EVAL)> is called from an XS destructor has been fixed | |
4114 | (5.12.2). | |
4115 | ||
42a91c97 FC |
4116 | =back |
4117 | ||
c71a852f | 4118 | =head1 Known Problems |
44691e6f | 4119 | |
7d43ecd2 FC |
4120 | XXX Many of these have probably already been solved. There are also |
4121 | unresolved BBC articles linked to #77718 that are awaiting CPAN | |
4122 | releases. These may need to be listed here. | |
98f866d8 FC |
4123 | See also #84444. Enbugger may also need to be listed if there is no new |
4124 | release in time (see #82152). | |
4125 | JJORE/overload-eval-0.08.tar.gz appears to be broken, too. See | |
4126 | http://www.nntp.perl.org/group/perl.perl5.porters/2010/11/msg165773.html | |
7d43ecd2 | 4127 | |
5076a392 | 4128 | =over 4 |
994ae753 | 4129 | |
5076a392 | 4130 | =item * |
994ae753 | 4131 | |
cdc10f43 FC |
4132 | C<List::Util::first> misbehaves in the presence of a lexical C<$_> |
4133 | (typically introduced by C<my $_> or implicitly by C<given>). The variable | |
4134 | which gets set for each iteration is the package variable C<$_>, not the | |
4135 | lexical C<$_>. | |
4136 | ||
4137 | A similar issue may occur in other modules that provide functions which | |
4138 | take a block as their first argument, like | |
4139 | ||
4140 | foo { ... $_ ...} list | |
4141 | ||
4142 | See also: L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=67694> | |
4143 | ||
4144 | =item * | |
4145 | ||
5076a392 FC |
4146 | readline() returns an empty string instead of undef when it is |
4147 | interrupted by a signal | |
c094a73d | 4148 | |
ca767864 JD |
4149 | =item * |
4150 | ||
5076a392 FC |
4151 | Test-Harness was updated from 3.17 to 3.21 for this release. A rewrite |
4152 | in how it handles non-Perl tests (in 3.17_01) broke argument passing to | |
4153 | non-Perl tests with L<prove> (RT #59186), and required that non-Perl | |
4154 | tests be run as C<prove ./test.sh> instead of C<prove test.sh> These | |
4155 | issues are being solved upstream, but didn't make it into this release. | |
4156 | They're expected to be fixed in time for perl v5.13.4. (RT #59457) | |
4157 | ||
4158 | =item * | |
4159 | ||
4160 | C<version> now prevents object methods from being called as class methods | |
4161 | (d808b68) | |
4162 | ||
4163 | =item * | |
4164 | ||
4165 | The changes in L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT"> | |
4166 | broke C<HTML::Parser> <= 3.66. A fixed C<HTML::Parser> is available as versions | |
4167 | 3.67 on CPAN. | |
4168 | ||
4169 | =item * | |
4170 | ||
4171 | The changes in prototype handling break C<Switch>. A patch has been sent | |
4172 | upstream and will hopefully appear on CPAN soon. | |
4173 | ||
4174 | =item * | |
4175 | ||
4176 | The upgrade to Encode-2.40 has caused some tests in the libwww-perl distribution | |
4177 | on CPAN to fail. (Specifically, F<base/message-charset.t> tests 33-36 in version | |
4178 | 5.836 of that distribution now fail.) | |
4179 | ||
4180 | =item * | |
4181 | ||
4182 | The upgrade to ExtUtils-MakeMaker-6.57_05 has caused some tests in the | |
4183 | Module-Install distribution on CPAN to fail. (Specifically, F<02_mymeta.t> tests | |
4184 | 5 and 21, F<18_all_from.t> tests 6 and 15, F<19_authors.t> tests 5, 13, 21 and | |
4185 | 29, and F<20_authors_with_special_characters.t> tests 6, 15 and 23 in version | |
4186 | 1.00 of that distribution now fail.) | |
ca767864 | 4187 | |
c71a852f | 4188 | =back |
014fb485 | 4189 | |
5076a392 FC |
4190 | =head1 Errata |
4191 | ||
c21445df | 4192 | =head2 C<keys>, C<values> and C<each> work on arrays |
df91d470 FC |
4193 | |
4194 | You can now use the C<keys>, C<values>, C<each> builtin functions on arrays | |
4195 | (previously you could only use them on hashes). See L<perlfunc> for details. | |
4196 | This is actually a change introduced in perl 5.12.0, but it was missed from | |
4197 | that release's perldelta. | |
5076a392 | 4198 | |
c71a852f | 4199 | =head1 Obituary |
014fb485 | 4200 | |
5076a392 FC |
4201 | Randy Kobes, creator of the kobesearch alternative to search.cpan.org and |
4202 | contributor/maintainer to several core Perl toolchain modules, passed away | |
4203 | on September 18, 2010 after a battle with lung cancer. His contributions | |
4204 | to the Perl community will be missed. | |
44691e6f | 4205 | |
44691e6f AB |
4206 | =head1 Acknowledgements |
4207 | ||
c71a852f | 4208 | XXX The list of people to thank goes here. |
44691e6f AB |
4209 | |
4210 | =head1 Reporting Bugs | |
4211 | ||
4212 | If you find what you think is a bug, you might check the articles | |
4213 | recently posted to the comp.lang.perl.misc newsgroup and the perl | |
4214 | bug database at http://rt.perl.org/perlbug/ . There may also be | |
4215 | information at http://www.perl.org/ , the Perl Home Page. | |
4216 | ||
4217 | If you believe you have an unreported bug, please run the L<perlbug> | |
4218 | program included with your release. Be sure to trim your bug down | |
4219 | to a tiny but sufficient test case. Your bug report, along with the | |
4220 | output of C<perl -V>, will be sent off to perlbug@perl.org to be | |
4221 | analysed by the Perl porting team. | |
4222 | ||
4223 | If the bug you are reporting has security implications, which make it | |
4224 | inappropriate to send to a publicly archived mailing list, then please send | |
4225 | it to perl5-security-report@perl.org. This points to a closed subscription | |
4226 | unarchived mailing list, which includes all the core committers, who be able | |
4227 | to help assess the impact of issues, figure out a resolution, and help | |
4228 | co-ordinate the release of patches to mitigate or fix the problem across all | |
4229 | platforms on which Perl is supported. Please only use this address for | |
4230 | security issues in the Perl core, not for modules independently | |
4231 | distributed on CPAN. | |
4232 | ||
4233 | =head1 SEE ALSO | |
4234 | ||
4235 | The F<Changes> file for an explanation of how to view exhaustive details | |
4236 | on what changed. | |
4237 | ||
4238 | The F<INSTALL> file for how to build Perl. | |
4239 | ||
4240 | The F<README> file for general stuff. | |
4241 | ||
4242 | The F<Artistic> and F<Copying> files for copyright information. | |
4243 | ||
4244 | =cut |