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