| =encoding utf8 |
| |
| =head1 NAME |
| |
| perl5140delta - what is new for perl v5.14.0 |
| |
| =head1 DESCRIPTION |
| |
| This document describes differences between the 5.12.0 release and |
| the 5.14.0 release. |
| |
| If you are upgrading from an earlier release such as 5.10.0, first read |
| L<perl5120delta>, which describes differences between 5.10.0 and |
| 5.12.0. |
| |
| Some of the bug fixes in this release have been backported to subsequent |
| releases of 5.12.x. Those are indicated with the 5.12.x version in |
| parentheses. |
| |
| =head1 Notice |
| |
| As described in L<perlpolicy>, the release of Perl 5.14.0 marks the |
| official end of support for Perl 5.10. Users of Perl 5.10 or earlier |
| should consider upgrading to a more recent release of Perl. |
| |
| =head1 Core Enhancements |
| |
| =head2 Unicode |
| |
| =head3 Unicode Version 6.0 is now supported (mostly) |
| |
| Perl comes with the Unicode 6.0 data base updated with |
| L<Corrigendum #8|http://www.unicode.org/versions/corrigendum8.html>, |
| with one exception noted below. |
| See L<http://unicode.org/versions/Unicode6.0.0/> for details on the new |
| release. Perl does not support any Unicode provisional properties, |
| including the new ones for this release. |
| |
| Unicode 6.0 has chosen to use the name C<BELL> for the character at U+1F514, |
| which is a symbol that looks like a bell, and is used in Japanese cell |
| phones. This conflicts with the long-standing Perl usage of having |
| C<BELL> mean the ASCII C<BEL> character, U+0007. In Perl 5.14, |
| C<\N{BELL}> continues to mean U+0007, but its use generates a |
| deprecation warning message unless such warnings are turned off. The |
| new name for U+0007 in Perl is C<ALERT>, which corresponds nicely |
| with the existing shorthand sequence for it, C<"\a">. C<\N{BEL}> |
| means U+0007, with no warning given. The character at U+1F514 has no |
| name in 5.14, but can be referred to by C<\N{U+1F514}>. |
| In Perl 5.16, C<\N{BELL}> will refer to U+1F514; all code |
| that uses C<\N{BELL}> should be converted to use C<\N{ALERT}>, |
| C<\N{BEL}>, or C<"\a"> before upgrading. |
| |
| =head3 Full functionality for C<use feature 'unicode_strings'> |
| |
| This release provides full functionality for C<use feature |
| 'unicode_strings'>. Under its scope, all string operations executed and |
| regular expressions compiled (even if executed outside its scope) have |
| Unicode semantics. See L<feature/"the 'unicode_strings' feature">. |
| However, see L</Inverted bracketed character classes and multi-character folds>, |
| below. |
| |
| This feature avoids most forms of the "Unicode Bug" (see |
| L<perlunicode/The "Unicode Bug"> for details). If there is any |
| possibility that your code will process Unicode strings, you are |
| I<strongly> encouraged to use this subpragma to avoid nasty surprises. |
| |
| =head3 C<\N{I<NAME>}> and C<charnames> enhancements |
| |
| =over |
| |
| =item * |
| |
| C<\N{I<NAME>}> and C<charnames::vianame> now know about the abbreviated |
| character names listed by Unicode, such as NBSP, SHY, LRO, ZWJ, etc.; all |
| customary abbreviations for the C0 and C1 control characters (such as |
| ACK, BEL, CAN, etc.); and a few new variants of some C1 full names that |
| are in common usage. |
| |
| =item * |
| |
| Unicode has several I<named character sequences>, in which particular sequences |
| of code points are given names. C<\N{I<NAME>}> now recognizes these. |
| |
| =item * |
| |
| C<\N{I<NAME>}>, C<charnames::vianame>, and C<charnames::viacode> |
| now know about every character in Unicode. In earlier releases of |
| Perl, they didn't know about the Hangul syllables nor several |
| CJK (Chinese/Japanese/Korean) characters. |
| |
| =item * |
| |
| It is now possible to override Perl's abbreviations with your own custom aliases. |
| |
| =item * |
| |
| You can now create a custom alias of the ordinal of a |
| character, known by C<\N{I<NAME>}>, C<charnames::vianame()>, and |
| C<charnames::viacode()>. Previously, aliases had to be to official |
| Unicode character names. This made it impossible to create an alias for |
| unnamed code points, such as those reserved for private |
| use. |
| |
| =item * |
| |
| The new function charnames::string_vianame() is a run-time version |
| of C<\N{I<NAME>}}>, returning the string of characters whose Unicode |
| name is its parameter. It can handle Unicode named character |
| sequences, whereas the pre-existing charnames::vianame() cannot, |
| as the latter returns a single code point. |
| |
| =back |
| |
| See L<charnames> for details on all these changes. |
| |
| =head3 New warnings categories for problematic (non-)Unicode code points. |
| |
| Three new warnings subcategories of "utf8" have been added. These |
| allow you to turn off some "utf8" warnings, while allowing |
| other warnings to remain on. The three categories are: |
| C<surrogate> when UTF-16 surrogates are encountered; |
| C<nonchar> when Unicode non-character code points are encountered; |
| and C<non_unicode> when code points above the legal Unicode |
| maximum of 0x10FFFF are encountered. |
| |
| =head3 Any unsigned value can be encoded as a character |
| |
| With this release, Perl is adopting a model that any unsigned value |
| can be treated as a code point and encoded internally (as utf8) |
| without warnings, not just the code points that are legal in Unicode. |
| However, unless utf8 or the corresponding sub-category (see previous |
| item) of lexical warnings have been explicitly turned off, outputting |
| or executing a Unicode-defined operation such as upper-casing |
| on such a code point generates a warning. Attempting to input these |
| using strict rules (such as with the C<:encoding(UTF-8)> layer) |
| will continue to fail. Prior to this release, handling was |
| inconsistent and in places, incorrect. |
| |
| Unicode non-characters, some of which previously were erroneously |
| considered illegal in places by Perl, contrary to the Unicode Standard, |
| are now always legal internally. Inputting or outputting them |
| works the same as with the non-legal Unicode code points, because the Unicode |
| Standard says they are (only) illegal for "open interchange". |
| |
| =head3 Unicode database files not installed |
| |
| The Unicode database files are no longer installed with Perl. This |
| doesn't affect any functionality in Perl and saves significant disk |
| space. If you need these files, you can download them from |
| L<http://www.unicode.org/Public/zipped/6.0.0/>. |
| |
| =head2 Regular Expressions |
| |
| =head3 C<(?^...)> construct signifies default modifiers |
| |
| An ASCII caret C<"^"> immediately following a C<"(?"> in a regular |
| expression now means that the subexpression does not inherit surrounding |
| modifiers such as C</i>, but reverts to the Perl defaults. Any modifiers |
| following the caret override the defaults. |
| |
| Stringification of regular expressions now uses this notation. |
| For example, C<qr/hlagh/i> would previously be stringified as |
| C<(?i-xsm:hlagh)>, but now it's stringified as C<(?^i:hlagh)>. |
| |
| The main purpose of this change is to allow tests that rely on the |
| stringification I<not> to have to change whenever new modifiers are added. |
| See L<perlre/Extended Patterns>. |
| |
| This change is likely to break code that compares stringified regular |
| expressions with fixed strings containing C<?-xism>. |
| |
| =head3 C</d>, C</l>, C</u>, and C</a> modifiers |
| |
| Four new regular expression modifiers have been added. These are mutually |
| exclusive: one only can be turned on at a time. |
| |
| =over |
| |
| =item * |
| |
| The C</l> modifier says to compile the regular expression as if it were |
| in the scope of C<use locale>, even if it is not. |
| |
| =item * |
| |
| The C</u> modifier says to compile the regular expression as if it were |
| in the scope of a C<use feature 'unicode_strings'> pragma. |
| |
| =item * |
| |
| The C</d> (default) modifier is used to override any C<use locale> and |
| C<use feature 'unicode_strings'> pragmas in effect at the time |
| of compiling the regular expression. |
| |
| =item * |
| |
| The C</a> regular expression modifier restricts C<\s>, C<\d> and C<\w> and |
| the POSIX (C<[[:posix:]]>) character classes to the ASCII range. Their |
| complements and C<\b> and C<\B> are correspondingly |
| affected. Otherwise, C</a> behaves like the C</u> modifier, in that |
| case-insensitive matching uses Unicode semantics. |
| |
| If the C</a> modifier is repeated, then additionally in case-insensitive |
| matching, no ASCII character can match a non-ASCII character. |
| For example, |
| |
| "k" =~ /\N{KELVIN SIGN}/ai |
| "\xDF" =~ /ss/ai |
| |
| match but |
| |
| "k" =~ /\N{KELVIN SIGN}/aai |
| "\xDF" =~ /ss/aai |
| |
| do not match. |
| |
| =back |
| |
| See L<perlre/Modifiers> for more detail. |
| |
| =head3 Non-destructive substitution |
| |
| The substitution (C<s///>) and transliteration |
| (C<y///>) operators now support an C</r> option that |
| copies the input variable, carries out the substitution on |
| the copy, and returns the result. The original remains unmodified. |
| |
| my $old = "cat"; |
| my $new = $old =~ s/cat/dog/r; |
| # $old is "cat" and $new is "dog" |
| |
| This is particularly useful with C<map>. See L<perlop> for more examples. |
| |
| =head3 Re-entrant regular expression engine |
| |
| It is now safe to use regular expressions within C<(?{...})> and |
| C<(??{...})> code blocks inside regular expressions. |
| |
| These blocks are still experimental, however, and still have problems with |
| lexical (C<my>) variables and abnormal exiting. |
| |
| =head3 C<use re '/flags'> |
| |
| The C<re> pragma now has the ability to turn on regular expression flags |
| till the end of the lexical scope: |
| |
| use re "/x"; |
| "foo" =~ / (.+) /; # /x implied |
| |
| See L<re/"'/flags' mode"> for details. |
| |
| =head3 \o{...} for octals |
| |
| There is a new octal escape sequence, C<"\o">, in doublequote-like |
| contexts. This construct allows large octal ordinals beyond the |
| current max of 0777 to be represented. It also allows you to specify a |
| character in octal which can safely be concatenated with other regex |
| snippets and which won't be confused with being a backreference to |
| a regex capture group. See L<perlre/Capture groups>. |
| |
| =head3 Add C<\p{Titlecase}> as a synonym for C<\p{Title}> |
| |
| This synonym is added for symmetry with the Unicode property names |
| C<\p{Uppercase}> and C<\p{Lowercase}>. |
| |
| =head3 Regular expression debugging output improvement |
| |
| Regular expression debugging output (turned on by C<use re 'debug'>) now |
| uses hexadecimal when escaping non-ASCII characters, instead of octal. |
| |
| =head3 Return value of C<delete $+{...}> |
| |
| Custom regular expression engines can now determine the return value of |
| C<delete> on an entry of C<%+> or C<%->. |
| |
| =head2 Syntactical Enhancements |
| |
| =head3 Array and hash container functions accept references |
| |
| B<Warning:> This feature is considered experimental, as the exact behaviour |
| may change in a future version of Perl. |
| |
| All builtin functions that operate directly on array or hash |
| containers now also accept unblessed hard references to arrays |
| or hashes: |
| |
| |----------------------------+---------------------------| |
| | Traditional syntax | Terse syntax | |
| |----------------------------+---------------------------| |
| | push @$arrayref, @stuff | push $arrayref, @stuff | |
| | unshift @$arrayref, @stuff | unshift $arrayref, @stuff | |
| | pop @$arrayref | pop $arrayref | |
| | shift @$arrayref | shift $arrayref | |
| | splice @$arrayref, 0, 2 | splice $arrayref, 0, 2 | |
| | keys %$hashref | keys $hashref | |
| | keys @$arrayref | keys $arrayref | |
| | values %$hashref | values $hashref | |
| | values @$arrayref | values $arrayref | |
| | ($k,$v) = each %$hashref | ($k,$v) = each $hashref | |
| | ($k,$v) = each @$arrayref | ($k,$v) = each $arrayref | |
| |----------------------------+---------------------------| |
| |
| This allows these builtin functions to act on long dereferencing chains |
| or on the return value of subroutines without needing to wrap them in |
| C<@{}> or C<%{}>: |
| |
| push @{$obj->tags}, $new_tag; # old way |
| push $obj->tags, $new_tag; # new way |
| |
| for ( keys %{$hoh->{genres}{artists}} ) {...} # old way |
| for ( keys $hoh->{genres}{artists} ) {...} # new way |
| |
| =head3 Single term prototype |
| |
| The C<+> prototype is a special alternative to C<$> that acts like |
| C<\[@%]> when given a literal array or hash variable, but will otherwise |
| force scalar context on the argument. See L<perlsub/Prototypes>. |
| |
| =head3 C<package> block syntax |
| |
| A package declaration can now contain a code block, in which case the |
| declaration is in scope inside that block only. So C<package Foo { ... }> |
| is precisely equivalent to C<{ package Foo; ... }>. It also works with |
| a version number in the declaration, as in C<package Foo 1.2 { ... }>, |
| which is its most attractive feature. See L<perlfunc>. |
| |
| =head3 Statement labels can appear in more places |
| |
| Statement labels can now occur before any type of statement or declaration, |
| such as C<package>. |
| |
| =head3 Stacked labels |
| |
| Multiple statement labels can now appear before a single statement. |
| |
| =head3 Uppercase X/B allowed in hexadecimal/binary literals |
| |
| Literals may now use either upper case C<0X...> or C<0B...> prefixes, |
| in addition to the already supported C<0x...> and C<0b...> |
| syntax [perl #76296]. |
| |
| C, Ruby, Python, and PHP already support this syntax, and it makes |
| Perl more internally consistent: a round-trip with C<eval sprintf |
| "%#X", 0x10> now returns C<16>, just like C<eval sprintf "%#x", 0x10>. |
| |
| =head3 Overridable tie functions |
| |
| C<tie>, C<tied> and C<untie> can now be overridden [perl #75902]. |
| |
| =head2 Exception Handling |
| |
| To make them more reliable and consistent, several changes have been made |
| to how C<die>, C<warn>, and C<$@> behave. |
| |
| =over |
| |
| =item * |
| |
| When an exception is thrown inside an C<eval>, the exception is no |
| longer at risk of being clobbered by destructor code running during unwinding. |
| Previously, the exception was written into C<$@> |
| early in the throwing process, and would be overwritten if C<eval> was |
| used internally in the destructor for an object that had to be freed |
| while exiting from the outer C<eval>. Now the exception is written |
| into C<$@> last thing before exiting the outer C<eval>, so the code |
| running immediately thereafter can rely on the value in C<$@> correctly |
| corresponding to that C<eval>. (C<$@> is still also set before exiting the |
| C<eval>, for the sake of destructors that rely on this.) |
| |
| Likewise, a C<local $@> inside an C<eval> no longer clobbers any |
| exception thrown in its scope. Previously, the restoration of C<$@> upon |
| unwinding would overwrite any exception being thrown. Now the exception |
| gets to the C<eval> anyway. So C<local $@> is safe before a C<die>. |
| |
| Exceptions thrown from object destructors no longer modify the C<$@> |
| of the surrounding context. (If the surrounding context was exception |
| unwinding, this used to be another way to clobber the exception being |
| thrown.) Previously such an exception was |
| sometimes emitted as a warning, and then either was |
| string-appended to the surrounding C<$@> or completely replaced the |
| surrounding C<$@>, depending on whether that exception and the surrounding |
| C<$@> were strings or objects. Now, an exception in this situation is |
| always emitted as a warning, leaving the surrounding C<$@> untouched. |
| In addition to object destructors, this also affects any function call |
| run by XS code using the C<G_KEEPERR> flag. |
| |
| =item * |
| |
| Warnings for C<warn> can now be objects in the same way as exceptions |
| for C<die>. If an object-based warning gets the default handling |
| of writing to standard error, it is stringified as before with the |
| filename and line number appended. But a C<$SIG{__WARN__}> handler now |
| receives an object-based warning as an object, where previously it |
| was passed the result of stringifying the object. |
| |
| =back |
| |
| =head2 Other Enhancements |
| |
| =head3 Assignment to C<$0> sets the legacy process name with prctl() on Linux |
| |
| On Linux the legacy process name is now set with L<prctl(2)>, in |
| addition to altering the POSIX name via C<argv[0]>, as Perl has done |
| since version 4.000. Now system utilities that read the legacy process |
| name such as I<ps>, I<top>, and I<killall> recognize the name you set when |
| assigning to C<$0>. The string you supply is truncated at 16 bytes; |
| this limitation is imposed by Linux. |
| |
| =head3 srand() now returns the seed |
| |
| This allows programs that need to have repeatable results not to have to come |
| up with their own seed-generating mechanism. Instead, they can use srand() |
| and stash the return value for future use. One example is a test program with |
| too many combinations to test comprehensively in the time available for |
| each run. It can test a random subset each time and, should there be a failure, |
| log the seed used for that run so this can later be used to produce the same results. |
| |
| =head3 printf-like functions understand post-1980 size modifiers |
| |
| Perl's printf and sprintf operators, and Perl's internal printf replacement |
| function, now understand the C90 size modifiers "hh" (C<char>), "z" |
| (C<size_t>), and "t" (C<ptrdiff_t>). Also, when compiled with a C99 |
| compiler, Perl now understands the size modifier "j" (C<intmax_t>) |
| (but this is not portable). |
| |
| So, for example, on any modern machine, C<sprintf("%hhd", 257)> returns "1". |
| |
| =head3 New global variable C<${^GLOBAL_PHASE}> |
| |
| A new global variable, C<${^GLOBAL_PHASE}>, has been added to allow |
| introspection of the current phase of the Perl interpreter. It's explained in |
| detail in L<perlvar/"${^GLOBAL_PHASE}"> and in |
| L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT and END">. |
| |
| =head3 C<-d:-foo> calls C<Devel::foo::unimport> |
| |
| The syntax B<-d:foo> was extended in 5.6.1 to make B<-d:foo=bar> |
| equivalent to B<-MDevel::foo=bar>, which expands |
| internally to C<use Devel::foo 'bar'>. |
| Perl now allows prefixing the module name with B<->, with the same |
| semantics as B<-M>; that is: |
| |
| =over 4 |
| |
| =item C<-d:-foo> |
| |
| Equivalent to B<-M-Devel::foo>: expands to |
| C<no Devel::foo> and calls C<< Devel::foo->unimport() >> |
| if that method exists. |
| |
| =item C<-d:-foo=bar> |
| |
| Equivalent to B<-M-Devel::foo=bar>: expands to C<no Devel::foo 'bar'>, |
| and calls C<< Devel::foo->unimport("bar") >> if that method exists. |
| |
| =back |
| |
| This is particularly useful for suppressing the default actions of a |
| C<Devel::*> module's C<import> method whilst still loading it for debugging. |
| |
| =head3 Filehandle method calls load L<IO::File> on demand |
| |
| When a method call on a filehandle would die because the method cannot |
| be resolved and L<IO::File> has not been loaded, Perl now loads L<IO::File> |
| via C<require> and attempts method resolution again: |
| |
| open my $fh, ">", $file; |
| $fh->binmode(":raw"); # loads IO::File and succeeds |
| |
| This also works for globs like C<STDOUT>, C<STDERR>, and C<STDIN>: |
| |
| STDOUT->autoflush(1); |
| |
| Because this on-demand load happens only if method resolution fails, the |
| legacy approach of manually loading an L<IO::File> parent class for partial |
| method support still works as expected: |
| |
| use IO::Handle; |
| open my $fh, ">", $file; |
| $fh->autoflush(1); # IO::File not loaded |
| |
| =head3 Improved IPv6 support |
| |
| The C<Socket> module provides new affordances for IPv6, |
| including implementations of the C<Socket::getaddrinfo()> and |
| C<Socket::getnameinfo()> functions, along with related constants and a |
| handful of new functions. See L<Socket>. |
| |
| =head3 DTrace probes now include package name |
| |
| The C<DTrace> probes now include an additional argument, C<arg3>, which contains |
| the package the subroutine being entered or left was compiled in. |
| |
| For example, using the following DTrace script: |
| |
| perl$target:::sub-entry |
| { |
| printf("%s::%s\n", copyinstr(arg0), copyinstr(arg3)); |
| } |
| |
| and then running: |
| |
| $ perl -e 'sub test { }; test' |
| |
| C<DTrace> will print: |
| |
| main::test |
| |
| =head2 New C APIs |
| |
| See L</Internal Changes>. |
| |
| =head1 Security |
| |
| =head2 User-defined regular expression properties |
| |
| L<perlunicode/"User-Defined Character Properties"> documented that you can |
| create custom properties by defining subroutines whose names begin with |
| "In" or "Is". However, Perl did not actually enforce that naming |
| restriction, so C<\p{foo::bar}> could call foo::bar() if it existed. The documented |
| convention is now enforced. |
| |
| Also, Perl no longer allows tainted regular expressions to invoke a |
| user-defined property. It simply dies instead [perl #82616]. |
| |
| =head1 Incompatible Changes |
| |
| Perl 5.14.0 is not binary-compatible with any previous stable release. |
| |
| In addition to the sections that follow, see L</C API Changes>. |
| |
| =head2 Regular Expressions and String Escapes |
| |
| =head3 Inverted bracketed character classes and multi-character folds |
| |
| Some characters match a sequence of two or three characters in C</i> |
| regular expression matching under Unicode rules. One example is |
| C<LATIN SMALL LETTER SHARP S> which matches the sequence C<ss>. |
| |
| 'ss' =~ /\A[\N{LATIN SMALL LETTER SHARP S}]\z/i # Matches |
| |
| This, however, can lead to very counter-intuitive results, especially |
| when inverted. Because of this, Perl 5.14 does not use multi-character C</i> |
| matching in inverted character classes. |
| |
| 'ss' =~ /\A[^\N{LATIN SMALL LETTER SHARP S}]+\z/i # ??? |
| |
| This should match any sequences of characters that aren't the C<SHARP S> |
| nor what C<SHARP S> matches under C</i>. C<"s"> isn't C<SHARP S>, but |
| Unicode says that C<"ss"> is what C<SHARP S> matches under C</i>. So |
| which one "wins"? Do you fail the match because the string has C<ss> or |
| accept it because it has an C<s> followed by another C<s>? |
| |
| Earlier releases of Perl did allow this multi-character matching, |
| but due to bugs, it mostly did not work. |
| |
| =head3 \400-\777 |
| |
| In certain circumstances, C<\400>-C<\777> in regexes have behaved |
| differently than they behave in all other doublequote-like contexts. |
| Since 5.10.1, Perl has issued a deprecation warning when this happens. |
| Now, these literals behave the same in all doublequote-like contexts, |
| namely to be equivalent to C<\x{100}>-C<\x{1FF}>, with no deprecation |
| warning. |
| |
| Use of C<\400>-C<\777> in the command-line option B<-0> retain their |
| conventional meaning. They slurp whole input files; previously, this |
| was documented only for B<-0777>. |
| |
| Because of various ambiguities, you should use the new |
| C<\o{...}> construct to represent characters in octal instead. |
| |
| =head3 Most C<\p{}> properties are now immune to case-insensitive matching |
| |
| For most Unicode properties, it doesn't make sense to have them match |
| differently under C</i> case-insensitive matching. Doing so can lead |
| to unexpected results and potential security holes. For example |
| |
| m/\p{ASCII_Hex_Digit}+/i |
| |
| could previously match non-ASCII characters because of the Unicode |
| matching rules (although there were several bugs with this). Now |
| matching under C</i> gives the same results as non-C</i> matching except |
| for those few properties where people have come to expect differences, |
| namely the ones where casing is an integral part of their meaning, such |
| as C<m/\p{Uppercase}/i> and C<m/\p{Lowercase}/i>, both of which match |
| the same code points as matched by C<m/\p{Cased}/i>. |
| Details are in L<perlrecharclass/Unicode Properties>. |
| |
| User-defined property handlers that need to match differently under C</i> |
| must be changed to read the new boolean parameter passed to them, which |
| is non-zero if case-insensitive matching is in effect and 0 otherwise. |
| See L<perlunicode/User-Defined Character Properties>. |
| |
| =head3 \p{} implies Unicode semantics |
| |
| Specifying a Unicode property in the pattern indicates |
| that the pattern is meant for matching according to Unicode rules, the way |
| C<\N{I<NAME>}> does. |
| |
| =head3 Regular expressions retain their localeness when interpolated |
| |
| Regular expressions compiled under C<use locale> now retain this when |
| interpolated into a new regular expression compiled outside a |
| C<use locale>, and vice-versa. |
| |
| Previously, one regular expression interpolated into another inherited |
| the localeness of the surrounding regex, losing whatever state it |
| originally had. This is considered a bug fix, but may trip up code that |
| has come to rely on the incorrect behaviour. |
| |
| =head3 Stringification of regexes has changed |
| |
| Default regular expression modifiers are now notated using |
| C<(?^...)>. Code relying on the old stringification will fail. |
| This is so that when new modifiers are added, such code won't |
| have to keep changing each time this happens, because the stringification |
| will automatically incorporate the new modifiers. |
| |
| Code that needs to work properly with both old- and new-style regexes |
| can avoid the whole issue by using (for perls since 5.9.5; see L<re>): |
| |
| use re qw(regexp_pattern); |
| my ($pat, $mods) = regexp_pattern($re_ref); |
| |
| If the actual stringification is important or older Perls need to be |
| supported, you can use something like the following: |
| |
| # Accept both old and new-style stringification |
| my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? "^" : "-xism"; |
| |
| And then use C<$modifiers> instead of C<-xism>. |
| |
| =head3 Run-time code blocks in regular expressions inherit pragmata |
| |
| Code blocks in regular expressions (C<(?{...})> and C<(??{...})>) previously |
| did not inherit pragmata (strict, warnings, etc.) if the regular expression |
| was compiled at run time as happens in cases like these two: |
| |
| use re "eval"; |
| $foo =~ $bar; # when $bar contains (?{...}) |
| $foo =~ /$bar(?{ $finished = 1 })/; |
| |
| This bug has now been fixed, but code that relied on the buggy behaviour |
| may need to be fixed to account for the correct behaviour. |
| |
| =head2 Stashes and Package Variables |
| |
| =head3 Localised tied hashes and arrays are no longed tied |
| |
| In the following: |
| |
| tie @a, ...; |
| { |
| local @a; |
| # here, @a is a now a new, untied array |
| } |
| # here, @a refers again to the old, tied array |
| |
| Earlier versions of Perl incorrectly tied the new local array. This has |
| now been fixed. This fix could however potentially cause a change in |
| behaviour of some code. |
| |
| =head3 Stashes are now always defined |
| |
| C<defined %Foo::> now always returns true, even when no symbols have yet been |
| defined in that package. |
| |
| This is a side-effect of removing a special-case kludge in the tokeniser, |
| added for 5.10.0, to hide side-effects of changes to the internal storage of |
| hashes. The fix drastically reduces hashes' memory overhead. |
| |
| Calling defined on a stash has been deprecated since 5.6.0, warned on |
| lexicals since 5.6.0, and warned for stashes and other package |
| variables since 5.12.0. C<defined %hash> has always exposed an |
| implementation detail: emptying a hash by deleting all entries from it does |
| not make C<defined %hash> false. Hence C<defined %hash> is not valid code to |
| determine whether an arbitrary hash is empty. Instead, use the behaviour |
| of an empty C<%hash> always returning false in scalar context. |
| |
| =head3 Clearing stashes |
| |
| Stash list assignment C<%foo:: = ()> used to make the stash temporarily |
| anonymous while it was being emptied. Consequently, any of its |
| subroutines referenced elsewhere would become anonymous, showing up as |
| "(unknown)" in C<caller>. They now retain their package names such that |
| C<caller> returns the original sub name if there is still a reference |
| to its typeglob and "foo::__ANON__" otherwise [perl #79208]. |
| |
| =head3 Dereferencing typeglobs |
| |
| If you assign a typeglob to a scalar variable: |
| |
| $glob = *foo; |
| |
| the glob that is copied to C<$glob> is marked with a special flag |
| indicating that the glob is just a copy. This allows subsequent |
| assignments to C<$glob> to overwrite the glob. The original glob, |
| however, is immutable. |
| |
| Some Perl operators did not distinguish between these two types of globs. |
| This would result in strange behaviour in edge cases: C<untie $scalar> |
| would not untie the scalar if the last thing assigned to it was a glob |
| (because it treated it as C<untie *$scalar>, which unties a handle). |
| Assignment to a glob slot (such as C<*$glob = \@some_array>) would simply |
| assign C<\@some_array> to C<$glob>. |
| |
| To fix this, the C<*{}> operator (including its C<*foo> and C<*$foo> forms) |
| has been modified to make a new immutable glob if its operand is a glob |
| copy. This allows operators that make a distinction between globs and |
| scalars to be modified to treat only immutable globs as globs. (C<tie>, |
| C<tied> and C<untie> have been left as they are for compatibility's sake, |
| but will warn. See L</Deprecations>.) |
| |
| This causes an incompatible change in code that assigns a glob to the |
| return value of C<*{}> when that operator was passed a glob copy. Take the |
| following code, for instance: |
| |
| $glob = *foo; |
| *$glob = *bar; |
| |
| The C<*$glob> on the second line returns a new immutable glob. That new |
| glob is made an alias to C<*bar>. Then it is discarded. So the second |
| assignment has no effect. |
| |
| See L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=77810> for |
| more detail. |
| |
| =head3 Magic variables outside the main package |
| |
| In previous versions of Perl, magic variables like C<$!>, C<%SIG>, etc. would |
| "leak" into other packages. So C<%foo::SIG> could be used to access signals, |
| C<${"foo::!"}> (with strict mode off) to access C's C<errno>, etc. |
| |
| This was a bug, or an "unintentional" feature, which caused various ill effects, |
| such as signal handlers being wiped when modules were loaded, etc. |
| |
| This has been fixed (or the feature has been removed, depending on how you see |
| it). |
| |
| =head3 local($_) strips all magic from $_ |
| |
| local() on scalar variables gives them a new value but keeps all |
| their magic intact. This has proven problematic for the default |
| scalar variable $_, where L<perlsub> recommends that any subroutine |
| that assigns to $_ should first localize it. This would throw an |
| exception if $_ is aliased to a read-only variable, and could in general have |
| various unintentional side-effects. |
| |
| Therefore, as an exception to the general rule, local($_) will not |
| only assign a new value to $_, but also remove all existing magic from |
| it as well. |
| |
| =head3 Parsing of package and variable names |
| |
| Parsing the names of packages and package variables has changed: |
| multiple adjacent pairs of colons, as in C<foo::::bar>, are now all |
| treated as package separators. |
| |
| Regardless of this change, the exact parsing of package separators has |
| never been guaranteed and is subject to change in future Perl versions. |
| |
| =head2 Changes to Syntax or to Perl Operators |
| |
| =head3 C<given> return values |
| |
| C<given> blocks now return the last evaluated |
| expression, or an empty list if the block was exited by C<break>. Thus you |
| can now write: |
| |
| my $type = do { |
| given ($num) { |
| break when undef; |
| "integer" when /^[+-]?[0-9]+$/; |
| "float" when /^[+-]?[0-9]+(?:\.[0-9]+)?$/; |
| "unknown"; |
| } |
| }; |
| |
| See L<perlsyn/Return value> for details. |
| |
| =head3 Change in parsing of certain prototypes |
| |
| Functions declared with the following prototypes now behave correctly as unary |
| functions: |
| |
| * |
| \$ \% \@ \* \& |
| \[...] |
| ;$ ;* |
| ;\$ ;\% etc. |
| ;\[...] |
| |
| Due to this bug fix [perl #75904], functions |
| using the C<(*)>, C<(;$)> and C<(;*)> prototypes |
| are parsed with higher precedence than before. So |
| in the following example: |
| |
| sub foo(;$); |
| foo $a < $b; |
| |
| the second line is now parsed correctly as C<< foo($a) < $b >>, rather than |
| C<< foo($a < $b) >>. This happens when one of these operators is used in |
| an unparenthesised argument: |
| |
| < > <= >= lt gt le ge |
| == != <=> eq ne cmp ~~ |
| & |
| | ^ |
| && |
| || // |
| .. ... |
| ?: |
| = += -= *= etc. |
| , => |
| |
| =head3 Smart-matching against array slices |
| |
| Previously, the following code resulted in a successful match: |
| |
| my @a = qw(a y0 z); |
| my @b = qw(a x0 z); |
| @a[0 .. $#b] ~~ @b; |
| |
| This odd behaviour has now been fixed [perl #77468]. |
| |
| =head3 Negation treats strings differently from before |
| |
| The unary negation operator, C<->, now treats strings that look like numbers |
| as numbers [perl #57706]. |
| |
| =head3 Negative zero |
| |
| Negative zero (-0.0), when converted to a string, now becomes "0" on all |
| platforms. It used to become "-0" on some, but "0" on others. |
| |
| If you still need to determine whether a zero is negative, use |
| C<sprintf("%g", $zero) =~ /^-/> or the L<Data::Float> module on CPAN. |
| |
| =head3 C<:=> is now a syntax error |
| |
| Previously C<my $pi := 4> was exactly equivalent to C<my $pi : = 4>, |
| with the C<:> being treated as the start of an attribute list, ending before |
| the C<=>. The use of C<:=> to mean C<: => was deprecated in 5.12.0, and is |
| now a syntax error. This allows future use of C<:=> as a new token. |
| |
| Outside the core's tests for it, we find no Perl 5 code on CPAN |
| using this construction, so we believe that this change will have |
| little impact on real-world codebases. |
| |
| If it is absolutely necessary to have empty attribute lists (for example, |
| because of a code generator), simply avoid the error by adding a space before |
| the C<=>. |
| |
| =head3 Change in the parsing of identifiers |
| |
| Characters outside the Unicode "XIDStart" set are no longer allowed at the |
| beginning of an identifier. This means that certain accents and marks |
| that normally follow an alphabetic character may no longer be the first |
| character of an identifier. |
| |
| =head2 Threads and Processes |
| |
| =head3 Directory handles not copied to threads |
| |
| On systems other than Windows that do not have |
| a C<fchdir> function, newly-created threads no |
| longer inherit directory handles from their parent threads. Such programs |
| would usually have crashed anyway [perl #75154]. |
| |
| =head3 C<close> on shared pipes |
| |
| To avoid deadlocks, the C<close> function no longer waits for the |
| child process to exit if the underlying file descriptor is still |
| in use by another thread. It returns true in such cases. |
| |
| =head3 fork() emulation will not wait for signalled children |
| |
| On Windows parent processes would not terminate until all forked |
| children had terminated first. However, C<kill("KILL", ...)> is |
| inherently unstable on pseudo-processes, and C<kill("TERM", ...)> |
| might not get delivered if the child is blocked in a system call. |
| |
| To avoid the deadlock and still provide a safe mechanism to terminate |
| the hosting process, Perl now no longer waits for children that |
| have been sent a SIGTERM signal. It is up to the parent process to |
| waitpid() for these children if child-cleanup processing must be |
| allowed to finish. However, it is also then the responsibility of the |
| parent to avoid the deadlock by making sure the child process |
| can't be blocked on I/O. |
| |
| See L<perlfork> for more information about the fork() emulation on |
| Windows. |
| |
| =head2 Configuration |
| |
| =head3 Naming fixes in Policy_sh.SH may invalidate Policy.sh |
| |
| Several long-standing typos and naming confusions in F<Policy_sh.SH> have |
| been fixed, standardizing on the variable names used in F<config.sh>. |
| |
| This will change the behaviour of F<Policy.sh> if you happen to have been |
| accidentally relying on its incorrect behaviour. |
| |
| =head3 Perl source code is read in text mode on Windows |
| |
| Perl scripts used to be read in binary mode on Windows for the benefit |
| of the L<ByteLoader> module (which is no longer part of core Perl). This |
| had the side-effect of breaking various operations on the C<DATA> filehandle, |
| including seek()/tell(), and even simply reading from C<DATA> after filehandles |
| have been flushed by a call to system(), backticks, fork() etc. |
| |
| The default build options for Windows have been changed to read Perl source |
| code on Windows in text mode now. L<ByteLoader> will (hopefully) be updated on |
| CPAN to automatically handle this situation [perl #28106]. |
| |
| =head1 Deprecations |
| |
| See also L</Deprecated C APIs>. |
| |
| =head2 Omitting a space between a regular expression and subsequent word |
| |
| Omitting the space between a regular expression operator or |
| its modifiers and the following word is deprecated. For |
| example, C<< m/foo/sand $bar >> is for now still parsed |
| as C<< m/foo/s and $bar >>, but will now issue a warning. |
| |
| =head2 C<\cI<X>> |
| |
| The backslash-c construct was designed as a way of specifying |
| non-printable characters, but there were no restrictions (on ASCII |
| platforms) on what the character following the C<c> could be. Now, |
| a deprecation warning is raised if that character isn't an ASCII character. |
| Also, a deprecation warning is raised for C<"\c{"> (which is the same |
| as simply saying C<";">). |
| |
| =head2 C<"\b{"> and C<"\B{"> |
| |
| In regular expressions, a literal C<"{"> immediately following a C<"\b"> |
| (not in a bracketed character class) or a C<"\B{"> is now deprecated |
| to allow for its future use by Perl itself. |
| |
| =head2 Perl 4-era .pl libraries |
| |
| Perl bundles a handful of library files that predate Perl 5. |
| This bundling is now deprecated for most of these files, which are now |
| available from CPAN. The affected files now warn when run, if they were |
| installed as part of the core. |
| |
| This is a mandatory warning, not obeying B<-X> or lexical warning bits. |
| The warning is modelled on that supplied by F<deprecate.pm> for |
| deprecated-in-core F<.pm> libraries. It points to the specific CPAN |
| distribution that contains the F<.pl> libraries. The CPAN versions, of |
| course, do not generate the warning. |
| |
| =head2 List assignment to C<$[> |
| |
| Assignment to C<$[> was deprecated and started to give warnings in |
| Perl version 5.12.0. This version of Perl (5.14) now also emits a warning |
| when assigning to C<$[> in list context. This fixes an oversight in 5.12.0. |
| |
| =head2 Use of qw(...) as parentheses |
| |
| Historically the parser fooled itself into thinking that C<qw(...)> literals |
| were always enclosed in parentheses, and as a result you could sometimes omit |
| parentheses around them: |
| |
| for $x qw(a b c) { ... } |
| |
| The parser no longer lies to itself in this way. Wrap the list literal in |
| parentheses like this: |
| |
| for $x (qw(a b c)) { ... } |
| |
| This is being deprecated because the parentheses in C<for $i (1,2,3) { ... }> |
| are not part of expression syntax. They are part of the statement |
| syntax, with the C<for> statement wanting literal parentheses. |
| The synthetic parentheses that a C<qw> expression acquired were only |
| intended to be treated as part of expression syntax. |
| |
| Note that this does not change the behaviour of cases like: |
| |
| use POSIX qw(setlocale localeconv); |
| our @EXPORT = qw(foo bar baz); |
| |
| where parentheses were never required around the expression. |
| |
| =head2 C<\N{BELL}> |
| |
| This is because Unicode is using that name for a different character. |
| See L</Unicode Version 6.0 is now supported (mostly)> for more |
| explanation. |
| |
| =head2 C<?PATTERN?> |
| |
| C<?PATTERN?> (without the initial C<m>) has been deprecated and now produces |
| a warning. This is to allow future use of C<?> in new operators. |
| The match-once functionality is still available as C<m?PATTERN?>. |
| |
| =head2 Tie functions on scalars holding typeglobs |
| |
| Calling a tie function (C<tie>, C<tied>, C<untie>) with a scalar argument |
| acts on a filehandle if the scalar happens to hold a typeglob. |
| |
| This is a long-standing bug that will be removed in Perl 5.16, as |
| there is currently no way to tie the scalar itself when it holds |
| a typeglob, and no way to untie a scalar that has had a typeglob |
| assigned to it. |
| |
| Now there is a deprecation warning whenever a tie |
| function is used on a handle without an explicit C<*>. |
| |
| =head2 User-defined case-mapping |
| |
| This feature is being deprecated due to its many issues, as documented in |
| L<perlunicode/User-Defined Case Mappings (for serious hackers only)>. |
| This feature will be removed in Perl 5.16. Instead use the CPAN module |
| L<Unicode::Casing>, which provides improved functionality. |
| |
| =head2 Deprecated modules |
| |
| The following module will be removed from the core distribution in a |
| future release, and should be installed from CPAN instead. Distributions |
| on CPAN that require this should add it to their prerequisites. The |
| core version of these module now issues a deprecation warning. |
| |
| If you ship a packaged version of Perl, either alone or as part of a |
| larger system, then you should carefully consider the repercussions of |
| core module deprecations. You may want to consider shipping your default |
| build of Perl with a package for the deprecated module that |
| installs into C<vendor> or C<site> Perl library directories. This will |
| inhibit the deprecation warnings. |
| |
| Alternatively, you may want to consider patching F<lib/deprecate.pm> |
| to provide deprecation warnings specific to your packaging system |
| or distribution of Perl, consistent with how your packaging system |
| or distribution manages a staged transition from a release where the |
| installation of a single package provides the given functionality, to |
| a later release where the system administrator needs to know to install |
| multiple packages to get that same functionality. |
| |
| You can silence these deprecation warnings by installing the module |
| in question from CPAN. To install the latest version of it by role |
| rather than by name, just install C<Task::Deprecations::5_14>. |
| |
| =over |
| |
| =item L<Devel::DProf> |
| |
| We strongly recommend that you install and use L<Devel::NYTProf> instead |
| of L<Devel::DProf>, as L<Devel::NYTProf> offers significantly |
| improved profiling and reporting. |
| |
| =back |
| |
| =head1 Performance Enhancements |
| |
| =head2 "Safe signals" optimisation |
| |
| Signal dispatch has been moved from the runloop into control ops. |
| This should give a few percent speed increase, and eliminates nearly |
| all the speed penalty caused by the introduction of "safe signals" |
| in 5.8.0. Signals should still be dispatched within the same |
| statement as they were previously. If this does I<not> happen, or |
| if you find it possible to create uninterruptible loops, this is a |
| bug, and reports are encouraged of how to recreate such issues. |
| |
| =head2 Optimisation of shift() and pop() calls without arguments |
| |
| Two fewer OPs are used for shift() and pop() calls with no argument (with |
| implicit C<@_>). This change makes shift() 5% faster than C<shift @_> |
| on non-threaded perls, and 25% faster on threaded ones. |
| |
| =head2 Optimisation of regexp engine string comparison work |
| |
| The C<foldEQ_utf8> API function for case-insensitive comparison of strings (which |
| is used heavily by the regexp engine) was substantially refactored and |
| optimised -- and its documentation much improved as a free bonus. |
| |
| =head2 Regular expression compilation speed-up |
| |
| Compiling regular expressions has been made faster when upgrading |
| the regex to utf8 is necessary but this isn't known when the compilation begins. |
| |
| =head2 String appending is 100 times faster |
| |
| When doing a lot of string appending, perls built to use the system's |
| C<malloc> could end up allocating a lot more memory than needed in a |
| inefficient way. |
| |
| C<sv_grow>, the function used to allocate more memory if necessary |
| when appending to a string, has been taught to round up the memory |
| it requests to a certain geometric progression, making it much faster on |
| certain platforms and configurations. On Win32, it's now about 100 times |
| faster. |
| |
| =head2 Eliminate C<PL_*> accessor functions under ithreads |
| |
| When C<MULTIPLICITY> was first developed, and interpreter state moved into |
| an interpreter struct, thread- and interpreter-local C<PL_*> variables |
| were defined as macros that called accessor functions (returning the |
| address of the value) outside the Perl core. The intent was to allow |
| members within the interpreter struct to change size without breaking |
| binary compatibility, so that bug fixes could be merged to a maintenance |
| branch that necessitated such a size change. This mechanism was redundant |
| and penalised well-behaved code. It has been removed. |
| |
| =head2 Freeing weak references |
| |
| When there are many weak references to an object, freeing that object |
| can under some circumstances take O(I<N*N>) time to free, where |
| I<N> is the number of references. The circumstances in which this can happen |
| have been reduced [perl #75254] |
| |
| =head2 Lexical array and hash assignments |
| |
| An earlier optimisation to speed up C<my @array = ...> and |
| C<my %hash = ...> assignments caused a bug and was disabled in Perl 5.12.0. |
| |
| Now we have found another way to speed up these assignments [perl #82110]. |
| |
| =head2 C<@_> uses less memory |
| |
| Previously, C<@_> was allocated for every subroutine at compile time with |
| enough space for four entries. Now this allocation is done on demand when |
| the subroutine is called [perl #72416]. |
| |
| =head2 Size optimisations to SV and HV structures |
| |
| C<xhv_fill> has been eliminated from C<struct xpvhv>, saving 1 IV per hash and |
| on some systems will cause C<struct xpvhv> to become cache-aligned. To avoid |
| this memory saving causing a slowdown elsewhere, boolean use of C<HvFILL> |
| now calls C<HvTOTALKEYS> instead (which is equivalent), so while the fill |
| data when actually required are now calculated on demand, cases when |
| this needs to be done should be rare. |
| |
| The order of structure elements in SV bodies has changed. Effectively, |
| the NV slot has swapped location with STASH and MAGIC. As all access to |
| SV members is via macros, this should be completely transparent. This |
| change allows the space saving for PVHVs documented above, and may reduce |
| the memory allocation needed for PVIVs on some architectures. |
| |
| C<XPV>, C<XPVIV>, and C<XPVNV> now allocate only the parts of the C<SV> body |
| they actually use, saving some space. |
| |
| Scalars containing regular expressions now allocate only the part of the C<SV> |
| body they actually use, saving some space. |
| |
| =head2 Memory consumption improvements to Exporter |
| |
| The C<@EXPORT_FAIL> AV is no longer created unless needed, hence neither is |
| the typeglob backing it. This saves about 200 bytes for every package that |
| uses Exporter but doesn't use this functionality. |
| |
| =head2 Memory savings for weak references |
| |
| For weak references, the common case of just a single weak reference |
| per referent has been optimised to reduce the storage required. In this |
| case it saves the equivalent of one small Perl array per referent. |
| |
| =head2 C<%+> and C<%-> use less memory |
| |
| The bulk of the C<Tie::Hash::NamedCapture> module used to be in the Perl |
| core. It has now been moved to an XS module to reduce overhead for |
| programs that do not use C<%+> or C<%->. |
| |
| =head2 Multiple small improvements to threads |
| |
| The internal structures of threading now make fewer API calls and fewer |
| allocations, resulting in noticeably smaller object code. Additionally, |
| many thread context checks have been deferred so they're done only |
| as needed (although this is only possible for non-debugging builds). |
| |
| =head2 Adjacent pairs of nextstate opcodes are now optimized away |
| |
| Previously, in code such as |
| |
| use constant DEBUG => 0; |
| |
| sub GAK { |
| warn if DEBUG; |
| print "stuff\n"; |
| } |
| |
| the ops for C<warn if DEBUG> would be folded to a C<null> op (C<ex-const>), but |
| the C<nextstate> op would remain, resulting in a runtime op dispatch of |
| C<nextstate>, C<nextstate>, etc. |
| |
| The execution of a sequence of C<nextstate> ops is indistinguishable from just |
| the last C<nextstate> op so the peephole optimizer now eliminates the first of |
| a pair of C<nextstate> ops except when the first carries a label, since labels |
| must not be eliminated by the optimizer, and label usage isn't conclusively known |
| at compile time. |
| |
| =head1 Modules and Pragmata |
| |
| =head2 New Modules and Pragmata |
| |
| =over 4 |
| |
| =item * |
| |
| L<CPAN::Meta::YAML> 0.003 has been added as a dual-life module. It supports a |
| subset of YAML sufficient for reading and writing F<META.yml> and F<MYMETA.yml> files |
| included with CPAN distributions or generated by the module installation |
| toolchain. It should not be used for any other general YAML parsing or |
| generation task. |
| |
| =item * |
| |
| L<CPAN::Meta> version 2.110440 has been added as a dual-life module. It |
| provides a standard library to read, interpret and write CPAN distribution |
| metadata files (like F<META.json> and F<META.yml)> that describe a |
| distribution, its contents, and the requirements for building it and |
| installing it. The latest CPAN distribution metadata specification is |
| included as L<CPAN::Meta::Spec> and notes on changes in the specification |
| over time are given in L<CPAN::Meta::History>. |
| |
| =item * |
| |
| L<HTTP::Tiny> 0.012 has been added as a dual-life module. It is a very |
| small, simple HTTP/1.1 client designed for simple GET requests and file |
| mirroring. It has been added so that F<CPAN.pm> and L<CPANPLUS> can |
| "bootstrap" HTTP access to CPAN using pure Perl without relying on external |
| binaries like L<curl(1)> or L<wget(1)>. |
| |
| =item * |
| |
| L<JSON::PP> 2.27105 has been added as a dual-life module to allow CPAN |
| clients to read F<META.json> files in CPAN distributions. |
| |
| =item * |
| |
| L<Module::Metadata> 1.000004 has been added as a dual-life module. It gathers |
| package and POD information from Perl module files. It is a standalone module |
| based on L<Module::Build::ModuleInfo> for use by other module installation |
| toolchain components. L<Module::Build::ModuleInfo> has been deprecated in |
| favor of this module instead. |
| |
| =item * |
| |
| L<Perl::OSType> 1.002 has been added as a dual-life module. It maps Perl |
| operating system names (like "dragonfly" or "MSWin32") to more generic types |
| with standardized names (like "Unix" or "Windows"). It has been refactored |
| out of L<Module::Build> and L<ExtUtils::CBuilder> and consolidates such mappings into |
| a single location for easier maintenance. |
| |
| =item * |
| |
| The following modules were added by the L<Unicode::Collate> |
| upgrade. See below for details. |
| |
| L<Unicode::Collate::CJK::Big5> |
| |
| L<Unicode::Collate::CJK::GB2312> |
| |
| L<Unicode::Collate::CJK::JISX0208> |
| |
| L<Unicode::Collate::CJK::Korean> |
| |
| L<Unicode::Collate::CJK::Pinyin> |
| |
| L<Unicode::Collate::CJK::Stroke> |
| |
| =item * |
| |
| L<Version::Requirements> version 0.101020 has been added as a dual-life |
| module. It provides a standard library to model and manipulates module |
| prerequisites and version constraints defined in L<CPAN::Meta::Spec>. |
| |
| =back |
| |
| =head2 Updated Modules and Pragma |
| |
| =over 4 |
| |
| =item * |
| |
| L<attributes> has been upgraded from version 0.12 to 0.14. |
| |
| =item * |
| |
| L<Archive::Extract> has been upgraded from version 0.38 to 0.48. |
| |
| Updates since 0.38 include: a safe print method that guards |
| L<Archive::Extract> from changes to C<$\>; a fix to the tests when run in core |
| Perl; support for TZ files; a modification for the lzma |
| logic to favour L<IO::Uncompress::Unlzma>; and a fix |
| for an issue with NetBSD-current and its new L<unzip(1)> |
| executable. |
| |
| =item * |
| |
| L<Archive::Tar> has been upgraded from version 1.54 to 1.76. |
| |
| Important changes since 1.54 include the following: |
| |
| =over |
| |
| =item * |
| |
| Compatibility with busybox implementations of L<tar(1)>. |
| |
| =item * |
| |
| A fix so that write() and create_archive() |
| close only filehandles they themselves opened. |
| |
| =item * |
| |
| A bug was fixed regarding the exit code of extract_archive. |
| |
| =item * |
| |
| The L<ptar(1)> utility has a new option to allow safe creation of |
| tarballs without world-writable files on Windows, allowing those |
| archives to be uploaded to CPAN. |
| |
| =item * |
| |
| A new L<ptargrep(1)> utility for using regular expressions against |
| the contents of files in a tar archive. |
| |
| =item * |
| |
| L<pax> extended headers are now skipped. |
| |
| =back |
| |
| =item * |
| |
| L<Attribute::Handlers> has been upgraded from version 0.87 to 0.89. |
| |
| =item * |
| |
| L<autodie> has been upgraded from version 2.06_01 to 2.1001. |
| |
| =item * |
| |
| L<AutoLoader> has been upgraded from version 5.70 to 5.71. |
| |
| =item * |
| |
| The L<B> module has been upgraded from version 1.23 to 1.29. |
| |
| It no longer crashes when taking apart a C<y///> containing characters |
| outside the octet range or compiled in a C<use utf8> scope. |
| |
| The size of the shared object has been reduced by about 40%, with no |
| reduction in functionality. |
| |
| =item * |
| |
| L<B::Concise> has been upgraded from version 0.78 to 0.83. |
| |
| L<B::Concise> marks rv2sv(), rv2av(), and rv2hv() ops with the new |
| C<OPpDEREF> flag as "DREFed". |
| |
| It no longer produces mangled output with the B<-tree> option |
| [perl #80632]. |
| |
| =item * |
| |
| L<B::Debug> has been upgraded from version 1.12 to 1.16. |
| |
| =item * |
| |
| L<B::Deparse> has been upgraded from version 0.96 to 1.03. |
| |
| The deparsing of a C<nextstate> op has changed when it has both a |
| change of package relative to the previous nextstate, or a change of |
| C<%^H> or other state and a label. The label was previously emitted |
| first, but is now emitted last (5.12.1). |
| |
| The C<no 5.13.2> or similar form is now correctly handled by L<B::Deparse> |
| (5.12.3). |
| |
| L<B::Deparse> now properly handles the code that applies a conditional |
| pattern match against implicit C<$_> as it was fixed in [perl #20444]. |
| |
| Deparsing of C<our> followed by a variable with funny characters |
| (as permitted under the C<use utf8> pragma) has also been fixed [perl #33752]. |
| |
| =item * |
| |
| L<B::Lint> has been upgraded from version 1.11_01 to 1.13. |
| |
| =item * |
| |
| L<base> has been upgraded from version 2.15 to 2.16. |
| |
| =item * |
| |
| L<Benchmark> has been upgraded from version 1.11 to 1.12. |
| |
| =item * |
| |
| L<bignum> has been upgraded from version 0.23 to 0.27. |
| |
| =item * |
| |
| L<Carp> has been upgraded from version 1.15 to 1.20. |
| |
| L<Carp> now detects incomplete L<caller()|perlfunc/"caller EXPR"> |
| overrides and avoids using bogus C<@DB::args>. To provide backtraces, |
| Carp relies on particular behaviour of the caller() builtin. |
| L<Carp> now detects if other code has overridden this with an |
| incomplete implementation, and modifies its backtrace accordingly. |
| Previously incomplete overrides would cause incorrect values in |
| backtraces (best case), or obscure fatal errors (worst case). |
| |
| This fixes certain cases of "Bizarre copy of ARRAY" caused by modules |
| overriding caller() incorrectly (5.12.2). |
| |
| It now also avoids using regular expressions that cause Perl to |
| load its Unicode tables, so as to avoid the "BEGIN not safe after |
| errors" error that ensue if there has been a syntax error |
| [perl #82854]. |
| |
| =item * |
| |
| L<CGI> has been upgraded from version 3.48 to 3.52. |
| |
| This provides the following security fixes: the MIME boundary in |
| multipart_init() is now random and the handling of |
| newlines embedded in header values has been improved. |
| |
| =item * |
| |
| L<Compress::Raw::Bzip2> has been upgraded from version 2.024 to 2.033. |
| |
| It has been updated to use L<bzip2(1)> 1.0.6. |
| |
| =item * |
| |
| L<Compress::Raw::Zlib> has been upgraded from version 2.024 to 2.033. |
| |
| =item * |
| |
| L<constant> has been upgraded from version 1.20 to 1.21. |
| |
| Unicode constants work once more. They have been broken since Perl 5.10.0 |
| [CPAN RT #67525]. |
| |
| =item * |
| |
| L<CPAN> has been upgraded from version 1.94_56 to 1.9600. |
| |
| Major highlights: |
| |
| =over 4 |
| |
| =item * much less configuration dialog hassle |
| |
| =item * support for F<META/MYMETA.json> |
| |
| =item * support for L<local::lib> |
| |
| =item * support for L<HTTP::Tiny> to reduce the dependency on FTP sites |
| |
| =item * automatic mirror selection |
| |
| =item * iron out all known bugs in configure_requires |
| |
| =item * support for distributions compressed with L<bzip2(1)> |
| |
| =item * allow F<Foo/Bar.pm> on the command line to mean C<Foo::Bar> |
| |
| =back |
| |
| =item * |
| |
| L<CPANPLUS> has been upgraded from version 0.90 to 0.9103. |
| |
| A change to F<cpanp-run-perl> |
| resolves L<RT #55964|http://rt.cpan.org/Public/Bug/Display.html?id=55964> |
| and L<RT #57106|http://rt.cpan.org/Public/Bug/Display.html?id=57106>, both |
| of which related to failures to install distributions that use |
| C<Module::Install::DSL> (5.12.2). |
| |
| A dependency on L<Config> was not recognised as a |
| core module dependency. This has been fixed. |
| |
| L<CPANPLUS> now includes support for F<META.json> and F<MYMETA.json>. |
| |
| =item * |
| |
| L<CPANPLUS::Dist::Build> has been upgraded from version 0.46 to 0.54. |
| |
| =item * |
| |
| L<Data::Dumper> has been upgraded from version 2.125 to 2.130_02. |
| |
| The indentation used to be off when C<$Data::Dumper::Terse> was set. This |
| has been fixed [perl #73604]. |
| |
| This upgrade also fixes a crash when using custom sort functions that might |
| cause the stack to change [perl #74170]. |
| |
| L<Dumpxs> no longer crashes with globs returned by C<*$io_ref> |
| [perl #72332]. |
| |
| =item * |
| |
| L<DB_File> has been upgraded from version 1.820 to 1.821. |
| |
| =item * |
| |
| L<DBM_Filter> has been upgraded from version 0.03 to 0.04. |
| |
| =item * |
| |
| L<Devel::DProf> has been upgraded from version 20080331.00 to 20110228.00. |
| |
| Merely loading L<Devel::DProf> now no longer triggers profiling to start. |
| Both C<use Devel::DProf> and C<perl -d:DProf ...> behave as before and start |
| the profiler. |
| |
| B<NOTE>: L<Devel::DProf> is deprecated and will be removed from a future |
| version of Perl. We strongly recommend that you install and use |
| L<Devel::NYTProf> instead, as it offers significantly improved |
| profiling and reporting. |
| |
| =item * |
| |
| L<Devel::Peek> has been upgraded from version 1.04 to 1.07. |
| |
| =item * |
| |
| L<Devel::SelfStubber> has been upgraded from version 1.03 to 1.05. |
| |
| =item * |
| |
| L<diagnostics> has been upgraded from version 1.19 to 1.22. |
| |
| It now renders pod links slightly better, and has been taught to find |
| descriptions for messages that share their descriptions with other |
| messages. |
| |
| =item * |
| |
| L<Digest::MD5> has been upgraded from version 2.39 to 2.51. |
| |
| It is now safe to use this module in combination with threads. |
| |
| =item * |
| |
| L<Digest::SHA> has been upgraded from version 5.47 to 5.61. |
| |
| C<shasum> now more closely mimics L<sha1sum(1)>/L<md5sum(1)>. |
| |
| C<addfile> accepts all POSIX filenames. |
| |
| New SHA-512/224 and SHA-512/256 transforms (ref. NIST Draft FIPS 180-4 |
| [February 2011]) |
| |
| =item * |
| |
| L<DirHandle> has been upgraded from version 1.03 to 1.04. |
| |
| =item * |
| |
| L<Dumpvalue> has been upgraded from version 1.13 to 1.16. |
| |
| =item * |
| |
| L<DynaLoader> has been upgraded from version 1.10 to 1.13. |
| |
| It fixes a buffer overflow when passed a very long file name. |
| |
| It no longer inherits from L<AutoLoader>; hence it no longer |
| produces weird error messages for unsuccessful method calls on classes that |
| inherit from L<DynaLoader> [perl #84358]. |
| |
| =item * |
| |
| L<Encode> has been upgraded from version 2.39 to 2.42. |
| |
| Now, all 66 Unicode non-characters are treated the same way U+FFFF has |
| always been treated: in cases when it was disallowed, all 66 are |
| disallowed, and in cases where it warned, all 66 warn. |
| |
| =item * |
| |
| L<Env> has been upgraded from version 1.01 to 1.02. |
| |
| =item * |
| |
| L<Errno> has been upgraded from version 1.11 to 1.13. |
| |
| The implementation of L<Errno> has been refactored to use about 55% less memory. |
| |
| On some platforms with unusual header files, like Win32 L<gcc(1)> using C<mingw64> |
| headers, some constants that weren't actually error numbers have been exposed |
| by L<Errno>. This has been fixed [perl #77416]. |
| |
| =item * |
| |
| L<Exporter> has been upgraded from version 5.64_01 to 5.64_03. |
| |
| Exporter no longer overrides C<$SIG{__WARN__}> [perl #74472] |
| |
| =item * |
| |
| L<ExtUtils::CBuilder> has been upgraded from version 0.27 to 0.280203. |
| |
| =item * |
| |
| L<ExtUtils::Command> has been upgraded from version 1.16 to 1.17. |
| |
| =item * |
| |
| L<ExtUtils::Constant> has been upgraded from 0.22 to 0.23. |
| |
| The L<AUTOLOAD> helper code generated by C<ExtUtils::Constant::ProxySubs> |
| can now croak() for missing constants, or generate a complete C<AUTOLOAD> |
| subroutine in XS, allowing simplification of many modules that use it |
| (L<Fcntl>, L<File::Glob>, L<GDBM_File>, L<I18N::Langinfo>, L<POSIX>, |
| L<Socket>). |
| |
| L<ExtUtils::Constant::ProxySubs> can now optionally push the names of all |
| constants onto the package's C<@EXPORT_OK>. |
| |
| =item * |
| |
| L<ExtUtils::Install> has been upgraded from version 1.55 to 1.56. |
| |
| =item * |
| |
| L<ExtUtils::MakeMaker> has been upgraded from version 6.56 to 6.57_05. |
| |
| =item * |
| |
| L<ExtUtils::Manifest> has been upgraded from version 1.57 to 1.58. |
| |
| =item * |
| |
| L<ExtUtils::ParseXS> has been upgraded from version 2.21 to 2.2210. |
| |
| =item * |
| |
| L<Fcntl> has been upgraded from version 1.06 to 1.11. |
| |
| =item * |
| |
| L<File::Basename> has been upgraded from version 2.78 to 2.82. |
| |
| =item * |
| |
| L<File::CheckTree> has been upgraded from version 4.4 to 4.41. |
| |
| =item * |
| |
| L<File::Copy> has been upgraded from version 2.17 to 2.21. |
| |
| =item * |
| |
| L<File::DosGlob> has been upgraded from version 1.01 to 1.04. |
| |
| It allows patterns containing literal parentheses: they no longer need to |
| be escaped. On Windows, it no longer |
| adds an extra F<./> to file names |
| returned when the pattern is a relative glob with a drive specification, |
| like F<C:*.pl> [perl #71712]. |
| |
| =item * |
| |
| L<File::Fetch> has been upgraded from version 0.24 to 0.32. |
| |
| L<HTTP::Lite> is now supported for the "http" scheme. |
| |
| The L<fetch(1)> utility is supported on FreeBSD, NetBSD, and |
| Dragonfly BSD for the C<http> and C<ftp> schemes. |
| |
| =item * |
| |
| L<File::Find> has been upgraded from version 1.15 to 1.19. |
| |
| It improves handling of backslashes on Windows, so that paths like |
| F<C:\dir\/file> are no longer generated [perl #71710]. |
| |
| =item * |
| |
| L<File::Glob> has been upgraded from version 1.07 to 1.12. |
| |
| =item * |
| |
| L<File::Spec> has been upgraded from version 3.31 to 3.33. |
| |
| Several portability fixes were made in L<File::Spec::VMS>: a colon is now |
| recognized as a delimiter in native filespecs; caret-escaped delimiters are |
| recognized for better handling of extended filespecs; catpath() returns |
| an empty directory rather than the current directory if the input directory |
| name is empty; and abs2rel() properly handles Unix-style input (5.12.2). |
| |
| =item * |
| |
| L<File::stat> has been upgraded from 1.02 to 1.05. |
| |
| The C<-x> and C<-X> file test operators now work correctly when run |
| by the superuser. |
| |
| =item * |
| |
| L<Filter::Simple> has been upgraded from version 0.84 to 0.86. |
| |
| =item * |
| |
| L<GDBM_File> has been upgraded from 1.10 to 1.14. |
| |
| This fixes a memory leak when DBM filters are used. |
| |
| =item * |
| |
| L<Hash::Util> has been upgraded from 0.07 to 0.11. |
| |
| L<Hash::Util> no longer emits spurious "uninitialized" warnings when |
| recursively locking hashes that have undefined values [perl #74280]. |
| |
| =item * |
| |
| L<Hash::Util::FieldHash> has been upgraded from version 1.04 to 1.09. |
| |
| =item * |
| |
| L<I18N::Collate> has been upgraded from version 1.01 to 1.02. |
| |
| =item * |
| |
| L<I18N::Langinfo> has been upgraded from version 0.03 to 0.08. |
| |
| langinfo() now defaults to using C<$_> if there is no argument given, just |
| as the documentation has always claimed. |
| |
| =item * |
| |
| L<I18N::LangTags> has been upgraded from version 0.35 to 0.35_01. |
| |
| =item * |
| |
| L<if> has been upgraded from version 0.05 to 0.0601. |
| |
| =item * |
| |
| L<IO> has been upgraded from version 1.25_02 to 1.25_04. |
| |
| This version of L<IO> includes a new L<IO::Select>, which now allows L<IO::Handle> |
| objects (and objects in derived classes) to be removed from an L<IO::Select> set |
| even if the underlying file descriptor is closed or invalid. |
| |
| =item * |
| |
| L<IPC::Cmd> has been upgraded from version 0.54 to 0.70. |
| |
| Resolves an issue with splitting Win32 command lines. An argument |
| consisting of the single character "0" used to be omitted (CPAN RT #62961). |
| |
| =item * |
| |
| L<IPC::Open3> has been upgraded from 1.05 to 1.09. |
| |
| open3() now produces an error if the C<exec> call fails, allowing this |
| condition to be distinguished from a child process that exited with a |
| non-zero status [perl #72016]. |
| |
| The internal xclose() routine now knows how to handle file descriptors as |
| documented, so duplicating C<STDIN> in a child process using its file |
| descriptor now works [perl #76474]. |
| |
| =item * |
| |
| L<IPC::SysV> has been upgraded from version 2.01 to 2.03. |
| |
| =item * |
| |
| L<lib> has been upgraded from version 0.62 to 0.63. |
| |
| =item * |
| |
| L<Locale::Maketext> has been upgraded from version 1.14 to 1.19. |
| |
| L<Locale::Maketext> now supports external caches. |
| |
| This upgrade also fixes an infinite loop in |
| C<Locale::Maketext::Guts::_compile()> when |
| working with tainted values (CPAN RT #40727). |
| |
| C<< ->maketext >> calls now back up and restore C<$@> so error |
| messages are not suppressed (CPAN RT #34182). |
| |
| =item * |
| |
| L<Log::Message> has been upgraded from version 0.02 to 0.04. |
| |
| =item * |
| |
| L<Log::Message::Simple> has been upgraded from version 0.06 to 0.08. |
| |
| =item * |
| |
| L<Math::BigInt> has been upgraded from version 1.89_01 to 1.994. |
| |
| This fixes, among other things, incorrect results when computing binomial |
| coefficients [perl #77640]. |
| |
| It also prevents C<sqrt($int)> from crashing under C<use bigrat>. |
| [perl #73534]. |
| |
| =item * |
| |
| L<Math::BigInt::FastCalc> has been upgraded from version 0.19 to 0.28. |
| |
| =item * |
| |
| L<Math::BigRat> has been upgraded from version 0.24 to 0.26_02. |
| |
| =item * |
| |
| L<Memoize> has been upgraded from version 1.01_03 to 1.02. |
| |
| =item * |
| |
| L<MIME::Base64> has been upgraded from 3.08 to 3.13. |
| |
| Includes new functions to calculate the length of encoded and decoded |
| base64 strings. |
| |
| Now provides encode_base64url() and decode_base64url() functions to process |
| the base64 scheme for "URL applications". |
| |
| =item * |
| |
| L<Module::Build> has been upgraded from version 0.3603 to 0.3800. |
| |
| A notable change is the deprecation of several modules. |
| L<Module::Build::Version> has been deprecated and L<Module::Build> now |
| relies on the L<version> pragma directly. L<Module::Build::ModuleInfo> has |
| been deprecated in favor of a standalone copy called L<Module::Metadata>. |
| L<Module::Build::YAML> has been deprecated in favor of L<CPAN::Meta::YAML>. |
| |
| L<Module::Build> now also generates F<META.json> and F<MYMETA.json> files |
| in accordance with version 2 of the CPAN distribution metadata specification, |
| L<CPAN::Meta::Spec>. The older format F<META.yml> and F<MYMETA.yml> files are |
| still generated. |
| |
| =item * |
| |
| L<Module::CoreList> has been upgraded from version 2.29 to 2.47. |
| |
| Besides listing the updated core modules of this release, it also stops listing |
| the C<Filespec> module. That module never existed in core. The scripts |
| generating L<Module::CoreList> confused it with L<VMS::Filespec>, which actually |
| is a core module as of Perl 5.8.7. |
| |
| =item * |
| |
| L<Module::Load> has been upgraded from version 0.16 to 0.18. |
| |
| =item * |
| |
| L<Module::Load::Conditional> has been upgraded from version 0.34 to 0.44. |
| |
| =item * |
| |
| The L<mro> pragma has been upgraded from version 1.02 to 1.07. |
| |
| =item * |
| |
| L<NDBM_File> has been upgraded from version 1.08 to 1.12. |
| |
| This fixes a memory leak when DBM filters are used. |
| |
| =item * |
| |
| L<Net::Ping> has been upgraded from version 2.36 to 2.38. |
| |
| =item * |
| |
| L<NEXT> has been upgraded from version 0.64 to 0.65. |
| |
| =item * |
| |
| L<Object::Accessor> has been upgraded from version 0.36 to 0.38. |
| |
| =item * |
| |
| L<ODBM_File> has been upgraded from version 1.07 to 1.10. |
| |
| This fixes a memory leak when DBM filters are used. |
| |
| =item * |
| |
| L<Opcode> has been upgraded from version 1.15 to 1.18. |
| |
| =item * |
| |
| The L<overload> pragma has been upgraded from 1.10 to 1.13. |
| |
| C<overload::Method> can now handle subroutines that are themselves blessed |
| into overloaded classes [perl #71998]. |
| |
| The documentation has greatly improved. See L</Documentation> below. |
| |
| =item * |
| |
| L<Params::Check> has been upgraded from version 0.26 to 0.28. |
| |
| =item * |
| |
| The L<parent> pragma has been upgraded from version 0.223 to 0.225. |
| |
| =item * |
| |
| L<Parse::CPAN::Meta> has been upgraded from version 1.40 to 1.4401. |
| |
| The latest Parse::CPAN::Meta can now read YAML and JSON files using |
| L<CPAN::Meta::YAML> and L<JSON::PP>, which are now part of the Perl core. |
| |
| =item * |
| |
| L<PerlIO::encoding> has been upgraded from version 0.12 to 0.14. |
| |
| =item * |
| |
| L<PerlIO::scalar> has been upgraded from 0.07 to 0.11. |
| |
| A read() after a seek() beyond the end of the string no longer thinks it |
| has data to read [perl #78716]. |
| |
| =item * |
| |
| L<PerlIO::via> has been upgraded from version 0.09 to 0.11. |
| |
| =item * |
| |
| L<Pod::Html> has been upgraded from version 1.09 to 1.11. |
| |
| =item * |
| |
| L<Pod::LaTeX> has been upgraded from version 0.58 to 0.59. |
| |
| =item * |
| |
| L<Pod::Perldoc> has been upgraded from version 3.15_02 to 3.15_03. |
| |
| =item * |
| |
| L<Pod::Simple> has been upgraded from version 3.13 to 3.16. |
| |
| =item * |
| |
| L<POSIX> has been upgraded from 1.19 to 1.24. |
| |
| It now includes constants for POSIX signal constants. |
| |
| =item * |
| |
| The L<re> pragma has been upgraded from version 0.11 to 0.18. |
| |
| The C<use re '/flags'> subpragma is new. |
| |
| The regmust() function used to crash when called on a regular expression |
| belonging to a pluggable engine. Now it croaks instead. |
| |
| regmust() no longer leaks memory. |
| |
| =item * |
| |
| L<Safe> has been upgraded from version 2.25 to 2.29. |
| |
| Coderefs returned by reval() and rdo() are now wrapped via |
| wrap_code_refs() (5.12.1). |
| |
| This fixes a possible infinite loop when looking for coderefs. |
| |
| It adds several C<version::vxs::*> routines to the default share. |
| |
| =item * |
| |
| L<SDBM_File> has been upgraded from version 1.06 to 1.09. |
| |
| =item * |
| |
| L<SelfLoader> has been upgraded from 1.17 to 1.18. |
| |
| It now works in taint mode [perl #72062]. |
| |
| =item * |
| |
| The L<sigtrap> pragma has been upgraded from version 1.04 to 1.05. |
| |
| It no longer tries to modify read-only arguments when generating a |
| backtrace [perl #72340]. |
| |
| =item * |
| |
| L<Socket> has been upgraded from version 1.87 to 1.94. |
| |
| See L</Improved IPv6 support> above. |
| |
| =item * |
| |
| L<Storable> has been upgraded from version 2.22 to 2.27. |
| |
| Includes performance improvement for overloaded classes. |
| |
| This adds support for serialising code references that contain UTF-8 strings |
| correctly. The L<Storable> minor version |
| number changed as a result, meaning that |
| L<Storable> users who set C<$Storable::accept_future_minor> to a C<FALSE> value |
| will see errors (see L<Storable/FORWARD COMPATIBILITY> for more details). |
| |
| Freezing no longer gets confused if the Perl stack gets reallocated |
| during freezing [perl #80074]. |
| |
| =item * |
| |
| L<Sys::Hostname> has been upgraded from version 1.11 to 1.16. |
| |
| =item * |
| |
| L<Term::ANSIColor> has been upgraded from version 2.02 to 3.00. |
| |
| =item * |
| |
| L<Term::UI> has been upgraded from version 0.20 to 0.26. |
| |
| =item * |
| |
| L<Test::Harness> has been upgraded from version 3.17 to 3.23. |
| |
| =item * |
| |
| L<Test::Simple> has been upgraded from version 0.94 to 0.98. |
| |
| Among many other things, subtests without a C<plan> or C<no_plan> now have an |
| implicit done_testing() added to them. |
| |
| =item * |
| |
| L<Thread::Semaphore> has been upgraded from version 2.09 to 2.12. |
| |
| It provides two new methods that give more control over the decrementing of |
| semaphores: C<down_nb> and C<down_force>. |
| |
| =item * |
| |
| L<Thread::Queue> has been upgraded from version 2.11 to 2.12. |
| |
| =item * |
| |
| The L<threads> pragma has been upgraded from version 1.75 to 1.83. |
| |
| =item * |
| |
| The L<threads::shared> pragma has been upgraded from version 1.32 to 1.37. |
| |
| =item * |
| |
| L<Tie::Hash> has been upgraded from version 1.03 to 1.04. |
| |
| Calling C<< Tie::Hash->TIEHASH() >> used to loop forever. Now it C<croak>s. |
| |
| =item * |
| |
| L<Tie::Hash::NamedCapture> has been upgraded from version 0.06 to 0.08. |
| |
| =item * |
| |
| L<Tie::RefHash> has been upgraded from version 1.38 to 1.39. |
| |
| =item * |
| |
| L<Time::HiRes> has been upgraded from version 1.9719 to 1.9721_01. |
| |
| =item * |
| |
| L<Time::Local> has been upgraded from version 1.1901_01 to 1.2000. |
| |
| =item * |
| |
| L<Time::Piece> has been upgraded from version 1.15_01 to 1.20_01. |
| |
| =item * |
| |
| L<Unicode::Collate> has been upgraded from version 0.52_01 to 0.73. |
| |
| L<Unicode::Collate> has been updated to use Unicode 6.0.0. |
| |
| L<Unicode::Collate::Locale> now supports a plethora of new locales: I<ar, be, |
| bg, de__phonebook, hu, hy, kk, mk, nso, om, tn, vi, hr, ig, ja, ko, ru, sq, |
| se, sr, to, uk, zh, zh__big5han, zh__gb2312han, zh__pinyin>, and I<zh__stroke>. |
| |
| The following modules have been added: |
| |
| L<Unicode::Collate::CJK::Big5> for C<zh__big5han> which makes |
| tailoring of CJK Unified Ideographs in the order of CLDR's big5han ordering. |
| |
| L<Unicode::Collate::CJK::GB2312> for C<zh__gb2312han> which makes |
| tailoring of CJK Unified Ideographs in the order of CLDR's gb2312han ordering. |
| |
| L<Unicode::Collate::CJK::JISX0208> which makes tailoring of 6355 kanji |
| (CJK Unified Ideographs) in the JIS X 0208 order. |
| |
| L<Unicode::Collate::CJK::Korean> which makes tailoring of CJK Unified Ideographs |
| in the order of CLDR's Korean ordering. |
| |
| L<Unicode::Collate::CJK::Pinyin> for C<zh__pinyin> which makes |
| tailoring of CJK Unified Ideographs in the order of CLDR's pinyin ordering. |
| |
| L<Unicode::Collate::CJK::Stroke> for C<zh__stroke> which makes |
| tailoring of CJK Unified Ideographs in the order of CLDR's stroke ordering. |
| |
| This also sees the switch from using the pure-Perl version of this |
| module to the XS version. |
| |
| =item * |
| |
| L<Unicode::Normalize> has been upgraded from version 1.03 to 1.10. |
| |
| =item * |
| |
| L<Unicode::UCD> has been upgraded from version 0.27 to 0.32. |
| |
| A new function, Unicode::UCD::num(), has been added. This function |
| returns the numeric value of the string passed it or C<undef> if the string |
| in its entirety has no "safe" numeric value. (For more detail, and for the |
| definition of "safe", see L<Unicode::UCD/num()>.) |
| |
| This upgrade also includes several bug fixes: |
| |
| =over 4 |
| |
| =item charinfo() |
| |
| =over 4 |
| |
| =item * |
| |
| It is now updated to Unicode Version 6.0.0 with I<Corrigendum #8>, |
| excepting that, just as with Perl 5.14, the code point at U+1F514 has no name. |
| |
| =item * |
| |
| Hangul syllable code points have the correct names, and their |
| decompositions are always output without requiring L<Lingua::KO::Hangul::Util> |
| to be installed. |
| |
| =item * |
| |
| CJK (Chinese-Japanese-Korean) code points U+2A700 to U+2B734 |
| and U+2B740 to U+2B81D are now properly handled. |
| |
| =item * |
| |
| Numeric values are now output for those CJK code points that have them. |
| |
| =item * |
| |
| Names output for code points with multiple aliases are now the |
| corrected ones. |
| |
| =back |
| |
| =item charscript() |
| |
| This now correctly returns "Unknown" instead of C<undef> for the script |
| of a code point that hasn't been assigned another one. |
| |
| =item charblock() |
| |
| This now correctly returns "No_Block" instead of C<undef> for the block |
| of a code point that hasn't been assigned to another one. |
| |
| =back |
| |
| =item * |
| |
| The L<version> pragma has been upgraded from 0.82 to 0.88. |
| |
| Because of a bug, now fixed, the is_strict() and is_lax() functions did not |
| work when exported (5.12.1). |
| |
| =item * |
| |
| The L<warnings> pragma has been upgraded from version 1.09 to 1.12. |
| |
| Calling C<use warnings> without arguments is now significantly more efficient. |
| |
| =item * |
| |
| The L<warnings::register> pragma has been upgraded from version 1.01 to 1.02. |
| |
| It is now possible to register warning categories other than the names of |
| packages using L<warnings::register>. See L<perllexwarn(1)> for more information. |
| |
| =item * |
| |
| L<XSLoader> has been upgraded from version 0.10 to 0.13. |
| |
| =item * |
| |
| L<VMS::DCLsym> has been upgraded from version 1.03 to 1.05. |
| |
| Two bugs have been fixed [perl #84086]: |
| |
| The symbol table name was lost when tying a hash, due to a thinko in |
| C<TIEHASH>. The result was that all tied hashes interacted with the |
| local symbol table. |
| |
| Unless a symbol table name had been explicitly specified in the call |
| to the constructor, querying the special key C<:LOCAL> failed to |
| identify objects connected to the local symbol table. |
| |
| =item * |
| |
| The L<Win32> module has been upgraded from version 0.39 to 0.44. |
| |
| This release has several new functions: Win32::GetSystemMetrics(), |
| Win32::GetProductInfo(), Win32::GetOSDisplayName(). |
| |
| The names returned by Win32::GetOSName() and Win32::GetOSDisplayName() |
| have been corrected. |
| |
| =item * |
| |
| L<XS::Typemap> has been upgraded from version 0.03 to 0.05. |
| |
| =back |
| |
| =head2 Removed Modules and Pragmata |
| |
| As promised in Perl 5.12.0's release notes, the following modules have |
| been removed from the core distribution, and if needed should be installed |
| from CPAN instead. |
| |
| =over |
| |
| =item * |
| |
| L<Class::ISA> has been removed from the Perl core. Prior version was 0.36. |
| |
| =item * |
| |
| L<Pod::Plainer> has been removed from the Perl core. Prior version was 1.02. |
| |
| =item * |
| |
| L<Switch> has been removed from the Perl core. Prior version was 2.16. |
| |
| =back |
| |
| The removal of L<Shell> has been deferred until after 5.14, as the |
| implementation of L<Shell> shipped with 5.12.0 did not correctly issue the |
| warning that it was to be removed from core. |
| |
| =head1 Documentation |
| |
| =head2 New Documentation |
| |
| =head3 L<perlgpl> |
| |
| L<perlgpl> has been updated to contain GPL version 1, as is included in the |
| F<README> distributed with Perl (5.12.1). |
| |
| =head3 Perl 5.12.x delta files |
| |
| The perldelta files for Perl 5.12.1 to 5.12.3 have been added from the |
| maintenance branch: L<perl5121delta>, L<perl5122delta>, L<perl5123delta>. |
| |
| =head3 L<perlpodstyle> |
| |
| New style guide for POD documentation, |
| split mostly from the NOTES section of the L<pod2man(1)> manpage. |
| |
| =head3 L<perlsource>, L<perlinterp>, L<perlhacktut>, and L<perlhacktips> |
| |
| See L</perlhack and perlrepository revamp>, below. |
| |
| =head2 Changes to Existing Documentation |
| |
| =head3 L<perlmodlib> is now complete |
| |
| The L<perlmodlib> manpage that came with Perl 5.12.0 was missing several |
| modules due to a bug in the script that generates the list. This has been |
| fixed [perl #74332] (5.12.1). |
| |
| =head3 Replace incorrect tr/// table in L<perlebcdic> |
| |
| L<perlebcdic> contains a helpful table to use in C<tr///> to convert |
| between EBCDIC and Latin1/ASCII. The table was the inverse of the one |
| it describes, though the code that used the table worked correctly for |
| the specific example given. |
| |
| The table has been corrected and the sample code changed to correspond. |
| |
| The table has also been changed to hex from octal, and the recipes in the |
| pod have been altered to print out leading zeros to make all values |
| the same length. |
| |
| =head3 Tricks for user-defined casing |
| |
| L<perlunicode> now contains an explanation of how to override, mangle |
| and otherwise tweak the way Perl handles upper-, lower- and other-case |
| conversions on Unicode data, and how to provide scoped changes to alter |
| one's own code's behaviour without stomping on anybody else's. |
| |
| =head3 INSTALL explicitly states that Perl requires a C89 compiler |
| |
| This was already true, but it's now Officially Stated For The Record |
| (5.12.2). |
| |
| =head3 Explanation of C<\xI<HH>> and C<\oI<OOO>> escapes |
| |
| L<perlop> has been updated with more detailed explanation of these two |
| character escapes. |
| |
| =head3 B<-0I<NNN>> switch |
| |
| In L<perlrun>, the behaviour of the B<-0NNN> switch for B<-0400> or higher |
| has been clarified (5.12.2). |
| |
| =head3 Maintenance policy |
| |
| L<perlpolicy> now contains the policy on what patches are acceptable for |
| maintenance branches (5.12.1). |
| |
| =head3 Deprecation policy |
| |
| L<perlpolicy> now contains the policy on compatibility and deprecation |
| along with definitions of terms like "deprecation" (5.12.2). |
| |
| =head3 New descriptions in L<perldiag> |
| |
| The following existing diagnostics are now documented: |
| |
| =over 4 |
| |
| =item * |
| |
| L<Ambiguous use of %c resolved as operator %c|perldiag/"Ambiguous use of %c resolved as operator %c"> |
| |
| =item * |
| |
| L<Ambiguous use of %c{%s} resolved to %c%s|perldiag/"Ambiguous use of %c{%s} resolved to %c%s"> |
| |
| =item * |
| |
| L<Ambiguous use of %c{%s[...]} resolved to %c%s[...]|perldiag/"Ambiguous use of %c{%s[...]} resolved to %c%s[...]"> |
| |
| =item * |
| |
| L<Ambiguous use of %c{%s{...}} resolved to %c%s{...}|perldiag/"Ambiguous use of %c{%s{...}} resolved to %c%s{...}"> |
| |
| =item * |
| |
| L<Ambiguous use of -%s resolved as -&%s()|perldiag/"Ambiguous use of -%s resolved as -&%s()"> |
| |
| =item * |
| |
| L<Invalid strict version format (%s)|perldiag/"Invalid strict version format (%s)"> |
| |
| =item * |
| |
| L<Invalid version format (%s)|perldiag/"Invalid version format (%s)"> |
| |
| =item * |
| |
| L<Invalid version object|perldiag/"Invalid version object"> |
| |
| =back |
| |
| =head3 L<perlbook> |
| |
| L<perlbook> has been expanded to cover many more popular books. |
| |
| =head3 C<SvTRUE> macro |
| |
| The documentation for the C<SvTRUE> macro in |
| L<perlapi> was simply wrong in stating that |
| get-magic is not processed. It has been corrected. |
| |
| =head3 op manipulation functions |
| |
| Several API functions that process optrees have been newly documented. |
| |
| =head3 L<perlvar> revamp |
| |
| L<perlvar> reorders the variables and groups them by topic. Each variable |
| introduced after Perl 5.000 notes the first version in which it is |
| available. L<perlvar> also has a new section for deprecated variables to |
| note when they were removed. |
| |
| =head3 Array and hash slices in scalar context |
| |
| These are now documented in L<perldata>. |
| |
| =head3 C<use locale> and formats |
| |
| L<perlform> and L<perllocale> have been corrected to state that |
| C<use locale> affects formats. |
| |
| =head3 L<overload> |
| |
| L<overload>'s documentation has practically undergone a rewrite. It |
| is now much more straightforward and clear. |
| |
| =head3 perlhack and perlrepository revamp |
| |
| The L<perlhack> document is now much shorter, and focuses on the Perl 5 |
| development process and submitting patches to Perl. The technical content |
| has been moved to several new documents, L<perlsource>, L<perlinterp>, |
| L<perlhacktut>, and L<perlhacktips>. This technical content has |
| been only lightly edited. |
| |
| The perlrepository document has been renamed to L<perlgit>. This new |
| document is just a how-to on using git with the Perl source code. |
| Any other content that used to be in perlrepository has been moved |
| to L<perlhack>. |
| |
| =head3 Time::Piece examples |
| |
| Examples in L<perlfaq4> have been updated to show the use of |
| L<Time::Piece>. |
| |
| =head1 Diagnostics |
| |
| The following additions or changes have been made to diagnostic output, |
| including warnings and fatal error messages. For the complete list of |
| diagnostic messages, see L<perldiag>. |
| |
| =head2 New Diagnostics |
| |
| =head3 New Errors |
| |
| =over |
| |
| =item Closure prototype called |
| |
| This error occurs when a subroutine reference passed to an attribute |
| handler is called, if the subroutine is a closure [perl #68560]. |
| |
| =item Insecure user-defined property %s |
| |
| Perl detected tainted data when trying to compile a regular |
| expression that contains a call to a user-defined character property |
| function, meaning C<\p{IsFoo}> or C<\p{InFoo}>. |
| See L<perlunicode/User-Defined Character Properties> and L<perlsec>. |
| |
| =item panic: gp_free failed to free glob pointer - something is repeatedly re-creating entries |
| |
| This new error is triggered if a destructor called on an object in a |
| typeglob that is being freed creates a new typeglob entry containing an |
| object with a destructor that creates a new entry containing an object etc. |
| |
| =item Parsing code internal error (%s) |
| |
| This new fatal error is produced when parsing |
| code supplied by an extension violates the |
| parser's API in a detectable way. |
| |
| =item refcnt: fd %d%s |
| |
| This new error only occurs if a internal consistency check fails when a |
| pipe is about to be closed. |
| |
| =item Regexp modifier "/%c" may not appear twice |
| |
| The regular expression pattern has one of the |
| mutually exclusive modifiers repeated. |
| |
| =item Regexp modifiers "/%c" and "/%c" are mutually exclusive |
| |
| The regular expression pattern has more than one of the mutually |
| exclusive modifiers. |
| |
| =item Using !~ with %s doesn't make sense |
| |
| This error occurs when C<!~> is used with C<s///r> or C<y///r>. |
| |
| =back |
| |
| =head3 New Warnings |
| |
| =over |
| |
| =item "\b{" is deprecated; use "\b\{" instead |
| |
| =item "\B{" is deprecated; use "\B\{" instead |
| |
| Use of an unescaped "{" immediately following a C<\b> or C<\B> is now |
| deprecated in order to reserve its use for Perl itself in a future release. |
| |
| =item Operation "%s" returns its argument for ... |
| |
| Performing an operation requiring Unicode semantics (such as case-folding) |
| on a Unicode surrogate or a non-Unicode character now triggers this |
| warning. |
| |
| =item Use of qw(...) as parentheses is deprecated |
| |
| See L</"Use of qw(...) as parentheses">, above, for details. |
| |
| =back |
| |
| =head2 Changes to Existing Diagnostics |
| |
| =over 4 |
| |
| =item * |
| |
| The "Variable $foo is not imported" warning that precedes a |
| C<strict 'vars'> error has now been assigned the "misc" category, so that |
| C<no warnings> will suppress it [perl #73712]. |
| |
| =item * |
| |
| warn() and die() now produce "Wide character" warnings when fed a |
| character outside the byte range if C<STDERR> is a byte-sized handle. |
| |
| =item * |
| |
| The "Layer does not match this perl" error message has been replaced with |
| these more helpful messages [perl #73754]: |
| |
| =over 4 |
| |
| =item * |
| |
| PerlIO layer function table size (%d) does not match size expected by this |
| perl (%d) |
| |
| =item * |
| |
| PerlIO layer instance size (%d) does not match size expected by this perl |
| (%d) |
| |
| =back |
| |
| =item * |
| |
| The "Found = in conditional" warning that is emitted when a constant is |
| assigned to a variable in a condition is now withheld if the constant is |
| actually a subroutine or one generated by C<use constant>, since the value |
| of the constant may not be known at the time the program is written |
| [perl #77762]. |
| |
| =item * |
| |
| Previously, if none of the gethostbyaddr(), gethostbyname() and |
| gethostent() functions were implemented on a given platform, they would |
| all die with the message "Unsupported socket function 'gethostent' called", |
| with analogous messages for getnet*() and getserv*(). This has been |
| corrected. |
| |
| =item * |
| |
| The warning message about unrecognized regular expression escapes passed |
| through has been changed to include any literal "{" following the |
| two-character escape. For example, "\q{" is now emitted instead of "\q". |
| |
| =back |
| |
| =head1 Utility Changes |
| |
| =head3 L<perlbug(1)> |
| |
| =over 4 |
| |
| =item * |
| |
| L<perlbug> now looks in the EMAIL environment variable for a return address |
| if the REPLY-TO and REPLYTO variables are empty. |
| |
| =item * |
| |
| L<perlbug> did not previously generate a "From:" header, potentially |
| resulting in dropped mail; it now includes that header. |
| |
| =item * |
| |
| The user's address is now used as the Return-Path. |
| |
| Many systems these days don't have a valid Internet domain name, and |
| perlbug@perl.org does not accept email with a return-path that does |
| not resolve. So the user's address is now passed to sendmail so it's |
| less likely to get stuck in a mail queue somewhere [perl #82996]. |
| |
| =item * |
| |
| L<perlbug> now always gives the reporter a chance to change the email |
| address it guesses for them (5.12.2). |
| |
| =item * |
| |
| L<perlbug> should no longer warn about uninitialized values when using the B<-d> |
| and B<-v> options (5.12.2). |
| |
| =back |
| |
| =head3 L<perl5db.pl> |
| |
| =over |
| |
| =item * |
| |
| The remote terminal works after forking and spawns new sessions, one |
| per forked process. |
| |
| =back |
| |
| =head3 L<ptargrep> |
| |
| =over 4 |
| |
| =item * |
| |
| L<ptargrep> is a new utility to apply pattern matching to the contents of |
| files in a tar archive. It comes with C<Archive::Tar>. |
| |
| =back |
| |
| =head1 Configuration and Compilation |
| |
| See also L</"Naming fixes in Policy_sh.SH may invalidate Policy.sh">, |
| above. |
| |
| =over 4 |
| |
| =item * |
| |
| CCINCDIR and CCLIBDIR for the mingw64 cross-compiler are now correctly |
| under F<$(CCHOME)\mingw\include> and F<\lib> rather than immediately below |
| F<$(CCHOME)>. |
| |
| This means the "incpath", "libpth", "ldflags", "lddlflags" and |
| "ldflags_nolargefiles" values in F<Config.pm> and F<Config_heavy.pl> are now |
| set correctly. |
| |
| =item * |
| |
| C<make test.valgrind> has been adjusted to account for F<cpan/dist/ext> |
| separation. |
| |
| =item * |
| |
| On compilers that support it, B<-Wwrite-strings> is now added to cflags by |
| default. |
| |
| =item * |
| |
| The L<Encode> module can now (once again) be included in a static Perl |
| build. The special-case handling for this situation got broken in Perl |
| 5.11.0, and has now been repaired. |
| |
| =item * |
| |
| The previous default size of a PerlIO buffer (4096 bytes) has been increased |
| to the larger of 8192 bytes and your local BUFSIZ. Benchmarks show that doubling |
| this decade-old default increases read and write performance by around |
| 25% to 50% when using the default layers of perlio on top of unix. To choose |
| a non-default size, such as to get back the old value or to obtain an even |
| larger value, configure with: |
| |
| ./Configure -Accflags=-DPERLIOBUF_DEFAULT_BUFSIZ=N |
| |
| where N is the desired size in bytes; it should probably be a multiple of |
| your page size. |
| |
| =item * |
| |
| An "incompatible operand types" error in ternary expressions when building |
| with C<clang> has been fixed (5.12.2). |
| |
| =item * |
| |
| Perl now skips setuid L<File::Copy> tests on partitions it detects mounted |
| as C<nosuid> (5.12.2). |
| |
| =back |
| |
| =head1 Platform Support |
| |
| =head2 New Platforms |
| |
| =over 4 |
| |
| =item AIX |
| |
| Perl now builds on AIX 4.2 (5.12.1). |
| |
| =back |
| |
| =head2 Discontinued Platforms |
| |
| =over 4 |
| |
| =item Apollo DomainOS |
| |
| The last vestiges of support for this platform have been excised from |
| the Perl distribution. It was officially discontinued in version 5.12.0. |
| It had not worked for years before that. |
| |
| =item MacOS Classic |
| |
| The last vestiges of support for this platform have been excised from the |
| Perl distribution. It was officially discontinued in an earlier version. |
| |
| =back |
| |
| =head2 Platform-Specific Notes |
| |
| =head3 AIX |
| |
| =over |
| |
| =item * |
| |
| F<README.aix> has been updated with information about the XL C/C++ V11 compiler |
| suite (5.12.2). |
| |
| =back |
| |
| =head3 ARM |
| |
| =over |
| |
| =item * |
| |
| The C<d_u32align> configuration probe on ARM has been fixed (5.12.2). |
| |
| =back |
| |
| =head3 Cygwin |
| |
| =over 4 |
| |
| =item * |
| |
| L<MakeMaker> has been updated to build manpages on cygwin. |
| |
| =item * |
| |
| Improved rebase behaviour |
| |
| If a DLL is updated on cygwin the old imagebase address is reused. |
| This solves most rebase errors, especially when updating on core DLL's. |
| See L<http://www.tishler.net/jason/software/rebase/rebase-2.4.2.README> |
| for more information. |
| |
| =item * |
| |
| Support for the standard cygwin dll prefix (needed for FFIs) |
| |
| =item * |
| |
| Updated build hints file |
| |
| =back |
| |
| =head3 FreeBSD 7 |
| |
| =over |
| |
| =item * |
| |
| FreeBSD 7 no longer contains F</usr/bin/objformat>. At build time, |
| Perl now skips the F<objformat> check for versions 7 and higher and |
| assumes ELF (5.12.1). |
| |
| =back |
| |
| =head3 HP-UX |
| |
| =over |
| |
| =item * |
| |
| Perl now allows B<-Duse64bitint> without promoting to C<use64bitall> on HP-UX |
| (5.12.1). |
| |
| =back |
| |
| =head3 IRIX |
| |
| =over |
| |
| =item * |
| |
| Conversion of strings to floating-point numbers is now more accurate on |
| IRIX systems [perl #32380]. |
| |
| =back |
| |
| =head3 Mac OS X |
| |
| =over |
| |
| =item * |
| |
| Early versions of Mac OS X (Darwin) had buggy implementations of the |
| setregid(), setreuid(), setrgid(,) and setruid() functions, so Perl |
| would pretend they did not exist. |
| |
| These functions are now recognised on Mac OS 10.5 (Leopard; Darwin 9) and |
| higher, as they have been fixed [perl #72990]. |
| |
| =back |
| |
| =head3 MirBSD |
| |
| =over |
| |
| =item * |
| |
| Previously if you built Perl with a shared F<libperl.so> on MirBSD (the |
| default config), it would work up to the installation; however, once |
| installed, it would be unable to find F<libperl>. Path handling is now |
| treated as in the other BSD dialects. |
| |
| =back |
| |
| =head3 NetBSD |
| |
| =over |
| |
| =item * |
| |
| The NetBSD hints file has been changed to make the system malloc the |
| default. |
| |
| =back |
| |
| =head3 OpenBSD |
| |
| =over |
| |
| =item * |
| |
| OpenBSD E<gt> 3.7 has a new malloc implementation which is I<mmap>-based, |
| and as such can release memory back to the OS; however, Perl's use of |
| this malloc causes a substantial slowdown, so we now default to using |
| Perl's malloc instead [perl #75742]. |
| |
| =back |
| |
| =head3 OpenVOS |
| |
| =over |
| |
| =item * |
| |
| Perl now builds again with OpenVOS (formerly known as Stratus VOS) |
| [perl #78132] (5.12.3). |
| |
| =back |
| |
| =head3 Solaris |
| |
| =over |
| |
| =item * |
| |
| DTrace is now supported on Solaris. There used to be build failures, but |
| these have been fixed [perl #73630] (5.12.3). |
| |
| =back |
| |
| =head3 VMS |
| |
| =over |
| |
| =item * |
| |
| Extension building on older (pre 7.3-2) VMS systems was broken because |
| configure.com hit the DCL symbol length limit of 1K. We now work within |
| this limit when assembling the list of extensions in the core build (5.12.1). |
| |
| =item * |
| |
| We fixed configuring and building Perl with B<-Uuseperlio> (5.12.1). |
| |
| =item * |
| |
| C<PerlIOUnix_open> now honours the default permissions on VMS. |
| |
| When C<perlio> became the default and C<unix> became the default bottom layer, |
| the most common path for creating files from Perl became C<PerlIOUnix_open>, |
| which has always explicitly used C<0666> as the permission mask. This prevents |
| inheriting permissions from RMS defaults and ACLs, so to avoid that problem, |
| we now pass C<0777> to open(). In the VMS CRTL, C<0777> has a special |
| meaning over and above intersecting with the current umask; specifically, it |
| allows Unix syscalls to preserve native default permissions (5.12.3). |
| |
| =item * |
| |
| The shortening of symbols longer than 31 characters in the core C sources |
| and in extensions is now by default done by the C compiler rather than by |
| xsubpp (which could only do so for generated symbols in XS code). You can |
| reenable xsubpp's symbol shortening by configuring with -Uuseshortenedsymbols, |
| but you'll have some work to do to get the core sources to compile. |
| |
| =item * |
| |
| Record-oriented files (record format variable or variable with fixed control) |
| opened for write by the C<perlio> layer will now be line-buffered to prevent the |
| introduction of spurious line breaks whenever the perlio buffer fills up. |
| |
| =item * |
| |
| F<git_version.h> is now installed on VMS. This was an oversight in v5.12.0 which |
| caused some extensions to fail to build (5.12.2). |
| |
| =item * |
| |
| Several memory leaks in L<stat()|perlfunc/"stat FILEHANDLE"> have been fixed (5.12.2). |
| |
| =item * |
| |
| A memory leak in Perl_rename() due to a double allocation has been |
| fixed (5.12.2). |
| |
| =item * |
| |
| A memory leak in vms_fid_to_name() (used by realpath() and |
| realname()> has been fixed (5.12.2). |
| |
| =back |
| |
| =head3 Windows |
| |
| See also L</"fork() emulation will not wait for signalled children"> and |
| L</"Perl source code is read in text mode on Windows">, above. |
| |
| =over 4 |
| |
| =item * |
| |
| Fixed build process for SDK2003SP1 compilers. |
| |
| =item * |
| |
| Compilation with Visual Studio 2010 is now supported. |
| |
| =item * |
| |
| When using old 32-bit compilers, the define C<_USE_32BIT_TIME_T> is now |
| set in C<$Config{ccflags}>. This improves portability when compiling |
| XS extensions using new compilers, but for a Perl compiled with old 32-bit |
| compilers. |
| |
| =item * |
| |
| C<$Config{gccversion}> is now set correctly when Perl is built using the |
| mingw64 compiler from L<http://mingw64.org> [perl #73754]. |
| |
| =item * |
| |
| When building Perl with the mingw64 x64 cross-compiler C<incpath>, |
| C<libpth>, C<ldflags>, C<lddlflags> and C<ldflags_nolargefiles> values |
| in F<Config.pm> and F<Config_heavy.pl> were not previously being set |
| correctly because, with that compiler, the include and lib directories |
| are not immediately below C<$(CCHOME)> (5.12.2). |
| |
| =item * |
| |
| The build process proceeds more smoothly with mingw and dmake when |
| F<C:\MSYS\bin> is in the PATH, due to a C<Cwd> fix. |
| |
| =item * |
| |
| Support for building with Visual C++ 2010 is now underway, but is not yet |
| complete. See F<README.win32> or L<perlwin32> for more details. |
| |
| =item * |
| |
| The option to use an externally-supplied crypt(), or to build with no |
| crypt() at all, has been removed. Perl supplies its own crypt() |
| implementation for Windows, and the political situation that required |
| this part of the distribution to sometimes be omitted is long gone. |
| |
| =back |
| |
| =head1 Internal Changes |
| |
| =head2 New APIs |
| |
| =head3 CLONE_PARAMS structure added to ease correct thread creation |
| |
| Modules that create threads should now create C<CLONE_PARAMS> structures |
| by calling the new function Perl_clone_params_new(), and free them with |
| Perl_clone_params_del(). This will ensure compatibility with any future |
| changes to the internals of the C<CLONE_PARAMS> structure layout, and that |
| it is correctly allocated and initialised. |
| |
| =head3 New parsing functions |
| |
| Several functions have been added for parsing Perl statements and |
| expressions. These functions are meant to be used by XS code invoked |
| during Perl parsing, in a recursive-descent manner, to allow modules to |
| augment the standard Perl syntax. |
| |
| =over |
| |
| =item * |
| |
| L<parse_stmtseq()|perlapi/parse_stmtseq> |
| parses a sequence of statements, up to closing brace or EOF. |
| |
| =item * |
| |
| L<parse_fullstmt()|perlapi/parse_fullstmt> |
| parses a complete Perl statement, including optional label. |
| |
| =item * |
| |
| L<parse_barestmt()|perlapi/parse_barestmt> |
| parses a statement without a label. |
| |
| =item * |
| |
| L<parse_block()|perlapi/parse_block> |
| parses a code block. |
| |
| =item * |
| |
| L<parse_label()|perlapi/parse_label> |
| parses a statement label, separate from statements. |
| |
| =item * |
| |
| L<C<parse_fullexpr()>|perlapi/parse_fullexpr>, |
| L<C<parse_listexpr()>|perlapi/parse_listexpr>, |
| L<C<parse_termexpr()>|perlapi/parse_termexpr>, and |
| L<C<parse_arithexpr()>|perlapi/parse_arithexpr> |
| parse expressions at various precedence levels. |
| |
| =back |
| |
| =head3 Hints hash API |
| |
| A new C API for introspecting the hinthash C<%^H> at runtime has been |
| added. See C<cop_hints_2hv>, C<cop_hints_fetchpvn>, C<cop_hints_fetchpvs>, |
| C<cop_hints_fetchsv>, and C<hv_copy_hints_hv> in L<perlapi> for details. |
| |
| A new, experimental API has been added for accessing the internal |
| structure that Perl uses for C<%^H>. See the functions beginning with |
| C<cophh_> in L<perlapi>. |
| |
| =head3 C interface to caller() |
| |
| The C<caller_cx> function has been added as an XSUB-writer's equivalent of |
| caller(). See L<perlapi> for details. |
| |
| =head3 Custom per-subroutine check hooks |
| |
| XS code in an extension module can now annotate a subroutine (whether |
| implemented in XS or in Perl) so that nominated XS code will be called |
| at compile time (specifically as part of op checking) to change the op |
| tree of that subroutine. The compile-time check function (supplied by |
| the extension module) can implement argument processing that can't be |
| expressed as a prototype, generate customised compile-time warnings, |
| perform constant folding for a pure function, inline a subroutine |
| consisting of sufficiently simple ops, replace the whole call with a |
| custom op, and so on. This was previously all possible by hooking the |
| C<entersub> op checker, but the new mechanism makes it easy to tie the |
| hook to a specific subroutine. See L<perlapi/cv_set_call_checker>. |
| |
| To help in writing custom check hooks, several subtasks within standard |
| C<entersub> op checking have been separated out and exposed in the API. |
| |
| =head3 Improved support for custom OPs |
| |
| Custom ops can now be registered with the new C<custom_op_register> C |
| function and the C<XOP> structure. This will make it easier to add new |
| properties of custom ops in the future. Two new properties have been added |
| already, C<xop_class> and C<xop_peep>. |
| |
| C<xop_class> is one of the OA_*OP constants. It allows L<B> and other |
| introspection mechanisms to work with custom ops |
| that aren't BASEOPs. C<xop_peep> is a pointer to |
| a function that will be called for ops of this |
| type from C<Perl_rpeep>. |
| |
| See L<perlguts/Custom Operators> and L<perlapi/Custom Operators> for more |
| detail. |
| |
| The old C<PL_custom_op_names>/C<PL_custom_op_descs> interface is still |
| supported but discouraged. |
| |
| =head3 Scope hooks |
| |
| It is now possible for XS code to hook into Perl's lexical scope |
| mechanism at compile time, using the new C<Perl_blockhook_register> |
| function. See L<perlguts/"Compile-time scope hooks">. |
| |
| =head3 The recursive part of the peephole optimizer is now hookable |
| |
| In addition to C<PL_peepp>, for hooking into the toplevel peephole optimizer, a |
| C<PL_rpeepp> is now available to hook into the optimizer recursing into |
| side-chains of the optree. |
| |
| =head3 New non-magical variants of existing functions |
| |
| The following functions/macros have been added to the API. The C<*_nomg> |
| macros are equivalent to their non-C<_nomg> variants, except that they ignore |
| get-magic. Those ending in C<_flags> allow one to specify whether |
| get-magic is processed. |
| |
| sv_2bool_flags |
| SvTRUE_nomg |
| sv_2nv_flags |
| SvNV_nomg |
| sv_cmp_flags |
| sv_cmp_locale_flags |
| sv_eq_flags |
| sv_collxfrm_flags |
| |
| In some of these cases, the non-C<_flags> functions have |
| been replaced with wrappers around the new functions. |
| |
| =head3 pv/pvs/sv versions of existing functions |
| |
| Many functions ending with pvn now have equivalent C<pv/pvs/sv> versions. |
| |
| =head3 List op-building functions |
| |
| List op-building functions have been added to the |
| API. See L<op_append_elem|perlapi/op_append_elem>, |
| L<op_append_list|perlapi/op_append_list>, and |
| L<op_prepend_elem|perlapi/op_prepend_elem> in L<perlapi>. |
| |
| =head3 C<LINKLIST> |
| |
| The L<LINKLIST|perlapi/LINKLIST> macro, part of op building that |
| constructs the execution-order op chain, has been added to the API. |
| |
| =head3 Localisation functions |
| |
| The C<save_freeop>, C<save_op>, C<save_pushi32ptr> and C<save_pushptrptr> |
| functions have been added to the API. |
| |
| =head3 Stash names |
| |
| A stash can now have a list of effective names in addition to its usual |
| name. The first effective name can be accessed via the C<HvENAME> macro, |
| which is now the recommended name to use in MRO linearisations (C<HvNAME> |
| being a fallback if there is no C<HvENAME>). |
| |
| These names are added and deleted via C<hv_ename_add> and |
| C<hv_ename_delete>. These two functions are I<not> part of the API. |
| |
| =head3 New functions for finding and removing magic |
| |
| The L<C<mg_findext()>|perlapi/mg_findext> and |
| L<C<sv_unmagicext()>|perlapi/sv_unmagicext> |
| functions have been added to the API. |
| They allow extension authors to find and remove magic attached to |
| scalars based on both the magic type and the magic virtual table, similar to how |
| sv_magicext() attaches magic of a certain type and with a given virtual table |
| to a scalar. This eliminates the need for extensions to walk the list of |
| C<MAGIC> pointers of an C<SV> to find the magic that belongs to them. |
| |
| =head3 C<find_rundefsv> |
| |
| This function returns the SV representing C<$_>, whether it's lexical |
| or dynamic. |
| |
| =head3 C<Perl_croak_no_modify> |
| |
| Perl_croak_no_modify() is short-hand for |
| C<Perl_croak("%s", PL_no_modify)>. |
| |
| =head3 C<PERL_STATIC_INLINE> define |
| |
| The C<PERL_STATIC_INLINE> define has been added to provide the best-guess |
| incantation to use for static inline functions, if the C compiler supports |
| C99-style static inline. If it doesn't, it'll give a plain C<static>. |
| |
| C<HAS_STATIC_INLINE> can be used to check if the compiler actually supports |
| inline functions. |
| |
| =head3 New C<pv_escape> option for hexadecimal escapes |
| |
| A new option, C<PERL_PV_ESCAPE_NONASCII>, has been added to C<pv_escape> to |
| dump all characters above ASCII in hexadecimal. Before, one could get all |
| characters as hexadecimal or the Latin1 non-ASCII as octal. |
| |
| =head3 C<lex_start> |
| |
| C<lex_start> has been added to the API, but is considered experimental. |
| |
| =head3 op_scope() and op_lvalue() |
| |
| The op_scope() and op_lvalue() functions have been added to the API, |
| but are considered experimental. |
| |
| =head2 C API Changes |
| |
| =head3 C<PERL_POLLUTE> has been removed |
| |
| The option to define C<PERL_POLLUTE> to expose older 5.005 symbols for |
| backwards compatibility has been removed. Its use was always discouraged, |
| and MakeMaker contains a more specific escape hatch: |
| |
| perl Makefile.PL POLLUTE=1 |
| |
| This can be used for modules that have not been upgraded to 5.6 naming |
| conventions (and really should be completely obsolete by now). |
| |
| =head3 Check API compatibility when loading XS modules |
| |
| When Perl's API changes in incompatible ways (which usually happens between |
| major releases), XS modules compiled for previous versions of Perl will no |
| longer work. They need to be recompiled against the new Perl. |
| |
| The C<XS_APIVERSION_BOOTCHECK> macro has been added to ensure that modules |
| are recompiled and to prevent users from accidentally loading modules |
| compiled for old perls into newer perls. That macro, which is called when |
| loading every newly compiled extension, compares the API version of the |
| running perl with the version a module has been compiled for and raises an |
| exception if they don't match. |
| |
| =head3 Perl_fetch_cop_label |
| |
| The first argument of the C API function C<Perl_fetch_cop_label> has changed |
| from C<struct refcounted_he *> to C<COP *>, to insulate the user from |
| implementation details. |
| |
| This API function was marked as "may change", and likely isn't in use outside |
| the core. (Neither an unpacked CPAN nor Google's codesearch finds any other |
| references to it.) |
| |
| =head3 GvCV() and GvGP() are no longer lvalues |
| |
| The new GvCV_set() and GvGP_set() macros are now provided to replace |
| assignment to those two macros. |
| |
| This allows a future commit to eliminate some backref magic between GV |
| and CVs, which will require complete control over assignment to the |
| C<gp_cv> slot. |
| |
| =head3 CvGV() is no longer an lvalue |
| |
| Under some circumstances, the CvGV() field of a CV is now |
| reference-counted. To ensure consistent behaviour, direct assignment to |
| it, for example C<CvGV(cv) = gv> is now a compile-time error. A new macro, |
| C<CvGV_set(cv,gv)> has been introduced to run this operation |
| safely. Note that modification of this field is not part of the public |
| API, regardless of this new macro (and despite its being listed in this section). |
| |
| =head3 CvSTASH() is no longer an lvalue |
| |
| The CvSTASH() macro can now only be used as an rvalue. CvSTASH_set() |
| has been added to replace assignment to CvSTASH(). This is to ensure |
| that backreferences are handled properly. These macros are not part of the |
| API. |
| |
| =head3 Calling conventions for C<newFOROP> and C<newWHILEOP> |
| |
| The way the parser handles labels has been cleaned up and refactored. As a |
| result, the newFOROP() constructor function no longer takes a parameter |
| stating what label is to go in the state op. |
| |
| The newWHILEOP() and newFOROP() functions no longer accept a line |
| number as a parameter. |
| |
| =head3 Flags passed to C<uvuni_to_utf8_flags> and C<utf8n_to_uvuni> |
| |
| Some of the flags parameters to uvuni_to_utf8_flags() and |
| utf8n_to_uvuni() have changed. This is a result of Perl's now allowing |
| internal storage and manipulation of code points that are problematic |
| in some situations. Hence, the default actions for these functions has |
| been complemented to allow these code points. The new flags are |
| documented in L<perlapi>. Code that requires the problematic code |
| points to be rejected needs to change to use the new flags. Some flag |
| names are retained for backward source compatibility, though they do |
| nothing, as they are now the default. However the flags |
| C<UNICODE_ALLOW_FDD0>, C<UNICODE_ALLOW_FFFF>, C<UNICODE_ILLEGAL>, and |
| C<UNICODE_IS_ILLEGAL> have been removed, as they stem from a |
| fundamentally broken model of how the Unicode non-character code points |
| should be handled, which is now described in |
| L<perlunicode/Non-character code points>. See also the Unicode section |
| under L</Selected Bug Fixes>. |
| |
| =head2 Deprecated C APIs |
| |
| =over |
| |
| =item C<Perl_ptr_table_clear> |
| |
| C<Perl_ptr_table_clear> is no longer part of Perl's public API. Calling it |
| now generates a deprecation warning, and it will be removed in a future |
| release. |
| |
| =item C<sv_compile_2op> |
| |
| The sv_compile_2op() API function is now deprecated. Searches suggest |
| that nothing on CPAN is using it, so this should have zero impact. |
| |
| It attempted to provide an API to compile code down to an optree, but failed |
| to bind correctly to lexicals in the enclosing scope. It's not possible to |
| fix this problem within the constraints of its parameters and return value. |
| |
| =item C<find_rundefsvoffset> |
| |
| The C<find_rundefsvoffset> function has been deprecated. It appeared that |
| its design was insufficient for reliably getting the lexical C<$_> at |
| run-time. |
| |
| Use the new C<find_rundefsv> function or the C<UNDERBAR> macro |
| instead. They directly return the right SV |
| representing C<$_>, whether it's |
| lexical or dynamic. |
| |
| =item C<CALL_FPTR> and C<CPERLscope> |
| |
| Those are left from an old implementation of C<MULTIPLICITY> using C++ objects, |
| which was removed in Perl 5.8. Nowadays these macros do exactly nothing, so |
| they shouldn't be used anymore. |
| |
| For compatibility, they are still defined for external C<XS> code. Only |
| extensions defining C<PERL_CORE> must be updated now. |
| |
| =back |
| |
| =head2 Other Internal Changes |
| |
| =head3 Stack unwinding |
| |
| The protocol for unwinding the C stack at the last stage of a C<die> |
| has changed how it identifies the target stack frame. This now uses |
| a separate variable C<PL_restartjmpenv>, where previously it relied on |
| the C<blk_eval.cur_top_env> pointer in the C<eval> context frame that |
| has nominally just been discarded. This change means that code running |
| during various stages of Perl-level unwinding no longer needs to take |
| care to avoid destroying the ghost frame. |
| |
| =head3 Scope stack entries |
| |
| The format of entries on the scope stack has been changed, resulting in a |
| reduction of memory usage of about 10%. In particular, the memory used by |
| the scope stack to record each active lexical variable has been halved. |
| |
| =head3 Memory allocation for pointer tables |
| |
| Memory allocation for pointer tables has been changed. Previously |
| C<Perl_ptr_table_store> allocated memory from the same arena system as |
| C<SV> bodies and C<HE>s, with freed memory remaining bound to those arenas |
| until interpreter exit. Now it allocates memory from arenas private to the |
| specific pointer table, and that memory is returned to the system when |
| C<Perl_ptr_table_free> is called. Additionally, allocation and release are |
| both less CPU intensive. |
| |
| =head3 C<UNDERBAR> |
| |
| The C<UNDERBAR> macro now calls C<find_rundefsv>. C<dUNDERBAR> is now a |
| noop but should still be used to ensure past and future compatibility. |
| |
| =head3 String comparison routines renamed |
| |
| The C<ibcmp_*> functions have been renamed and are now called C<foldEQ>, |
| C<foldEQ_locale>, and C<foldEQ_utf8>. The old names are still available as |
| macros. |
| |
| =head3 C<chop> and C<chomp> implementations merged |
| |
| The opcode bodies for C<chop> and C<chomp> and for C<schop> and C<schomp> |
| have been merged. The implementation functions Perl_do_chop() and |
| Perl_do_chomp(), never part of the public API, have been merged and |
| moved to a static function in F<pp.c>. This shrinks the Perl binary |
| slightly, and should not affect any code outside the core (unless it is |
| relying on the order of side-effects when C<chomp> is passed a I<list> of |
| values). |
| |
| =head1 Selected Bug Fixes |
| |
| =head2 I/O |
| |
| =over 4 |
| |
| =item * |
| |
| Perl no longer produces this warning: |
| |
| $ perl -we 'open(my $f, ">", \my $x); binmode($f, "scalar")' |
| Use of uninitialized value in binmode at -e line 1. |
| |
| =item * |
| |
| Opening a glob reference via C<< open($fh, ">", \*glob) >> no longer |
| causes the glob to be corrupted when the filehandle is printed to. This would |
| cause Perl to crash whenever the glob's contents were accessed |
| [perl #77492]. |
| |
| =item * |
| |
| PerlIO no longer crashes when called recursively, such as from a signal |
| handler. Now it just leaks memory [perl #75556]. |
| |
| =item * |
| |
| Most I/O functions were not warning for unopened handles unless the |
| "closed" and "unopened" warnings categories were both enabled. Now only |
| C<use warnings 'unopened'> is necessary to trigger these warnings, as |
| had always been the intention. |
| |
| =item * |
| |
| There have been several fixes to PerlIO layers: |
| |
| When C<binmode(FH, ":crlf")> pushes the C<:crlf> layer on top of the stack, |
| it no longer enables crlf layers lower in the stack so as to avoid |
| unexpected results [perl #38456]. |
| |
| Opening a file in C<:raw> mode now does what it advertises to do (first |
| open the file, then C<binmode> it), instead of simply leaving off the top |
| layer [perl #80764]. |
| |
| The three layers C<:pop>, C<:utf8>, and C<:bytes> didn't allow stacking when |
| opening a file. For example |
| this: |
| |
| open(FH, ">:pop:perlio", "some.file") or die $!; |
| |
| would throw an "Invalid argument" error. This has been fixed in this |
| release [perl #82484]. |
| |
| =back |
| |
| =head2 Regular Expression Bug Fixes |
| |
| =over |
| |
| =item * |
| |
| The regular expression engine no longer loops when matching |
| C<"\N{LATIN SMALL LIGATURE FF}" =~ /f+/i> and similar expressions |
| [perl #72998] (5.12.1). |
| |
| =item * |
| |
| The trie runtime code should no longer allocate massive amounts of memory, |
| fixing #74484. |
| |
| =item * |
| |
| Syntax errors in C<< (?{...}) >> blocks no longer cause panic messages |
| [perl #2353]. |
| |
| =item * |
| |
| A pattern like C<(?:(o){2})?> no longer causes a "panic" error |
| [perl #39233]. |
| |
| =item * |
| |
| A fatal error in regular expressions containing C<(.*?)> when processing |
| UTF-8 data has been fixed [perl #75680] (5.12.2). |
| |
| =item * |
| |
| An erroneous regular expression engine optimisation that caused regex verbs like |
| C<*COMMIT> sometimes to be ignored has been removed. |
| |
| =item * |
| |
| The regular expression bracketed character class C<[\8\9]> was effectively the |
| same as C<[89\000]>, incorrectly matching a NULL character. It also gave |
| incorrect warnings that the C<8> and C<9> were ignored. Now C<[\8\9]> is the |
| same as C<[89]> and gives legitimate warnings that C<\8> and C<\9> are |
| unrecognized escape sequences, passed-through. |
| |
| =item * |
| |
| A regular expression match in the right-hand side of a global substitution |
| (C<s///g>) that is in the same scope will no longer cause match variables |
| to have the wrong values on subsequent iterations. This can happen when an |
| array or hash subscript is interpolated in the right-hand side, as in |
| C<s|(.)|@a{ print($1), /./ }|g> [perl #19078]. |
| |
| =item * |
| |
| Several cases in which characters in the Latin-1 non-ASCII range (0x80 to |
| 0xFF) used not to match themselves, or used to match both a character class |
| and its complement, have been fixed. For instance, U+00E2 could match both |
| C<\w> and C<\W> [perl #78464] [perl #18281] [perl #60156]. |
| |
| =item * |
| |
| Matching a Unicode character against an alternation containing characters |
| that happened to match continuation bytes in the former's UTF8 |
| representation (like C<qq{\x{30ab}} =~ /\xab|\xa9/>) would cause erroneous |
| warnings [perl #70998]. |
| |
| =item * |
| |
| The trie optimisation was not taking empty groups into account, preventing |
| "foo" from matching C</\A(?:(?:)foo|bar|zot)\z/> [perl #78356]. |
| |
| =item * |
| |
| A pattern containing a C<+> inside a lookahead would sometimes cause an |
| incorrect match failure in a global match (for example, C</(?=(\S+))/g>) |
| [perl #68564]. |
| |
| =item * |
| |
| A regular expression optimisation would sometimes cause a match with a |
| C<{n,m}> quantifier to fail when it should have matched [perl #79152]. |
| |
| =item * |
| |
| Case-insensitive matching in regular expressions compiled under |
| C<use locale> now works much more sanely when the pattern or target |
| string is internally encoded in UTF8. Previously, under these |
| conditions the localeness was completely lost. Now, code points |
| above 255 are treated as Unicode, but code points between 0 and 255 |
| are treated using the current locale rules, regardless of whether |
| the pattern or the string is encoded in UTF8. The few case-insensitive |
| matches that cross the 255/256 boundary are not allowed. For |
| example, 0xFF does not caselessly match the character at 0x178, |
| LATIN CAPITAL LETTER Y WITH DIAERESIS, because 0xFF may not be LATIN |
| SMALL LETTER Y in the current locale, and Perl has no way of knowing |
| if that character even exists in the locale, much less what code |
| point it is. |
| |
| =item * |
| |
| The C<(?|...)> regular expression construct no longer crashes if the final |
| branch has more sets of capturing parentheses than any other branch. This |
| was fixed in Perl 5.10.1 for the case of a single branch, but that fix did |
| not take multiple branches into account [perl #84746]. |
| |
| =item * |
| |
| A bug has been fixed in the implementation of C<{...}> quantifiers in |
| regular expressions that prevented the code block in |
| C</((\w+)(?{ print $2 })){2}/> from seeing the C<$2> sometimes |
| [perl #84294]. |
| |
| =back |
| |
| =head2 Syntax/Parsing Bugs |
| |
| =over |
| |
| =item * |
| |
| C<when (scalar) {...}> no longer crashes, but produces a syntax error |
| [perl #74114] (5.12.1). |
| |
| =item * |
| |
| A label right before a string eval (C<foo: eval $string>) no longer causes |
| the label to be associated also with the first statement inside the eval |
| [perl #74290] (5.12.1). |
| |
| =item * |
| |
| The C<no 5.13.2> form of C<no> no longer tries to turn on features or |
| pragmata (like L<strict>) [perl #70075] (5.12.2). |
| |
| =item * |
| |
| C<BEGIN {require 5.12.0}> now behaves as documented, rather than behaving |
| identically to C<use 5.12.0>. Previously, C<require> in a C<BEGIN> block |
| was erroneously executing the C<use feature ':5.12.0'> and |
| C<use strict> behaviour, which only C<use> was documented to |
| provide [perl #69050]. |
| |
| =item * |
| |
| A regression introduced in Perl 5.12.0, making |
| C<< my $x = 3; $x = length(undef) >> result in C<$x> set to C<3> has been |
| fixed. C<$x> will now be C<undef> [perl #85508] (5.12.2). |
| |
| =item * |
| |
| When strict "refs" mode is off, C<%{...}> in rvalue context returns |
| C<undef> if its argument is undefined. An optimisation introduced in Perl |
| 5.12.0 to make C<keys %{...}> faster when used as a boolean did not take |
| this into account, causing C<keys %{+undef}> (and C<keys %$foo> when |
| C<$foo> is undefined) to be an error, which it should be so in strict |
| mode only [perl #81750]. |
| |
| =item * |
| |
| Constant-folding used to cause |
| |
| $text =~ ( 1 ? /phoo/ : /bear/) |
| |
| to turn into |
| |
| $text =~ /phoo/ |
| |
| at compile time. Now it correctly matches against C<$_> [perl #20444]. |
| |
| =item * |
| |
| Parsing Perl code (either with string C<eval> or by loading modules) from |
| within a C<UNITCHECK> block no longer causes the interpreter to crash |
| [perl #70614]. |
| |
| =item * |
| |
| String C<eval>s no longer fail after 2 billion scopes have been |
| compiled [perl #83364]. |
| |
| =item * |
| |
| The parser no longer hangs when encountering certain Unicode characters, |
| such as U+387 [perl #74022]. |
| |
| =item * |
| |
| Defining a constant with the same name as one of Perl's special blocks |
| (like C<INIT>) stopped working in 5.12.0, but has now been fixed |
| [perl #78634]. |
| |
| =item * |
| |
| A reference to a literal value used as a hash key (C<$hash{\"foo"}>) used |
| to be stringified, even if the hash was tied [perl #79178]. |
| |
| =item * |
| |
| A closure containing an C<if> statement followed by a constant or variable |
| is no longer treated as a constant [perl #63540]. |
| |
| =item * |
| |
| C<state> can now be used with attributes. It |
| used to mean the same thing as |
| C<my> if any attributes were present [perl #68658]. |
| |
| =item * |
| |
| Expressions like C<< @$a > 3 >> no longer cause C<$a> to be mentioned in |
| the "Use of uninitialized value in numeric gt" warning when C<$a> is |
| undefined (since it is not part of the C<< > >> expression, but the operand |
| of the C<@>) [perl #72090]. |
| |
| =item * |
| |
| Accessing an element of a package array with a hard-coded number (as |
| opposed to an arbitrary expression) would crash if the array did not exist. |
| Usually the array would be autovivified during compilation, but typeglob |
| manipulation could remove it, as in these two cases which used to crash: |
| |
| *d = *a; print $d[0]; |
| undef *d; print $d[0]; |
| |
| =item * |
| |
| The B<-C> command-line option, when used on the shebang line, can now be |
| followed by other options [perl #72434]. |
| |
| =item * |
| |
| The C<B> module was returning C<B::OP>s instead of C<B::LOGOP>s for |
| C<entertry> [perl #80622]. This was due to a bug in the Perl core, |
| not in C<B> itself. |
| |
| =back |
| |
| =head2 Stashes, Globs and Method Lookup |
| |
| Perl 5.10.0 introduced a new internal mechanism for caching MROs (method |
| resolution orders, or lists of parent classes; aka "isa" caches) to make |
| method lookup faster (so C<@ISA> arrays would not have to be searched |
| repeatedly). Unfortunately, this brought with it quite a few bugs. Almost |
| all of these have been fixed now, along with a few MRO-related bugs that |
| existed before 5.10.0: |
| |
| =over |
| |
| =item * |
| |
| The following used to have erratic effects on method resolution, because |
| the "isa" caches were not reset or otherwise ended up listing the wrong |
| classes. These have been fixed. |
| |
| =over |
| |
| =item Aliasing packages by assigning to globs [perl #77358] |
| |
| =item Deleting packages by deleting their containing stash elements |
| |
| =item Undefining the glob containing a package (C<undef *Foo::>) |
| |
| =item Undefining an ISA glob (C<undef *Foo::ISA>) |
| |
| =item Deleting an ISA stash element (C<delete $Foo::{ISA}>) |
| |
| =item Sharing @ISA arrays between classes (via C<*Foo::ISA = \@Bar::ISA> or |
| C<*Foo::ISA = *Bar::ISA>) [perl #77238] |
| |
| =back |
| |
| C<undef *Foo::ISA> would even stop a new C<@Foo::ISA> array from updating |
| caches. |
| |
| =item * |
| |
| Typeglob assignments would crash if the glob's stash no longer existed, so |
| long as the glob assigned to were named C<ISA> or the glob on either side of |
| the assignment contained a subroutine. |
| |
| =item * |
| |
| C<PL_isarev>, which is accessible to Perl via C<mro::get_isarev> is now |
| updated properly when packages are deleted or removed from the C<@ISA> of |
| other classes. This allows many packages to be created and deleted without |
| causing a memory leak [perl #75176]. |
| |
| =back |
| |
| In addition, various other bugs related to typeglobs and stashes have been |
| fixed: |
| |
| =over |
| |
| =item * |
| |
| Some work has been done on the internal pointers that link between symbol |
| tables (stashes), typeglobs, and subroutines. This has the effect that |
| various edge cases related to deleting stashes or stash entries (for example, |
| <%FOO:: = ()>), and complex typeglob or code-reference aliasing, will no |
| longer crash the interpreter. |
| |
| =item * |
| |
| Assigning a reference to a glob copy now assigns to a glob slot instead of |
| overwriting the glob with a scalar [perl #1804] [perl #77508]. |
| |
| =item * |
| |
| A bug when replacing the glob of a loop variable within the loop has been fixed |
| [perl #21469]. This |
| means the following code will no longer crash: |
| |
| for $x (...) { |
| *x = *y; |
| } |
| |
| =item * |
| |
| Assigning a glob to a PVLV used to convert it to a plain string. Now it |
| works correctly, and a PVLV can hold a glob. This would happen when a |
| nonexistent hash or array element was passed to a subroutine: |
| |
| sub { $_[0] = *foo }->($hash{key}); |
| # $_[0] would have been the string "*main::foo" |
| |
| It also happened when a glob was assigned to, or returned from, an element |
| of a tied array or hash [perl #36051]. |
| |
| =item * |
| |
| When trying to report C<Use of uninitialized value $Foo::BAR>, crashes could |
| occur if the glob holding the global variable in question had been detached |
| from its original stash by, for example, C<delete $::{"Foo::"}>. This has |
| been fixed by disabling the reporting of variable names in those |
| cases. |
| |
| =item * |
| |
| During the restoration of a localised typeglob on scope exit, any |
| destructors called as a result would be able to see the typeglob in an |
| inconsistent state, containing freed entries, which could result in a |
| crash. This would affect code like this: |
| |
| local *@; |
| eval { die bless [] }; # puts an object in $@ |
| sub DESTROY { |
| local $@; # boom |
| } |
| |
| Now the glob entries are cleared before any destructors are called. This |
| also means that destructors can vivify entries in the glob. So Perl tries |
| again and, if the entries are re-created too many times, dies with a |
| "panic: gp_free ..." error message. |
| |
| =item * |
| |
| If a typeglob is freed while a subroutine attached to it is still |
| referenced elsewhere, the subroutine is renamed to C<__ANON__> in the same |
| package, unless the package has been undefined, in which case the C<__ANON__> |
| package is used. This could cause packages to be sometimes autovivified, |
| such as if the package had been deleted. Now this no longer occurs. |
| The C<__ANON__> package is also now used when the original package is |
| no longer attached to the symbol table. This avoids memory leaks in some |
| cases [perl #87664]. |
| |
| =item * |
| |
| Subroutines and package variables inside a package whose name ends with |
| C<::> can now be accessed with a fully qualified name. |
| |
| =back |
| |
| =head2 Unicode |
| |
| =over |
| |
| =item * |
| |
| What has become known as "the Unicode Bug" is almost completely resolved in |
| this release. Under C<use feature 'unicode_strings'> (which is |
| automatically selected by C<use 5.012> and above), the internal |
| storage format of a string no longer affects the external semantics. |
| [perl #58182]. |
| |
| There are two known exceptions: |
| |
| =over |
| |
| =item 1 |
| |
| The now-deprecated, user-defined case-changing |
| functions require utf8-encoded strings to operate. The CPAN module |
| L<Unicode::Casing> has been written to replace this feature without its |
| drawbacks, and the feature is scheduled to be removed in 5.16. |
| |
| =item 2 |
| |
| quotemeta() (and its in-line equivalent C<\Q>) can also give different |
| results depending on whether a string is encoded in UTF-8. See |
| L<perlunicode/The "Unicode Bug">. |
| |
| =back |
| |
| =item * |
| |
| Handling of Unicode non-character code points has changed. |
| Previously they were mostly considered illegal, except that in some |
| place only one of the 66 of them was known. The Unicode Standard |
| considers them all legal, but forbids their "open interchange". |
| This is part of the change to allow internal use of any code |
| point (see L</Core Enhancements>). Together, these changes resolve |
| [perl #38722], [perl #51918], [perl #51936], and [perl #63446]. |
| |
| =item * |
| |
| Case-insensitive C<"/i"> regular expression matching of Unicode |
| characters that match multiple characters now works much more as |
| intended. For example |
| |
| "\N{LATIN SMALL LIGATURE FFI}" =~ /ffi/ui |
| |
| and |
| |
| "ffi" =~ /\N{LATIN SMALL LIGATURE FFI}/ui |
| |
| are both true. Previously, there were many bugs with this feature. |
| What hasn't been fixed are the places where the pattern contains the |
| multiple characters, but the characters are split up by other things, |
| such as in |
| |
| "\N{LATIN SMALL LIGATURE FFI}" =~ /(f)(f)i/ui |
| |
| or |
| |
| "\N{LATIN SMALL LIGATURE FFI}" =~ /ffi*/ui |
| |
| or |
| |
| "\N{LATIN SMALL LIGATURE FFI}" =~ /[a-f][f-m][g-z]/ui |
| |
| None of these match. |
| |
| Also, this matching doesn't fully conform to the current Unicode |
| Standard, which asks that the matching be made upon the NFD |
| (Normalization Form Decomposed) of the text. However, as of this |
| writing (April 2010), the Unicode Standard is currently in flux about |
| what they will recommend doing with regard in such scenarios. It may be |
| that they will throw out the whole concept of multi-character matches. |
| [perl #71736]. |
| |
| =item * |
| |
| Naming a deprecated character in C<\N{I<NAME>}> no longer leaks memory. |
| |
| =item * |
| |
| We fixed a bug that could cause C<\N{I<NAME>}> constructs followed by |
| a single C<"."> to be parsed incorrectly [perl #74978] (5.12.1). |
| |
| =item * |
| |
| C<chop> now correctly handles characters above C<"\x{7fffffff}"> |
| [perl #73246]. |
| |
| =item * |
| |
| Passing to C<index> an offset beyond the end of the string when the string |
| is encoded internally in UTF8 no longer causes panics [perl #75898]. |
| |
| =item * |
| |
| warn() and die() now respect utf8-encoded scalars [perl #45549]. |
| |
| =item * |
| |
| Sometimes the UTF8 length cache would not be reset on a value |
| returned by substr, causing C<length(substr($uni_string, ...))> to give |
| wrong answers. With C<${^UTF8CACHE}> set to -1, it would also produce |
| a "panic" error message [perl #77692]. |
| |
| =back |
| |
| =head2 Ties, Overloading and Other Magic |
| |
| =over |
| |
| =item * |
| |
| Overloading now works properly in conjunction with tied |
| variables. What formerly happened was that most ops checked their |
| arguments for overloading I<before> checking for magic, so for example |
| an overloaded object returned by a tied array access would usually be |
| treated as not overloaded [RT #57012]. |
| |
| =item * |
| |
| Various instances of magic (like tie methods) being called on tied variables |
| too many or too few times have been fixed: |
| |
| =over |
| |
| =item * |
| |
| C<< $tied->() >> did not always call FETCH [perl #8438]. |
| |
| =item * |
| |
| Filetest operators and C<y///> and C<tr///> were calling FETCH too |
| many times. |
| |
| =item * |
| |
| The C<=> operator used to ignore magic on its right-hand side if the |
| scalar happened to hold a typeglob (if a typeglob was the last thing |
| returned from or assigned to a tied scalar) [perl #77498]. |
| |
| =item * |
| |
| Dereference operators used to ignore magic if the argument was a |
| reference already (such as from a previous FETCH) [perl #72144]. |
| |
| =item * |
| |
| C<splice> now calls set-magic (so changes made |
| by C<splice @ISA> are respected by method calls) [perl #78400]. |
| |
| =item * |
| |
| In-memory files created by C<< open($fh, ">", \$buffer) >> were not calling |
| FETCH/STORE at all [perl #43789] (5.12.2). |
| |
| =item * |
| |
| utf8::is_utf8() now respects get-magic (like C<$1>) (5.12.1). |
| |
| =back |
| |
| =item * |
| |
| Non-commutative binary operators used to swap their operands if the same |
| tied scalar was used for both operands and returned a different value for |
| each FETCH. For instance, if C<$t> returned 2 the first time and 3 the |
| second, then C<$t/$t> would evaluate to 1.5. This has been fixed |
| [perl #87708]. |
| |
| =item * |
| |
| String C<eval> now detects taintedness of overloaded or tied |
| arguments [perl #75716]. |
| |
| =item * |
| |
| String C<eval> and regular expression matches against objects with string |
| overloading no longer cause memory corruption or crashes [perl #77084]. |
| |
| =item * |
| |
| L<readline|perlfunc/"readline EXPR"> now honors C<< <> >> overloading on tied |
| arguments. |
| |
| =item * |
| |
| C<< <expr> >> always respects overloading now if the expression is |
| overloaded. |
| |
| Because "S<< <> as >> glob" was parsed differently from |
| "S<< <> as >> filehandle" from 5.6 onwards, something like C<< <$foo[0]> >> did |
| not handle overloading, even if C<$foo[0]> was an overloaded object. This |
| was contrary to the documentation for L<overload>, and meant that C<< <> >> |
| could not be used as a general overloaded iterator operator. |
| |
| =item * |
| |
| The fallback behaviour of overloading on binary operators was asymmetric |
| [perl #71286]. |
| |
| =item * |
| |
| Magic applied to variables in the main package no longer affects other packages. |
| See L</Magic variables outside the main package> above [perl #76138]. |
| |
| =item * |
| |
| Sometimes magic (ties, taintedness, etc.) attached to variables could cause |
| an object to last longer than it should, or cause a crash if a tied |
| variable were freed from within a tie method. These have been fixed |
| [perl #81230]. |
| |
| =item * |
| |
| DESTROY methods of objects implementing ties are no longer able to crash by |
| accessing the tied variable through a weak reference [perl #86328]. |
| |
| =item * |
| |
| Fixed a regression of kill() when a match variable is used for the |
| process ID to kill [perl #75812]. |
| |
| =item * |
| |
| C<$AUTOLOAD> used to remain tainted forever if it ever became tainted. Now |
| it is correctly untainted if an autoloaded method is called and the method |
| name was not tainted. |
| |
| =item * |
| |
| C<sprintf> now dies when passed a tainted scalar for the format. It did |
| already die for arbitrary expressions, but not for simple scalars |
| [perl #82250]. |
| |
| =item * |
| |
| C<lc>, C<uc>, C<lcfirst>, and C<ucfirst> no longer return untainted strings |
| when the argument is tainted. This has been broken since perl 5.8.9 |
| [perl #87336]. |
| |
| =back |
| |
| =head2 The Debugger |
| |
| =over |
| |
| =item * |
| |
| The Perl debugger now also works in taint mode [perl #76872]. |
| |
| =item * |
| |
| Subroutine redefinition works once more in the debugger [perl #48332]. |
| |
| =item * |
| |
| When B<-d> is used on the shebang (C<#!>) line, the debugger now has access |
| to the lines of the main program. In the past, this sometimes worked and |
| sometimes did not, depending on the order in which things happened to be |
| arranged in memory [perl #71806]. |
| |
| =item * |
| |
| A possible memory leak when using L<caller()|perlfunc/"caller EXPR"> to set |
| C<@DB::args> has been fixed (5.12.2). |
| |
| =item * |
| |
| Perl no longer stomps on C<$DB::single>, C<$DB::trace>, and C<$DB::signal> |
| if these variables already have values when C<$^P> is assigned to [perl #72422]. |
| |
| =item * |
| |
| C<#line> directives in string evals were not properly updating the arrays |
| of lines of code (C<< @{"_< ..."} >>) that the debugger (or any debugging or |
| profiling module) uses. In threaded builds, they were not being updated at |
| all. In non-threaded builds, the line number was ignored, so any change to |
| the existing line number would cause the lines to be misnumbered |
| [perl #79442]. |
| |
| =back |
| |
| =head2 Threads |
| |
| =over |
| |
| =item * |
| |
| Perl no longer accidentally clones lexicals in scope within active stack |
| frames in the parent when creating a child thread [perl #73086]. |
| |
| =item * |
| |
| Several memory leaks in cloning and freeing threaded Perl interpreters have been |
| fixed [perl #77352]. |
| |
| =item * |
| |
| Creating a new thread when directory handles were open used to cause a |
| crash, because the handles were not cloned, but simply passed to the new |
| thread, resulting in a double free. |
| |
| Now directory handles are cloned properly on Windows |
| and on systems that have a C<fchdir> function. On other |
| systems, new threads simply do not inherit directory |
| handles from their parent threads [perl #75154]. |
| |
| =item * |
| |
| The typeglob C<*,>, which holds the scalar variable C<$,> (output field |
| separator), had the wrong reference count in child threads. |
| |
| =item * |
| |
| [perl #78494] When pipes are shared between threads, the C<close> function |
| (and any implicit close, such as on thread exit) no longer blocks. |
| |
| =item * |
| |
| Perl now does a timely cleanup of SVs that are cloned into a new |
| thread but then discovered to be orphaned (that is, their owners |
| are I<not> cloned). This eliminates several "scalars leaked" |
| warnings when joining threads. |
| |
| =back |
| |
| =head2 Scoping and Subroutines |
| |
| =over |
| |
| =item * |
| |
| Lvalue subroutines are again able to return copy-on-write scalars. This |
| had been broken since version 5.10.0 [perl #75656] (5.12.3). |
| |
| =item * |
| |
| C<require> no longer causes C<caller> to return the wrong file name for |
| the scope that called C<require> and other scopes higher up that had the |
| same file name [perl #68712]. |
| |
| =item * |
| |
| C<sort> with a C<($$)>-prototyped comparison routine used to cause the value |
| of C<@_> to leak out of the sort. Taking a reference to C<@_> within the |
| sorting routine could cause a crash [perl #72334]. |
| |
| =item * |
| |
| Match variables (like C<$1>) no longer persist between calls to a sort |
| subroutine [perl #76026]. |
| |
| =item * |
| |
| Iterating with C<foreach> over an array returned by an lvalue sub now works |
| [perl #23790]. |
| |
| =item * |
| |
| C<$@> is now localised during calls to C<binmode> to prevent action at a |
| distance [perl #78844]. |
| |
| =item * |
| |
| Calling a closure prototype (what is passed to an attribute handler for a |
| closure) now results in a "Closure prototype called" error message instead |
| of a crash [perl #68560]. |
| |
| =item * |
| |
| Mentioning a read-only lexical variable from the enclosing scope in a |
| string C<eval> no longer causes the variable to become writable |
| [perl #19135]. |
| |
| =back |
| |
| =head2 Signals |
| |
| =over |
| |
| =item * |
| |
| Within signal handlers, C<$!> is now implicitly localized. |
| |
| =item * |
| |
| CHLD signals are no longer unblocked after a signal handler is called if |
| they were blocked before by C<POSIX::sigprocmask> [perl #82040]. |
| |
| =item * |
| |
| A signal handler called within a signal handler could cause leaks or |
| double-frees. Now fixed [perl #76248]. |
| |
| =back |
| |
| =head2 Miscellaneous Memory Leaks |
| |
| =over |
| |
| =item * |
| |
| Several memory leaks when loading XS modules were fixed (5.12.2). |
| |
| =item * |
| |
| L<substr()|perlfunc/"substr EXPR,OFFSET,LENGTH,REPLACEMENT">, |
| L<pos()|perlfunc/"index STR,SUBSTR,POSITION">, L<keys()|perlfunc/"keys HASH">, |
| and L<vec()|perlfunc/"vec EXPR,OFFSET,BITS"> could, when used in combination |
| with lvalues, result in leaking the scalar value they operate on, and cause its |
| destruction to happen too late. This has now been fixed. |
| |
| =item * |
| |
| The postincrement and postdecrement operators, C<++> and C<-->, used to cause |
| leaks when used on references. This has now been fixed. |
| |
| =item * |
| |
| Nested C<map> and C<grep> blocks no longer leak memory when processing |
| large lists [perl #48004]. |
| |
| =item * |
| |
| C<use I<VERSION>> and C<no I<VERSION>> no longer leak memory [perl #78436] |
| [perl #69050]. |
| |
| =item * |
| |
| C<.=> followed by C<< <> >> or C<readline> would leak memory if C<$/> |
| contained characters beyond the octet range and the scalar assigned to |
| happened to be encoded as UTF8 internally [perl #72246]. |
| |
| =item * |
| |
| C<eval 'BEGIN{die}'> no longer leaks memory on non-threaded builds. |
| |
| =back |
| |
| =head2 Memory Corruption and Crashes |
| |
| =over |
| |
| =item * |
| |
| glob() no longer crashes when C<%File::Glob::> is empty and |
| C<CORE::GLOBAL::glob> isn't present [perl #75464] (5.12.2). |
| |
| =item * |
| |
| readline() has been fixed when interrupted by signals so it no longer |
| returns the "same thing" as before or random memory. |
| |
| =item * |
| |
| When assigning a list with duplicated keys to a hash, the assignment used to |
| return garbage and/or freed values: |
| |
| @a = %h = (list with some duplicate keys); |
| |
| This has now been fixed [perl #31865]. |
| |
| =item * |
| |
| The mechanism for freeing objects in globs used to leave dangling |
| pointers to freed SVs, meaning Perl users could see corrupted state |
| during destruction. |
| |
| Perl now frees only the affected slots of the GV, rather than freeing |
| the GV itself. This makes sure that there are no dangling refs or |
| corrupted state during destruction. |
| |
| =item * |
| |
| The interpreter no longer crashes when freeing deeply-nested arrays of |
| arrays. Hashes have not been fixed yet [perl #44225]. |
| |
| =item * |
| |
| Concatenating long strings under C<use encoding> no longer causes Perl to |
| crash [perl #78674]. |
| |
| =item * |
| |
| Calling C<< ->import >> on a class lacking an import method could corrupt |
| the stack, resulting in strange behaviour. For instance, |
| |
| push @a, "foo", $b = bar->import; |
| |
| would assign "foo" to C<$b> [perl #63790]. |
| |
| =item * |
| |
| The C<recv> function could crash when called with the MSG_TRUNC flag |
| [perl #75082]. |
| |
| =item * |
| |
| C<formline> no longer crashes when passed a tainted format picture. It also |
| taints C<$^A> now if its arguments are tainted [perl #79138]. |
| |
| =item * |
| |
| A bug in how we process filetest operations could cause a segfault. |
| Filetests don't always expect an op on the stack, so we now use |
| TOPs only if we're sure that we're not C<stat>ing the C<_> filehandle. |
| This is indicated by C<OPf_KIDS> (as checked in ck_ftst) [perl #74542] |
| (5.12.1). |
| |
| =item * |
| |
| unpack() now handles scalar context correctly for C<%32H> and C<%32u>, |
| fixing a potential crash. split() would crash because the third item |
| on the stack wasn't the regular expression it expected. C<unpack("%2H", |
| ...)> would return both the unpacked result and the checksum on the stack, |
| as would C<unpack("%2u", ...)> [perl #73814] (5.12.2). |
| |
| =back |
| |
| =head2 Fixes to Various Perl Operators |
| |
| =over |
| |
| =item * |
| |
| The C<&>, C<|>, and C<^> bitwise operators no longer coerce read-only arguments |
| [perl #20661]. |
| |
| =item * |
| |
| Stringifying a scalar containing "-0.0" no longer has the effect of turning |
| false into true [perl #45133]. |
| |
| =item * |
| |
| Some numeric operators were converting integers to floating point, |
| resulting in loss of precision on 64-bit platforms [perl #77456]. |
| |
| =item * |
| |
| sprintf() was ignoring locales when called with constant arguments |
| [perl #78632]. |
| |
| =item * |
| |
| Combining the vector (C<%v>) flag and dynamic precision would |
| cause C<sprintf> to confuse the order of its arguments, making it |
| treat the string as the precision and vice-versa [perl #83194]. |
| |
| =back |
| |
| =head2 Bugs Relating to the C API |
| |
| =over |
| |
| =item * |
| |
| The C-level C<lex_stuff_pvn> function would sometimes cause a spurious |
| syntax error on the last line of the file if it lacked a final semicolon |
| [perl #74006] (5.12.1). |
| |
| =item * |
| |
| The C<eval_sv> and C<eval_pv> C functions now set C<$@> correctly when |
| there is a syntax error and no C<G_KEEPERR> flag, and never set it if the |
| C<G_KEEPERR> flag is present [perl #3719]. |
| |
| =item * |
| |
| The XS multicall API no longer causes subroutines to lose reference counts |
| if called via the multicall interface from within those very subroutines. |
| This affects modules like L<List::Util>. Calling one of its functions with an |
| active subroutine as the first argument could cause a crash [perl #78070]. |
| |
| =item * |
| |
| The C<SvPVbyte> function available to XS modules now calls magic before |
| downgrading the SV, to avoid warnings about wide characters [perl #72398]. |
| |
| =item * |
| |
| The ref types in the typemap for XS bindings now support magical variables |
| [perl #72684]. |
| |
| =item * |
| |
| C<sv_catsv_flags> no longer calls C<mg_get> on its second argument (the |
| source string) if the flags passed to it do not include SV_GMAGIC. So it |
| now matches the documentation. |
| |
| =item * |
| |
| C<my_strftime> no longer leaks memory. This fixes a memory leak in |
| C<POSIX::strftime> [perl #73520]. |
| |
| =item * |
| |
| F<XSUB.h> now correctly redefines fgets under PERL_IMPLICIT_SYS [perl #55049] |
| (5.12.1). |
| |
| =item * |
| |
| XS code using fputc() or fputs() on Windows could cause an error |
| due to their arguments being swapped [perl #72704] (5.12.1). |
| |
| =item * |
| |
| A possible segfault in the C<T_PTROBJ> default typemap has been fixed |
| (5.12.2). |
| |
| =item * |
| |
| A bug that could cause "Unknown error" messages when |
| C<call_sv(code, G_EVAL)> is called from an XS destructor has been fixed |
| (5.12.2). |
| |
| =back |
| |
| =head1 Known Problems |
| |
| This is a list of significant unresolved issues which are regressions |
| from earlier versions of Perl or which affect widely-used CPAN modules. |
| |
| =over 4 |
| |
| =item * |
| |
| C<List::Util::first> misbehaves in the presence of a lexical C<$_> |
| (typically introduced by C<my $_> or implicitly by C<given>). The variable |
| that gets set for each iteration is the package variable C<$_>, not the |
| lexical C<$_>. |
| |
| A similar issue may occur in other modules that provide functions which |
| take a block as their first argument, like |
| |
| foo { ... $_ ...} list |
| |
| See also: L<http://rt.perl.org/rt3/Public/Bug/Display.html?id=67694> |
| |
| =item * |
| |
| readline() returns an empty string instead of a cached previous value |
| when it is interrupted by a signal |
| |
| =item * |
| |
| The changes in prototype handling break L<Switch>. A patch has been sent |
| upstream and will hopefully appear on CPAN soon. |
| |
| =item * |
| |
| The upgrade to F<ExtUtils-MakeMaker-6.57_05> has caused |
| some tests in the F<Module-Install> distribution on CPAN to |
| fail. (Specifically, F<02_mymeta.t> tests 5 and 21; F<18_all_from.t> |
| tests 6 and 15; F<19_authors.t> tests 5, 13, 21, and 29; and |
| F<20_authors_with_special_characters.t> tests 6, 15, and 23 in version |
| 1.00 of that distribution now fail.) |
| |
| =item * |
| |
| On VMS, C<Time::HiRes> tests will fail due to a bug in the CRTL's |
| implementation of C<setitimer>: previous timer values would be cleared |
| if a timer expired but not if the timer was reset before expiring. HP |
| OpenVMS Engineering have corrected the problem and will release a patch |
| in due course (Quix case # QXCM1001115136). |
| |
| =item * |
| |
| On VMS, there were a handful of C<Module::Build> test failures we didn't |
| get to before the release; please watch CPAN for updates. |
| |
| =back |
| |
| =head1 Errata |
| |
| =head2 keys(), values(), and each() work on arrays |
| |
| You can now use the keys(), values(), and each() builtins on arrays; |
| previously you could use them only on hashes. See L<perlfunc> for details. |
| This is actually a change introduced in perl 5.12.0, but it was missed from |
| that release's L<perl5120delta>. |
| |
| =head2 split() and C<@_> |
| |
| split() no longer modifies C<@_> when called in scalar or void context. |
| In void context it now produces a "Useless use of split" warning. |
| This was also a perl 5.12.0 change that missed the perldelta. |
| |
| =head1 Obituary |
| |
| Randy Kobes, creator of http://kobesearch.cpan.org/ and |
| contributor/maintainer to several core Perl toolchain modules, passed |
| away on September 18, 2010 after a battle with lung cancer. The community |
| was richer for his involvement. He will be missed. |
| |
| =head1 Acknowledgements |
| |
| Perl 5.14.0 represents one year of development since |
| Perl 5.12.0 and contains nearly 550,000 lines of changes across nearly |
| 3,000 files from 150 authors and committers. |
| |
| Perl continues to flourish into its third decade thanks to a vibrant |
| community of users and developers. The following people are known to |
| have contributed the improvements that became Perl 5.14.0: |
| |
| Aaron Crane, Abhijit Menon-Sen, Abigail, Ævar Arnfjörð Bjarmason, |
| Alastair Douglas, Alexander Alekseev, Alexander Hartmaier, Alexandr |
| Ciornii, Alex Davies, Alex Vandiver, Ali Polatel, Allen Smith, Andreas |
| König, Andrew Rodland, Andy Armstrong, Andy Dougherty, Aristotle |
| Pagaltzis, Arkturuz, Arvan, A. Sinan Unur, Ben Morrow, Bo Lindbergh, |
| Boris Ratner, Brad Gilbert, Bram, brian d foy, Brian Phillips, Casey |
| West, Charles Bailey, Chas. Owens, Chip Salzenberg, Chris 'BinGOs' |
| Williams, chromatic, Craig A. Berry, Curtis Jewell, Dagfinn Ilmari |
| Mannsåker, Dan Dascalescu, Dave Rolsky, David Caldwell, David Cantrell, |
| David Golden, David Leadbeater, David Mitchell, David Wheeler, Eric |
| Brine, Father Chrysostomos, Fingle Nark, Florian Ragwitz, Frank Wiegand, |
| Franz Fasching, Gene Sullivan, George Greer, Gerard Goossen, Gisle Aas, |
| Goro Fuji, Grant McLean, gregor herrmann, H.Merijn Brand, Hongwen Qiu, |
| Hugo van der Sanden, Ian Goodacre, James E Keenan, James Mastros, Jan |
| Dubois, Jay Hannah, Jerry D. Hedden, Jesse Vincent, Jim Cromie, Jirka |
| Hruška, John Peacock, Joshua ben Jore, Joshua Pritikin, Karl Williamson, |
| Kevin Ryde, kmx, Lars Dɪᴇᴄᴋᴏᴡ 迪拉斯, Larwan Berke, Leon Brocard, Leon |
| Timmermans, Lubomir Rintel, Lukas Mai, Maik Hentsche, Marty Pauley, |
| Marvin Humphrey, Matt Johnson, Matt S Trout, Max Maischein, Michael |
| Breen, Michael Fig, Michael G Schwern, Michael Parker, Michael Stevens, |
| Michael Witten, Mike Kelly, Moritz Lenz, Nicholas Clark, Nick Cleaton, |
| Nick Johnston, Nicolas Kaiser, Niko Tyni, Noirin Shirley, Nuno Carvalho, |
| Paul Evans, Paul Green, Paul Johnson, Paul Marquess, Peter J. Holzer, |
| Peter John Acklam, Peter Martini, Philippe Bruhat (BooK), Piotr Fusik, |
| Rafael Garcia-Suarez, Rainer Tammer, Reini Urban, Renee Baecker, Ricardo |
| Signes, Richard Möhn, Richard Soderberg, Rob Hoelz, Robin Barker, Ruslan |
| Zakirov, Salvador Fandiño, Salvador Ortiz Garcia, Shlomi Fish, Sinan |
| Unur, Sisyphus, Slaven Rezic, Steffen Müller, Steve Hay, Steven |
| Schubiger, Steve Peters, Sullivan Beck, Tatsuhiko Miyagawa, Tim Bunce, |
| Todd Rinaldo, Tom Christiansen, Tom Hukins, Tony Cook, Tye McQueen, |
| Vadim Konovalov, Vernon Lyon, Vincent Pit, Walt Mankowski, Wolfram |
| Humann, Yves Orton, Zefram, and Zsbán Ambrus. |
| |
| This is woefully incomplete as it's automatically generated from version |
| control history. In particular, it doesn't include the names of the |
| (very much appreciated) contributors who reported issues in previous |
| versions of Perl that helped make Perl 5.14.0 better. For a more complete |
| list of all of Perl's historical contributors, please see the C<AUTHORS> |
| file in the Perl 5.14.0 distribution. |
| |
| Many of the changes included in this version originated in the CPAN |
| modules included in Perl's core. We're grateful to the entire CPAN |
| community for helping Perl to flourish. |
| |
| =head1 Reporting Bugs |
| |
| If you find what you think is a bug, you might check the articles |
| recently posted to the comp.lang.perl.misc newsgroup and the Perl |
| bug database at http://rt.perl.org/perlbug/ . There may also be |
| information at http://www.perl.org/ , the Perl Home Page. |
| |
| If you believe you have an unreported bug, please run the L<perlbug> |
| program included with your release. Be sure to trim your bug down |
| to a tiny but sufficient test case. Your bug report, along with the |
| output of C<perl -V>, will be sent off to perlbug@perl.org to be |
| analysed by the Perl porting team. |
| |
| If the bug you are reporting has security implications, which make it |
| inappropriate to send to a publicly archived mailing list, then please send |
| it to perl5-security-report@perl.org. This points to a closed subscription |
| unarchived mailing list, which includes all the core committers, who are able |
| to help assess the impact of issues, figure out a resolution, and help |
| co-ordinate the release of patches to mitigate or fix the problem across all |
| platforms on which Perl is supported. Please use this address for |
| security issues in the Perl core I<only>, not for modules independently |
| distributed on CPAN. |
| |
| =head1 SEE ALSO |
| |
| The F<Changes> file for an explanation of how to view exhaustive details |
| on what changed. |
| |
| The F<INSTALL> file for how to build Perl. |
| |
| The F<README> file for general stuff. |
| |
| The F<Artistic> and F<Copying> files for copyright information. |
| |
| =cut |