From: Jesse Vincent Date: Sun, 24 Jan 2010 19:52:05 +0000 (-0800) Subject: First full pass at perl5120delta X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=3ab3a109701f5b8fdfac11b3ea273b219e23b66c;p=p5sagit%2Fp5-mst-13.2.git First full pass at perl5120delta --- diff --git a/pod/perl5120delta.pod b/pod/perl5120delta.pod index 922aa97..ef052df 100644 --- a/pod/perl5120delta.pod +++ b/pod/perl5120delta.pod @@ -2,6 +2,17 @@ perl5120delta - what is new for perl v5.12.0 +=head1 XXX - THIS DOCUMENT IS ONLY CURRENT THROUGH PERL5114 + +FIX ME BEFORE RELEASe + +OTHER ISSUES: + +UPDATED MODULE LIST NEEDS TO BE GENERATED +ORDERING NEEDS CHECKING +HEAVY COPYEDITING IS NEEDED + + =head1 DESCRIPTION This document describes differences between the 5.10.0 release and @@ -14,3 +25,2565 @@ coordinated (while 5.12.0 was still called 5.11.something). You can see the list of changes in the 5.10.1 release by reading L. +=head1 Core Enhancements + +=head2 qr overloading + +It is now possible to overload the C operator, that is, +conversion to regexp, like it was already possible to overload +conversion to boolean, string or number of objects. It is invoked when +an object appears on the right hand side of the C<=~> operator, or when +it is interpolated into a regexp. See L. + +=head2 Pluggable keywords + +Extension modules can now cleanly hook into the Perl parser to define +new kinds of keyword-headed expression and compound statement. The +syntax following the keyword is defined entirely by the extension. This +allow a completely non-Perl sublanguage to be parsed inline, with the +right ops cleanly generated. This feature is currently considered +experimental. + +See L for the mechanism. The Perl core +source distribution also includes a new module +L, which implements reverse Polish notation +arithmetic via pluggable keywords. This module is mainly used for test +purposes, and is not normally installed, but also serves as an example +of how to use the new mechanism. + +=head2 APIs for more internals + +The lowest layers of the lexer and parts of the pad system now have C +APIs available to XS extensions. These are necessary to support proper +use of pluggable keywords, but have other uses too. The new APIs are +experimental, and only cover a small proportion of what would be +necessary to take full advantage of the core's facilities in these +areas. It is intended that the Perl 5.13 development cycle will see the +addition of a full range of clean, supported interfaces. + +=head2 Overridable function lookup + +Where an extension module hooks the creation of rv2cv ops to modify the +subroutine lookup process, this now works correctly for bareword +subroutine calls. This means that prototypes on subroutines referenced +this way will be processed correctly. (Previously bareword subroutine +names were initially looked up, for parsing purposes, by an unhookable +mechanism, so extensions could only properly influence subroutine names +that appeared with an C<&> sigil.) + +=head2 Unicode version + +Perl is shipped with the latest Unicode version, 5.2, dated October 2009. See +L for details about this release +of Unicode. See L for instructions on installing and using +older versions of Unicode. + +=head2 Unicode properties + +Perl can now handle every Unicode character property. A new pod, +L, lists all available non-Unihan character properties. By +default the Unihan properties and certain others (deprecated and Unicode +internal-only ones) are not exposed. See below for more details on +these; there is also a section in the pod listing them, and why they are +not exposed. + +Perl now fully supports the Unicode compound-style of using C<=> and C<:> +in writing regular expressions: C<\p{property=value}> and +C<\p{property:value}> (both of which mean the same thing). + +Perl now fully supports the Unicode loose matching rules for text +between the braces in C<\p{...}> constructs. In addition, Perl also allows +underscores between digits of numbers. + +All the Unicode-defined synonyms for properties and property values are +now accepted. + +C, which matches a Unicode logical character, has been expanded to work +better with various Asian languages. It now is defined as an C. (See L). +Anything matched previously that made sense will continue to be matched. But +in addition: + +=over + +=item * + +C<\X> will now not break apart a C> sequence. + +=item * + +C<\X> will now match a sequence including the C and C characters. + +=item * + +C<\X> will now always match at least one character, including an initial mark. +Marks generally come after a base character, but it is possible in Unicode to +have them in isolation, and C<\X> will now handle that case, for example at the +beginning of a line or after a C. And this is the part where C<\X> +doesn't match the things that it used to that don't make sense. Formerly, for +example, you could have the nonsensical case of an accented LF. + +=item * + +C<\X> will now match a (Korean) Hangul syllable sequence, and the Thai and Lao +exception cases. + +=back + +Otherwise, this change should be transparent for the non-affected languages. + +C<\p{...}> matches using the Canonical_Combining_Class property were +completely broken in previous Perls. This is now fixed. + +In previous Perls, the Unicode C property and a +Perl extension had the same name, which led to neither matching all the +correct values (with more than 100 mistakes in one, and several thousand +in the other). The Perl extension has now been renamed to be +C (short: C). It has the same +meaning as was previously intended, namely the union of all the +non-canonical Decomposition types, with Unicode C being just one of +those. + +C<\p{Uppercase}> and C<\p{Lowercase}> have been brought into line with the +Unicode definitions. This means they each match a few more characters +than previously. + +C<\p{Cntrl}> now matches the same characters as C<\p{Control}>. This means it +no longer will match Private Use (gc=co), Surrogates (gc=cs), nor Format +(gc=cf) code points. The Format code points represent the biggest +possible problem. All but 36 of them are either officially deprecated +or strongly discouraged from being used. Of those 36, likely the most +widely used are the soft hyphen (U+00AD), and BOM, ZWSP, ZWNJ, WJ, and +similar, plus Bi-directional controls. + +C<\p{Alpha}> now matches the same characters as C<\p{Alphabetic}>. The Perl +definition included a number of things that aren't really alpha (all +marks), while omitting many that were. As a direct consequence, the +definitions of C<\p{Alnum}> and C<\p{Word}> which depend on Alpha also change. + +C<\p{Word}> also now doesn't match certain characters it wasn't supposed +to, such as fractions. + +C<\p{Print}> no longer matches the line control characters: Tab, LF, CR, +FF, VT, and NEL. This brings it in line with the documentation. + +C<\p{Decomposition_Type=Canonical}> now includes the Hangul syllables. + +The Numeric type property has been extended to include the Unihan +characters. + +There is a new Perl extension, the 'Present_In', or simply 'In', +property. This is an extension of the Unicode Age property, but +C<\p{In=5.0}> matches any code point whose usage has been determined +I Unicode version 5.0. The C<\p{Age=5.0}> only matches code points +added in I version 5.0. + +A number of properties did not have the correct values for unassigned +code points. This is now fixed. The affected properties are +Bidi_Class, East_Asian_Width, Joining_Type, Decomposition_Type, +Hangul_Syllable_Type, Numeric_Type, and Line_Break. + +The Default_Ignorable_Code_Point, ID_Continue, and ID_Start properties +have been updated to their current Unicode definitions. + +Certain properties that are supposed to be Unicode internal-only were +erroneously exposed by previous Perls. Use of these in regular +expressions will now generate, if enabled, a deprecated warning message. +The properties are: Other_Alphabetic, Other_Default_Ignorable_Code_Point, +Other_Grapheme_Extend, Other_ID_Continue, Other_ID_Start, Other_Lowercase, +Other_Math, and Other_Uppercase. + +An installation can now fairly easily change which Unicode properties +Perl understands. As mentioned above, certain properties are by default +turned off. These include all the Unihan properties (which should be +accessible via the CPAN module Unicode::Unihan) and any deprecated or +Unicode internal-only property that Perl has never exposed. + +The generated files in the C directory are now more +clearly marked as being stable, directly usable by applications. +New hash entries in them give the format of the normal entries, +which allows for easier machine parsing. Perl can generate files +in this directory for any property, though most are suppressed. An +installation can choose to change which get written. Instructions +are in L. + +=head2 Regular Expressions + +U+0FFFF is now a legal character in regular expressions. + +=head2 Unicode properties + +C<\p{XDigit}> now matches the same characters as C<\p{Hex_Digit}>. This +means that in addition to the characters it currently matches, +C<[A-Fa-f0-9]>, it will also match their fullwidth equivalent forms, for +example U+FF10: FULLWIDTH DIGIT ZERO. + +=head2 Unicode Character Database 5.1.0 + +The copy of the Unicode Character Database included in Perl 5.11.0 has +been updated to 5.1.0 from 5.0.0. See +L for the +notable changes. + +=head2 A proper interface for pluggable Method Resolution Orders + +As of Perl 5.11.0 there is a new interface for plugging and using method +resolution orders other than the default (linear depth first search). +The C3 method resolution order added in 5.10.0 has been re-implemented as +a plugin, without changing its Perl-space interface. See L for +more information. + +=head2 The C pragma + +This pragma allows you to lexically disable or enable overloading +for some or all operations. (Yuval Kogman) + +=head2 C<\N> regex escape + +A new regex escape has been added, C<\N>. It will match any character that +is not a newline, independently from the presence or absence of the single +line match modifier C. (If C<\N> is followed by an opening brace and +by a letter, perl will still assume that a Unicode character name is +coming, so compatibility is preserved.) (Rafael Garcia-Suarez) + +=head2 Implicit strictures + +Using the C syntax with a version number greater or equal +to 5.11.0 will also lexically enable strictures just like C +would do (in addition to enabling features.) So, the following: + + use 5.11.0; + +will now imply: + + use strict; + use feature ':5.11'; + +=head2 Parallel tests + +The core distribution can now run its regression tests in parallel on +Unix-like platforms. Instead of running C, set C in +your environment to the number of tests to run in parallel, and run +C. On a Bourne-like shell, this can be done as + + TEST_JOBS=3 make test_harness # Run 3 tests in parallel + +An environment variable is used, rather than parallel make itself, because +L needs to be able to schedule individual non-conflicting test +scripts itself, and there is no standard interface to C utilities to +interact with their job schedulers. + +Note that currently some test scripts may fail when run in parallel (most +notably C). If necessary run just the failing scripts +again sequentially and see if the failures go away. + +=head2 The C<...> operator + +A new operator, C<...>, nicknamed the Yada Yada operator, has been added. +It is intended to mark placeholder code, that is not yet implemented. +See L. (chromatic) + +=head2 DTrace support + +Some support for DTrace has been added. See "DTrace support" in F. + +=head2 Support for C in CPAN module metadata + +Both C and C now support the C keyword +in the F metadata file included in most recent CPAN distributions. +This allows distribution authors to specify configuration prerequisites that +must be installed before running F or F. + +See the documentation for C or C for more +on how to specify C when creating a distribution for CPAN. + +=head2 C is now more flexible + +The C function can now operate on arrays. + +=head2 Y2038 compliance + +Perl's core time-related functions are now Y2038 compliant. (With 29 +years to spare!) + +=head2 C<$,> flexibility + +The variable C<$,> may now be tied. + +=head2 // in where clauses + +// now behaves like || in when clauses + +=head2 Enabling warnings from your shell environment + +You can now set C<-W> from the C environment variable + +=head2 C + +C now allows you to locally delete a hash entry. + +=head2 New support for Abstract namespace sockets + +Abstract namespace sockets are Linux-specific socket type that live in +AF_UNIX family, slightly abusing it to be able to use arbitrary +character arrays as addresses: They start with nul byte and are not +terminated by nul byte, but with the length passed to the socket() +system call. + +=head2 Add C syntax + +This new syntax allows a module author to set the $VERSION of a namespace +when the namespace is declared with 'package'. It eliminates the need +for C and similar constructs. E.g. + + package Foo::Bar 1.23; + # $Foo::Bar::VERSION == 1.23 + +There are several advantages to this: + +=over + +=item * + +C<$VERSION> is parsed in I the same way as C + +=item * + +C<$VERSION> is set at compile time + +=item * + +Eliminates C<$VERSION = ...> and C clutter + +=item * + +As it requires VERSION to be a numeric literal or v-string +literal, it can be statically parsed by toolchain modules +without C the way MM-Eparse_version does for C<$VERSION = ...> + +=item * + +Alpha versions with underscores do not need to be quoted; static +parsing will preserve the underscore, but during compilation, Perl +will remove underscores as it does for all numeric literals + +It does not break old code with only C, but code that uses +C will need to be restricted to perl 5.11.X or newer +This is analogous to the change to C from two-args to three-args. +Users requiring the latest Perl will benefit, and perhaps N years from +now it will become standard practice when Perl 5.12 is targeted the way +that 5.6 is today. + +=back + +=head1 Incompatible Changes + +=head2 Version number formats + +Acceptable version number formats have been formalized into "strict" and +"lax" rules. C takes a strict version number. C takes a lax version number. C and the +L object constructors take lax version numbers. Providing an +invalid version will result in a fatal error. + +These formats will be documented fully in the L module in a +subsequent release of Perl 5.11. To a first approximation, a "strict" +version number is a positive decimal number (integer or decimal-fraction) +without exponentiation or else a dotted-decimal v-string with a leading 'v' +character and at least three components. A "lax" version number allows +v-strings with fewer than three components or without a leading 'v'. Under +"lax" rules, both decimal and dotted-decimal versions may have a trailing +"alpha" component separated by an underscore character after a fractional +or dotted-decimal component. + +The L module adds C and C +functions to check a scalar against these rules. + +=over + +=item * + +The boolkeys op moved to the group of hash ops. This breaks binary compatibility. + +=item * + +C<\s> C<\w> and C<\d> once again have the semantics they had in Perl 5.8.x. + +=item * + +Filehandles are blessed directly into C, as C is merely a wrapper around C. + +The previous behaviour was to bless Filehandles into L +(an empty proxy class) if it was loaded into memory and otherwise +to bless them into C. + +=back + +=head2 Unicode interpretation of \w, \d, \s, and the POSIX character classes redefined. + +Previous versions of Perl tried to map POSIX style character class definitions onto +Unicode property names so that patterns would "dwim" when matches were made against latin-1 or +unicode strings. This proved to be a mistake, breaking character class negation, causing +forward compatibility problems (as Unicode keeps updating their property definitions and adding +new characters), and other problems. + +Therefore we have now defined a new set of artificial "unicode" property names which will be +used to do unicode matching of patterns using POSIX style character classes and perl short-form +escape character classes like \w and \d. + +The key change here is that \d will no longer match every digit in the unicode standard +(there are thousands) nor will \w match every word character in the standard, instead they +will match precisely their POSIX or Perl definition. + +Those needing to match based on Unicode properties can continue to do so by using the \p{} syntax +to match whichever property they like, including the new artificial definitions. + +B This is a backwards incompatible no-warning change in behaviour. If you are upgrading +and you process large volumes of text look for POSIX and Perl style character classes and +change them to the relevent property name (by removing the word 'Posix' from the current name). + +The following table maps the POSIX character class names, the escapes and the old and new +Unicode property mappings: + + POSIX Esc Class New-Property ! Old-Property + ----------------------------------------------+------------- + alnum [0-9A-Za-z] IsPosixAlnum ! IsAlnum + alpha [A-Za-z] IsPosixAlpha ! IsAlpha + ascii [\000-\177] IsASCII = IsASCII + blank [\011 ] IsPosixBlank ! + cntrl [\0-\37\177] IsPosixCntrl ! IsCntrl + digit \d [0-9] IsPosixDigit ! IsDigit + graph [!-~] IsPosixGraph ! IsGraph + lower [a-z] IsPosixLower ! IsLower + print [ -~] IsPosixPrint ! IsPrint + punct [!-/:-@[-`{-~] IsPosixPunct ! IsPunct + space [\11-\15 ] IsPosixSpace ! IsSpace + \s [\11\12\14\15 ] IsPerlSpace ! IsSpacePerl + upper [A-Z] IsPosixUpper ! IsUpper + word \w [0-9A-Z_a-z] IsPerlWord ! IsWord + xdigit [0-9A-Fa-f] IsXDigit = IsXDigit + +If you wish to build perl with the old mapping you may do so by setting + + #define PERL_LEGACY_UNICODE_CHARCLASS_MAPPINGS 1 + +in regcomp.h, and then setting + + PERL_TEST_LEGACY_POSIX_CC + +to true your enviornment when testing. + +=head2 +@INC reorganization + +In @INC, ARCHLIB and PRIVLIB now occur after after the current version's +site_perl and vendor_perl. + +=head2 Switch statement changes + +The handling of complex expressions by the C/C switch +statement has been enhanced. These enhancements are also available in +5.10.1 and subsequent 5.10 releases. There are two new cases where C now +interprets its argument as a boolean, instead of an expression to be used +in a smart match: + +=head2 flip-flop operators + +The C<..> and C<...> flip-flop operators are now evaluated in boolean +context, following their usual semantics; see L. + +Note that, as in perl 5.10.0, C will not work to test +whether a given value is an integer between 1 and 10; you should use +C instead (note the array reference). + +However, contrary to 5.10.0, evaluating the flip-flop operators in boolean +context ensures it can now be useful in a C, notably for +implementing bistable conditions, like in: + + when (/^=begin/ .. /^=end/) { + # do something + } + +=head2 defined-or operator + +A compound expression involving the defined-or operator, as in +C, will be treated as boolean if the first +expression is boolean. (This just extends the existing rule that applies +to the regular or operator, as in C.) + +=head2 Smart match changes + +This section details more changes brought to the semantics to +the smart match operator, that naturally also modify the behaviour +of the switch statements where smart matching is implicitly used. +These changers were also made for the 5.10.1 release, and will remain in +subsequent 5.10 releases. + + +=head3 Changes to type-based dispatch + +The smart match operator C<~~> is no longer commutative. The behaviour of +a smart match now depends primarily on the type of its right hand +argument. Moreover, its semantics have been adjusted for greater +consistency or usefulness in several cases. While the general backwards +compatibility is maintained, several changes must be noted: + +=over 4 + +=item * + +Code references with an empty prototype are no longer treated specially. +They are passed an argument like the other code references (even if they +choose to ignore it). + +=item * + +C<%hash ~~ sub {}> and C<@array ~~ sub {}> now test that the subroutine +returns a true value for each key of the hash (or element of the +array), instead of passing the whole hash or array as a reference to +the subroutine. + +=item * + +Due to the commutativity breakage, code references are no longer +treated specially when appearing on the left of the C<~~> operator, +but like any vulgar scalar. + +=item * + +C is always false (since C can't be a key in a +hash). No implicit conversion to C<""> is done (as was the case in perl +5.10.0). + +=item * + +C<$scalar ~~ @array> now always distributes the smart match across the +elements of the array. It's true if one element in @array verifies +C<$scalar ~~ $element>. This is a generalization of the old behaviour +that tested whether the array contained the scalar. + +=back + +The full dispatch table for the smart match operator is given in +L. + +=head3 Smart match and overloading + +According to the rule of dispatch based on the rightmost argument type, +when an object overloading C<~~> appears on the right side of the +operator, the overload routine will always be called (with a 3rd argument +set to a true value, see L.) However, when the object will +appear on the left, the overload routine will be called only when the +rightmost argument is a simple scalar. This way distributivity of smart match +across arrays is not broken, as well as the other behaviours with complex +types (coderefs, hashes, regexes). Thus, writers of overloading routines +for smart match mostly need to worry only with comparing against a scalar, +and possibly with stringification overloading; the other common cases +will be automatically handled consistently. + +C<~~> will now refuse to work on objects that do not overload it (in order +to avoid relying on the object's underlying structure). (However, if the +object overloads the stringification or the numification operators, and +if overload fallback is active, it will be used instead, as usual.) + +=head2 Labels can't be keywords + +Labels used as targets for the C, C, C or C +statements cannot be keywords anymore. This restriction will prevent +potential confusion between the C and C syntaxes: +for example, a statement like C would jump to a label whose +name would be the return value of C, (usually 1), instead of a +label named C. Moreover, the other control flow statements +would just ignore any keyword passed to them as a label name. Since +such labels cannot be defined anymore, this kind of error will be +avoided. + +=head2 Other incompatible changes + +=over 4 + +=item * + +The semantics of C have changed slightly. +See L<"Modules and Pragmata"> for more information. + +=item * + +It is now a run-time error to use the smart match operator C<~~> +with an object that has no overload defined for it. (This way +C<~~> will not break encapsulation by matching against the +object's internal representation as a reference.) + +=item * + +The version control system used for the development of the perl +interpreter has been switched from Perforce to git. This is mainly an +internal issue that only affects people actively working on the perl core; +but it may have minor external visibility, for example in some of details +of the output of C. See L for more information. + +=item * + +The internal structure of the C directory in the perl source has +been reorganised. In general, a module C whose source was +stored under F is now located under F. Also, +nearly all dual-life modules have been moved from F to F. This +is purely a source tarball change, and should make no difference to the +compilation or installation of perl, unless you have a very customised build +process that explicitly relies on this structure, or which hard-codes the +C F parameter. Specifically, this change does not by +default alter the location of any files in the final installation. + +=item * + +As part of the C 2.x to 3.x upgrade, the experimental +C module has been removed. +See L for more details. + +=item * + +As part of the C upgrade, the +C and C modules +have been removed from this distribution. + +=item * + +C no longer contains the C<%:patchlevel> hash. + +=item * + +This one is actually a change introduced in 5.10.0, but it was missed +from that release's perldelta, so it is mentioned here instead. + +A bugfix related to the handling of the C modifier and C resulted +in a change of behaviour between 5.8.x and 5.10.0: + + # matches in 5.8.x, doesn't match in 5.10.0 + $re = qr/^bar/; "foo\nbar" =~ /$re/m; + +=item * + +C now returns undef. + +=item * + +Unsupported private C API functions are now declared "static" to prevent +leakage to Perl's public API. + +=item * + +To support the bootstrapping process, F no longer builds with +UTF-8 support in the regexp engine. + +This allows a build to complete with PERL_UNICODE set and a UTF-8 locale. +Without this there's a bootstrapping problem, as miniperl can't load the UTF-8 +components of the regexp engine, because they're not yet built. + +=item * + +F's @INC is now restricted to just -I..., the split of $ENV{PERL5LIB}, and "." + +=item * + +A space or a newline is now required after a C<"#line XXX"> directive. + +=item * + +Tied filehandles now have an additional method EOF which provides the EOF type + +=item * + +To better match all other flow control statements, C may no longer be used as an attribute. + +=back + +=head1 Deprecations + +From time to time, Perl's developers find it necessary to deprecate +features or modules we've previously shipped as part of the core +distribution. We are well aware of the pain and frustration that a +backwards-incompatible change to Perl can cause for developers building +or maintaining software in Perl. You can be sure that when we deprecate +a functionality or syntax, it isn't a choice we make lightly. Sometimes, +we choose to deprecate functionality or syntax because it was found to +be poorly designed or implemented. Sometimes, this is because they're +holding back other features or causing performance problems. Sometimes, +the reasons are more complex. Wherever possible, we try to keep deprecated +functionality available to developers in its previous form for at least +one major release. So long as a deprecated feature isn't actively +disrupting our ability to maintain and extend Perl, we'll try to leave +it in place as long as possible. + +The following items are now deprecated. + +=over 4 + +=item Use of C<:=> to mean an empty attribute list is now deprecated. + +An accident of Perl's parser meant that these constructions were all +equivalent: + + my $pi := 4; + my $pi : = 4; + my $pi : = 4; + +with the C<:> being treated as the start of an attribute list, which +ends before the C<=>. As whitespace is not significant here, all are +parsed as an empty attribute list, hence all the above are equivalent +to, and better written as + + my $pi = 4; + +because no attribute processing is done for an empty list. + +As is, this meant that C<:=> cannot be used as a new token, without +silently changing the meaning of existing code. Hence that particular +form is now deprecated, and will become a syntax error. If it is +absolutely necessary to have empty attribute lists (for example, +because of a code generator) then avoid the warning by adding a space +before the C<=>. + +=item C<< UNIVERSAL-Eimport() >> + +The method C<< UNIVERSAL-Eimport() >> is now deprecated. Attempting to +pass import arguments to a C statement will result in a +deprecation warning. (This is a less noisy version of the full deprecation +warning added in 5.11.0.) + +=item Use of "goto" to jump into a construct is deprecated + +Using C to jump from an outer scope into an inner +scope is now deprecated. This rare use case was causing +problems in the implementation of scopes. + +=item C is buggy and should be avoided. + +From perl 5.11.0 onwards, it is +intended that any use of the core version of this module will emit a +warning, and that the module will eventually be removed from the core +(probably in perl 5.14.0). See L for its +replacement. + +=item Deprecated Modules + +The following modules will be removed from the core distribution in a future +release, and should be installed from CPAN instead. Distributions on CPAN +which require these should add them to their prerequisites. The core versions +of these modules warnings will issue a deprecation warning. + +=over + +=item C + +=item C + +=item C + +=back + +=item suidperl + +C has been removed. It used to provide a mechanism to +emulate setuid permission bits on systems that don't support it properly. + +=item Assignment to $[ + +=item attrs + +Remove attrs, which has been deprecated since 1999-10-02. + +=item Use of the attribute :locked on subroutines. + +=item Use of "locked" with the attributes pragma. + +=item Use of "unique" with the attributes pragma. + +=item Numerous Perl 4-era libraries: + +F, F, F, F, F, +F, F, F, F, F, +F, F, F, F, +F, F, F, F, F, +F, F, F, F, F, +F, F, F, F, and +F are all now deprecated. Using them will incur a warning. + +=back + +=head1 Modules and Pragmata + +=head2 Dual-lifed modules moved + +Dual-lifed modules maintained primarily in the Perl core now live in dist/. +Dual-lifed modules maintained primarily on CPAN now live in cpan/ + +In previous releases of Perl, it was customary to enumerate all module +changes in this section of the C file. From 5.11.0 forward +only notable updates (such as new or deprecated modules ) will be +listed in this section. For a complete reference to the versions of +modules shipped in a given release of perl, please see L. + +=head2 New Modules and Pragmata + +=over 4 + +=item * + +C + +This is a new lexically-scoped alternative for the C module. +The bundled version is 2.06_01. Note that in this release, using a string +eval when C is in effect can cause the autodie behaviour to leak +into the surrounding scope. See L for more details. + +=item * + +C + +This has been added to the core (version 2.020). + +=item * + +C + +This pragma establishes an ISA relationship with base classes at compile +time. It provides the key feature of C without the feature creep. + +=item * + +C + +This has been added to the core (version 1.39). + +=back + +=head2 Pragmata Changes + +=over 4 + +=item * + +C + +See L pragma"> above. + +=item * + +C + +The C pragma has been removed. It had been marked as deprecated since +5.6.0. + +=item * + +C + +The Unicode F database file has been added. This has the +effect of adding some extra C<\N> character names that formerly wouldn't +have been recognised; for example, C<"\N{LATIN CAPITAL LETTER GHA}">. + +=item * + +C + +The meaning of the C<:5.10> and C<:5.10.X> feature bundles has +changed slightly. The last component, if any (i.e. C) is simply ignored. +This is predicated on the assumption that new features will not, in +general, be added to maintenance releases. So C<:5.10> and C<:5.10.X> +have identical effect. This is a change to the behaviour documented for +5.10.0. + +=item * + +C + +Upgraded from version 1.00 to 1.01. Performance for single inheritance is 40% +faster - see L below. + +C is now implemented as an XS extension. The documented interface has not +changed. Code relying on the implementation detail that some C +methods happened to be available at all times gets to "keep both pieces". + +=item * + +C + +Supports %.0f formatting internally. + +=item * + +C + +Allow overloading of 'qr'. + +=item * + +C + +Upgraded from version 1.19 to 1.20. + +=item * + +C + +This pragma no longer suppresses C warnings. [perl #71204] + +=item * + +C + +Upgraded from 1.13 to 1.14. Added the C feature: + + use feature "unicode_strings"; + +This pragma turns on Unicode semantics for the case-changing operations +(uc/lc/ucfirst/lcfirst) on strings that don't have the internal UTF-8 flag set, +but that contain single-byte characters between 128 and 255. + +=item * + +C + +Upgraded from version 1.74 to 1.75. + +=item * + +C + +Upgraded from version 0.03 to 0.03. + +This version introduces the C method to allow subclasses of less to +pick where in %^H to store their stash. + +=item * + +C + +Upgraded from version 0.77 to 0.81. + +This version adds support for L as described earlier +in this document and in its own documentation. + +=item * + +C + +Upgraded from 1.07 to 1.09. + +Added new C function. +This version adds the C warning category. See also L for this change. + +=back + + +=head2 Updated Modules + +=over 4 + +=item XXX TODO RECALCULATE THIS VS 5.10.0 + +=back + +=head2 Removed Modules and Pragmata + +=over 4 + +=item * + +C + +Removed from the Perl core. Prior version was 'undef'. + +=back + +=head1 Documentation + +=head2 New Documentation + +=over 4 + +=item * + +L + +This contains instructions on how to build perl for the Haiku platform. + +=item * + +L + +This describes the new interface for pluggable Method Resolution Orders. + +=item * + +L + +This document, by Richard Foley, provides an introduction to the use of +performance and optimization techniques which can be used with particular +reference to perl programs. + +=item * + +L + +This describes how to access the perl source using the I version +control system. + +=item * + +L extends the "Social contract about contributed modules" into +the beginnings of a document on Perl porting policies. + +=back + +=head2 Changes to Existing Documentation + +The various large F files (which listed every change made to perl +over the last 18 years) have been removed, and replaced by a small file, +also called F, which just explains how that same information may +be extracted from the git version control system. + +The file F has been deleted, as it mainly described +interacting with the old Perforce-based repository, which is now obsolete. +Information still relevant has been moved to L. + +L, L, L and L are now all +generated at build time, rather than being shipped as part of the release. + +=over + +=item * + +Documented -X overloading. + +=item * + +Documented that C treats specially most of the filetest operators + +=item * + +Documented when as a syntax modifier + +=item * + +Eliminated "Old Perl threads tutorial", which describes 5005 threads. + +F is the same material reworked for ithreads. + +=item * + +Correct previous documentation: v-strings are not deprecated + +With version objects, we need them to use MODULE VERSION syntax. This +patch removes the deprecation note. + +=item * + +Added security contact information to L + +A significant fraction of the core documentation has been updated to clarify +the behavior of Perl's Unicode handling. + +Much of the remaining core documentation has been reviewed and edited +for clarity, consistent use of language, and to fix the spelling of Tom +Christiansen's name. + +The Pod specification (L) has been updated to bring the +specification in line with modern usage already supported by most Pod systems. +A parameter string may now follow the format name in a "begin/end" region. +Links to URIs with a text description are now allowed. The usage of +C"section"E> has been marked as deprecated. + +L has been documented in L as a means to get +conditional loading of modules despite the implicit BEGIN block around C. + +=item * + +Documentation for C<$1> in perlvar.pod clarified + +=back + +=head1 Performance Enhancements + +=over 4 + +=item * + +A new internal cache means that C will often be faster. + +=item * + +The implementation of C Method Resolution Order has been optimised - +linearisation for classes with single inheritance is 40% faster. Performance +for multiple inheritance is unchanged. + +=item * + +Under C, the locale-relevant information is now cached on +read-only values, such as the list returned by C. This makes +operations such as C in the scope of C much +faster. + +=item * + +Empty C methods are no longer called. + +=item * + +Faster C + +=item * + +Speed up C on empty hash + +=item * + +C has been optimized to be faster than C + +=item * + +Reversing an array to itself (as in C<@a = reverse @a>) in void context +now happens in-place and is several orders of magnitude faster than it +used to be. It will also preserve non-existent elements whenever +possible, i.e. for non magical arrays or tied arrays with C and +C methods. + +=back + +=head1 Installation and Configuration Improvements + +=head2 F reorganisation + +The layout of directories in F has been revised. Specifically, all +extensions are now flat, and at the top level, with C in pathnames +replaced by C<->, so that F is now F, +etc. The names of the extensions as specified to F, and as +reported by C<%Config::Config> under the keys C, +C, C and C have not changed, and +still use C. Hence this change will not have any affect once perl is +installed. C has been split out from being part of C, and +C is now an extension in its own right. + +Nearly all dual-life modules have been moved from F to F, and will +now appear as known C. This will made no difference to the +structure of an installed perl, nor will the modules installed differ, +unless you run F with options to specify an exact list of +extensions to build. In this case, you will rapidly become aware that you +need to add to your list, because various modules needed to complete the +build, such as C, have now become extensions, and +without them the build will fail well before it attempts to run the +regression tests. + +=head2 Configuration improvements + +If C and C are the same, then they are only added to +C<@INC> once. + +C<$Config{usedevel}> and the C-level C are now defined if +perl is built with C<-Dusedevel>. + +F will enable use of C<-fstack-protector>, to provide protection +against stack-smashing attacks, if the compiler supports it. + +F will now determine the correct prototypes for re-entrant +functions, and for C, if you are using a C++ compiler rather +than a C compiler. + +On Unix, if you build from a tree containing a git repository, the +configuration process will note the commit hash you have checked out, for +display in the output of C and C. Unpushed local commits +are automatically added to the list of local patches displayed by +C. + +USE_ATTRIBUTES_FOR_PERLIO is now reported in the compile-time options +listed by the C<-V> switch. + +=head2 Compilation improvements + +As part of the flattening of F, all extensions on all platforms are +built by F. This replaces the Unix-specific +F, VMS-specific F and Win32-specific +F. + + +=head1 Changed Internals + +=over 4 + +=item * + +C has been removed from the public API. Calling it now +generates a deprecation warning, and it will be removed in a future +release. Although listed as part of the API, it was never documented, +and only ever used in F, and prior to 5.10, F. In +core, it has been replaced by a static function. + +=item * + +Perl_magic_setmglob now knows about globs, fixing RT #71254. + +=item * + +TODO: C is gone. RVs are now stored in IVs + +=item * + +TODO: REGEXPs are first class + +=item * + +TODO: OOK is reworked, such that an OOKed scalar is PV not PVIV + +=item * + +The J.R.R. Tolkien quotes at the head of C source file have been checked and +proper citations added, thanks to a patch from Tom Christiansen. + +=item * + +C now accepts a null first argument. In addition, a full audit +was made of the "not NULL" compiler annotations, and those for several +other internal functions were corrected. + +=item * + +New macros C, C, C, C +have been added to formalise the temporary saving of the C +variable. + +=item * + +The function C has been added to augment +C. + +=item * + +The function C has been added, equivalent to +C followed by C. + +=item * + +The function C has been added, equivalent to +C and then performing the action relevant to the flag. + +Two flag bits are currently supported. + +=over 4 + +=item * + +C + +This will call C for you. (Note that this does not convert an +sequence of ISO 8859-1 characters to UTF-8). A wrapper, C +is available for this. + +=item * + +C + +Call C on the new SV. + +=back + +There is also a wrapper that takes constant strings, C. + +=item * + +The function C has been added as a wrapper to +C. + +=item * + +The functions C and C are now +exported. + +=item * + +C has been exterminated from the core code, replaced by local STRLEN +temporaries, or C<*_nolen()> calls. Either approach is faster than C, +which is a pointer deference into the interpreter structure under ithreads, +and a global variable otherwise. + +=item * + +C used to leave freed memory accessible via C on +the scalar. It now updates the linked list to remove each piece of magic +as it is freed. + +=item * + +Under ithreads, the regex in C is now reference counted. This +eliminates a lot of hackish workarounds to cope with it not being reference +counted. + +=item * + +C would sometimes incorrectly turn on C. +This has been fixed. + +=item * + +The I IV and NV flags are now not set if the string value has +trailing "garbage". This behaviour is consistent with not setting the +public IV or NV flags if the value is out of range for the type. + +=item * + +SV allocation tracing has been added to the diagnostics enabled by C<-Dm>. +The tracing can alternatively output via the C mechanism, if +that was enabled when the F binary was compiled. + +=item * + +Smartmatch resolution tracing has been added as a new diagnostic. Use C<-DM> to +enable it. + +=item * + +A new debugging flag C<-DB> now dumps subroutine definitions, leaving +C<-Dx> for its original purpose of dumping syntax trees. + +=item * + +Uses of C, C, C, C, C etc have been +replaced by C in the core code, and non-dual-life modules, as C +is clearer to those unfamiliar with the core code. + +=item * + +A macro C has been added, which on (non-pedantic) gcc will +not cast away C, returning a C. Macros C, +C etc build on this, casting to C etc without +casting away C. This allows proper compile-time auditing of +C correctness in the core, and helped picked up some errors (now +fixed). + +=item * + +Macros C and C have been added, for pushing SVs on the +stack and mortalizing them. + +=item * + +Use of the private structure C has changed slightly. Nothing +outside the core should be accessing this directly anyway. + +=item * + +A new tool, F has been added, that allows you +to view how a C preprocessor macro would be expanded when compiled. +This is handy when trying to decode the macro hell that is the perl +guts. + +=back + +=head1 Testing + +=head2 New Tests + +Many modules updated from CPAN incorporate new tests. +Several tests that have the potential to hang forever if they fail now +incorporate a "watchdog" functionality that will kill them after a timeout, +which helps ensure that C and C run to +completion automatically. (Jerry Hedden). + +Some core-specific tests have been added: + +=over 4 + +=item * + +Significant cleanups to core tests to ensure that language and +interpreter features are not used before they're tested. + +=item * + +C now runs a number of important pre-commit checks which might be of use to anyone working on the Perl core. + +=item * + +F automatically checks the well-formedness of +POD found in all .pl, .pm and .pod files in the F, other than in +dual-lifed modules which are primarily maintained outside the Perl core. + +=item * + +F now tests that all files listed in MANIFEST are present. + +=item * + +F + +Test that a bare readdir in while loop sets $_. + +=item * + +t/comp/retainedlines.t + +Check that the debugger can retain source lines from C. + +=item * + +t/io/perlio_fail.t + +Check that bad layers fail. + +=item * + +t/io/perlio_leaks.t + +Check that PerlIO layers are not leaking. + +=item * + +t/io/perlio_open.t + +Check that certain special forms of open work. + +=item * + +t/io/perlio.t + +General PerlIO tests. + +=item * + +t/io/pvbm.t + +Check that there is no unexpected interaction between the internal types +C and C. + +=item * + +t/mro/package_aliases.t + +Check that mro works properly in the presence of aliased packages. + +=item * + +t/op/dbm.t + +Tests for C and C. + +=item * + +t/op/index_thr.t + +Tests for the interaction of C and threads. + +=item * + +t/op/pat_thr.t + +Tests for the interaction of esoteric patterns and threads. + +=item * + +t/op/qr_gc.t + +Test that C doesn't leak. + +=item * + +t/op/reg_email_thr.t + +Tests for the interaction of regex recursion and threads. + +=item * + +t/op/regexp_qr_embed_thr.t + +Tests for the interaction of patterns with embedded C and threads. + +=item * + +t/op/regexp_unicode_prop.t + +Tests for Unicode properties in regular expressions. + +=item * + +t/op/regexp_unicode_prop_thr.t + +Tests for the interaction of Unicode properties and threads. + +=item * + +t/op/reg_nc_tie.t + +Test the tied methods of C. + +=item * + +t/op/reg_posixcc.t + +Check that POSIX character classes behave consistently. + +=item * + +t/op/re.t + +Check that exportable C functions in F work. + +=item * + +t/op/setpgrpstack.t + +Check that C works. + +=item * + +t/op/substr_thr.t + +Tests for the interaction of C and threads. + +=item * + +t/op/upgrade.t + +Check that upgrading and assigning scalars works. + +=item * + +t/uni/lex_utf8.t + +Check that Unicode in the lexer works. + +=item * + +t/uni/tie.t + +Check that Unicode and C work. + +=item * + +t/comp/final_line_num.t + +See if line numbers are correct at EOF + +=item * + +t/comp/form_scope.t + +See if format scoping works + +=item * + +t/comp/line_debug.t + +See if @{"_<$file"} works + +=item * + +t/op/filetest_t.t + +See if -t file test works + +=item * + +t/op/qr.t + +See if qr works + +=item * + +t/op/utf8cache.t + +Tests malfunctions of utf8 cache + +=item * + +t/re/uniprops.t + +Test unicode \p{} regex constructs + +=back + +=head2 Testing improvements + +=over 4 + +=item * + +It's now possible to override C and friends in F + +=back + + +=head1 New or Changed Diagnostics + +Several new diagnostics, see L for details. + +=over 4 + +=item * + +C + +=item * + +C + +=item * + +C + +=item * + +C + +=item * + +C + +=item * + +C + +=item * + +C + +=item * + +C + +=item * + +New warning category C + +The two warnings : + + Illegal character in prototype for %s : %s + Prototype after '%c' for %s : %s + +have been moved from the C top-level warnings category into a new +first-level category, C. These two warnings are currently the +only ones emitted during parsing of an invalid/illegal prototype, so one +can now do + + no warnings 'illegalproto'; + +to suppress only those, but not other syntax-related warnings. Warnings where +prototypes are changed, ignored, or not met are still in the C +category as before. (Matt S. Trout) + +=item * + +lvalue attribute ignored after the subroutine has been defined + +This new warning is issued when one attempts to mark a subroutine as +lvalue after it has been defined. + +=item * + +warn if ++ or -- are unable to change the value because it's beyond the limit of representation + +This uses a new warnings category: "imprecision". + +=item * +lc/uc/lcfirst/ucfirst warn when passed undef. + +=item * + +Show constant in "Useless use of a constant in void context" + +=item * + +Make the new warning report undef constants as undef + +=item * + +Add a new warning, "Prototype after '%s'" + +=item * + +Tweak the "Illegal character in prototype" warning so it's more precise when reporting illegal characters after _ + +=item * + +Unintended interpolation of $\ in regex + +=item * + +Make overflow warnings in gmtime/localtime only occur when warnings are on + +=item * + +Improve mro merging error messages. + +They are now very similar to those produced by Algorithm::C3. + +=item * + +Amelioration of the error message "Unrecognized character %s in column %d" + +Changes the error message to "Unrecognized character %s; marked by E-- +HERE after %sE-- HERE near column %d". This should make it a little +simpler to spot and correct the suspicious character. + +=item * + +Explicitely point to $. when it causes an uninitialized warning for ranges in scalar context + +=back + +One diagnostic has been removed: + +=over 4 + +=item * + +C + +C now warns when called in void context + +=item * + +C-style functions called with too few arguments will now issue the +warning C<"Missing argument in %s"> [perl #71000] + +=item * + +C + +This new fatal error occurs when the C routine C was +passed a position that is not within the scalar's string buffer. This +could be caused by buggy XS code, and at this point recovery is not +possible. + +=item * + +C + +This warning has been removed. In general, it only got produced in +conjunction with other warnings, and removing it allowed an ISA lookup +optimisation to be added. + +=item * + +C + +This warning has been removed. + +=item * + +C + +It is now possible to change the depth threshold for this warning from the +default of 100, by recompiling the F binary, setting the C +pre-processor macro C to the desired value. + +=item * + +Perl now properly returns a syntax error instead of segfaulting +if C, C or C is used without an argument + +=item * + +C now fails properly if called without an argument and when no previous file was read + +C now returns C<-1>, and sets errno to C, thus restoring the 5.8.x behaviour + +=item * + +overload no longer implicitly unsets fallback on repeated 'use overload' lines + +=item * + +POSIX::strftime() can now handle Unicode characters in the format string. + +=item * + +The Windows select() implementation now supports all empty Cs more correctly. + +=item * + +The 'syntax' category was removed from 5 warnings that should only be in 'deprecated'. + +=item * + +Three fatal pack/unpack error messages have been normalized to "panic: %s" + +=item * + +"Unicode character is illegal" has been rephrased to be more accurate + +It now reads C and the +perldiag documentation has been expanded a bit. + +=item * + +Perl now defaults to issuing a warning if a deprecated language feature is used. + +To disable this feature in a given lexical scope, you should use C For information about which language features +are deprecated and explanations of various deprecation warnings, please +see L + +=back + +=head1 Utility Changes + +=over 4 + +=item * + +F + +Now looks in C too, which is a recent addition to gcc's +search path. + +=item * + +F + +No longer incorrectly treats enum values like macros (Daniel Burr). + +Now handles C++ style constants (C) properly in enums. (A patch from +Rainer Weikusat was used; Daniel Burr also proposed a similar fix). + +=item * + +F + +C subroutines now work under the debugger. + +The debugger now correctly handles proxy constant subroutines, and +subroutine stubs. + +=item * + +F + +F now uses C<%Module::CoreList::bug_tracker> to print out upstream bug +tracker URLs. + +Where the user names a module that their bug report is about, and we know the +URL for its upstream bug tracker, provide a message to the user explaining +that the core copies the CPAN version directly, and provide the URL for +reporting the bug directly to upstream. + +=item * + +F + +Perl 5.11.0 added a new utility F, which is a variant of +F, but for sending non-bug-reports to the authors and maintainers +of Perl. Getting nothing but bug reports can become a bit demoralising: +we'll see if this changes things. + +=item * + +F + +No longer reports "Message sent" when it hasn't actually sent the message + +=item * + +F + +Fixed bugs with the match() operator in list context, remove mention of +$[. + +=back + +=head1 Selected Bug Fixes + +=over 4 + +=item * + +Ensure that pp_qr returns a new regexp SV each time. Resolves RT #69852. + +Instead of returning a(nother) reference to the (pre-compiled) regexp in the +optree, use reg_temp_copy() to create a copy of it, and return a reference to +that. This resolves issues about Regexp::DESTROY not being called in a timely +fashion (the original bug tracked by RT #69852), as well as bugs related to +blessing regexps, and of assigning to regexps, as described in correspondence +added to the ticket. + +It transpires that we also need to undo the SvPVX() sharing when ithreads +cloning a Regexp SV, because mother_re is set to NULL, instead of a cloned +copy of the mother_re. This change might fix bugs with regexps and threads in +certain other situations, but as yet neither tests nor bug reports have +indicated any problems, so it might not actually be an edge case that it's +possible to reach. + +=item * + + * + +Several compilation errors and segfaults when perl was built with C<-Dmad> were fixed. + +=item * + +Fixes for lexer API changes in 5.11.2 which broke NYTProf's savesrc option. + +=item * + +F<-t> should only return TRUE for file handles connected to a TTY + +The Microsoft C version of isatty() returns TRUE for all +character mode devices, including the /dev/null style "nul" +device and printers like "lpt1". + +=item * + +Fixed a regression caused by commit fafafbaf which caused a panic during +parameter passing [perl #70171] + +=item * + +On systems which in-place edits without backup files, -i'*' now works as +the documentation says it does [perl #70802] + +=item * + +Saving and restoring magic flags no longer loses readonly flag. + +=item * + +The malformed syntax C (note the missing comma) no longer +causes abrupt and total failure. + +=item * + +Regular expressions compiled with C literals properly set C<$'> when +matching again. + +=item * + +Using named subroutines with C should no longer lead to bus errors [perl +#71076] + +=item * + +Numerous bugfixes catch small issues caused by the recently-added Lexer API. + +=item * + +Smart match against C<@_> sometimes gave false negatives. [perl #71078] + +=item * + +C<$@> may now be assigned a read-only value (without error or busting the stack). + +=item * + +C called recursively from within an active comparison subroutine no +longer causes a bus error if run multiple times. [perl #71076] + +=item * + +Tie::Hash::NamedCapture::* shouldn't abort if passed bad input (RT #71828) + +=item * + +@_ and $_ no longer leak under threads (RT #34342 and #41138, also +#70602, #70974) + +=item * + +C<-I> on shebang line now adds directories in front of @INC +as documented, and as does C<-I> when specified on the command-line. + +=item * + +C is now fatal when called on non-numeric process identifiers. +Previously, an 'undef' process identifier would be interpreted as a request to +kill process "0", which would terminate the current process group on POSIX +systems. Since process identifiers are always integers, killing a non-numeric +process is now fatal. + +=item * + +5.10.0 inadvertently disabled an optimisation, which caused a measurable +performance drop in list assignment, such as is often used to assign +function parameters from C<@_>. The optimisation has been re-instated, and +the performance regression fixed. + +=item * + +Fixed memory leak on C [RT #53038]. + +=item * + +Some potential coredumps in PerlIO fixed [RT #57322,54828]. + +=item * + +The debugger now works with lvalue subroutines. + +=item * + +The debugger's C command was broken on modules that defined constants +[RT #61222]. + +=item * + +C and string complement could return tainted values for untainted +arguments [RT #59998]. + +=item * + +The C<-i>I<.suffix> command-line switch now recreates the file using +restricted permissions, before changing its mode to match the original +file. This eliminates a potential race condition [RT #60904]. + +=item * + +On some Unix systems, the value in C<$?> would not have the top bit set +(C<$? & 128>) even if the child core dumped. + +=item * + +Under some circumstances, C<$^R> could incorrectly become undefined +[RT #57042]. + +=item * + +In the XS API, various hash functions, when passed a pre-computed hash where +the key is UTF-8, might result in an incorrect lookup. + +=item * + +XS code including F before F gave a compile-time error +[RT #57176]. + +=item * + +C<< $object-Eisa('Foo') >> would report false if the package C didn't +exist, even if the object's C<@ISA> contained C. + +=item * + +Various bugs in the new-to 5.10.0 mro code, triggered by manipulating +C<@ISA>, have been found and fixed. + +=item * + +Bitwise operations on references could crash the interpreter, e.g. +C<$x=\$y; $x |= "foo"> [RT #54956]. + +=item * + +Patterns including alternation might be sensitive to the internal UTF-8 +representation, e.g. + + my $byte = chr(192); + my $utf8 = chr(192); utf8::upgrade($utf8); + $utf8 =~ /$byte|X}/i; # failed in 5.10.0 + +=item * + +Within UTF8-encoded Perl source files (i.e. where C is in +effect), double-quoted literal strings could be corrupted where a C<\xNN>, +C<\0NNN> or C<\N{}> is followed by a literal character with ordinal value +greater than 255 [RT #59908]. + +=item * + +C failed to correctly deparse various constructs: +C [RT #62428], C [RT #62488], +C [RT #62484]. + +=item * + +Using C with no arguments could corrupt the perl stack. + +=item * + +The block form of C is now specifically trappable by C and +C. Previously it was erroneously treated like string C. + +=item * + +In 5.10.0, the two characters C<[~> were sometimes parsed as the smart +match operator (C<~~>) [RT #63854]. + +=item * + +In 5.10.0, the C<*> quantifier in patterns was sometimes treated as +C<{0,32767}> [RT #60034, #60464]. For example, this match would fail: + + ("ab" x 32768) =~ /^(ab)*$/ + +=item * + +C was limited to a 32 bit segment size on a 64 bit OS [RT #63924]. + +=item * + +Using C or C to exit a C block no longer produces a +spurious warning like the following: + + Exiting given via last at foo.pl line 123 + +=item * + +On Windows, C<'.\foo'> and C<'..\foo'> were treated differently than +C<'./foo'> and C<'../foo'> by C and C [RT #63492]. + +=item * + +Assigning a format to a glob could corrupt the format; e.g.: + + *bar=*foo{FORMAT}; # foo format now bad + +=item * + +Attempting to coerce a typeglob to a string or number could cause an +assertion failure. The correct error message is now generated, +C>. + +=item * + +Under C, C<-x> was using the wrong access mode. This +has been fixed [RT #49003]. + +=item * + +C on a tied scalar that returned a Unicode value would not be +correct the first time. This has been fixed. + +=item * + +Using an array C inside in array C could SEGV. This has been +fixed. [RT #51636] + +=item * + +A race condition inside C has been identified and +fixed. This used to cause various threading issues, including SEGVs. + +=item * + +In C, the use of C<()> groups in scalar context was internally +placing a list on the interpreter's stack, which manifested in various +ways, including SEGVs. This is now fixed [RT #50256]. + +=item * + +Magic was called twice in C, C<\&$x>, C and C. +These have all been fixed. + +=item * + +A 5.10.0 optimisation to clear the temporary stack within the implicit +loop of C has been reverted, as it turned out to be the cause of +obscure bugs in seemingly unrelated parts of the interpreter [commit +ef0d4e17921ee3de]. + +=item * + +The line numbers for warnings inside C are now correct. + +=item * + +The C<..> operator now works correctly with ranges whose ends are at or +close to the values of the smallest and largest integers. + +=item * + +C could lead to segmentation faults on some platforms. +This has been fixed [RT #54828]. + +=item * + +An off-by-one error meant that C was effectively being +executed as C. This has been fixed [RT #53746]. + +=item * + +Various leaks associated with named captures in regexes have been fixed +[RT #57024]. + +=item * + +A weak reference to a hash would leak. This was affecting C +[RT #56908]. + +=item * + +Using (?|) in a regex could cause a segfault [RT #59734]. + +=item * + +Use of a UTF-8 C within a closure could cause a segfault [RT #61520]. + +=item * + +Calling C or otherwise upgrading an SV could result in an +unaligned 64-bit access on the SPARC architecture [RT #60574]. + +=item * + +In the 5.10.0 release, C would incorrectly list +C<5.10.*> after C<5.8.*>; this affected the C<@INC> search order +[RT #67628]. + +=item * + +In 5.10.0, C returned a non-tainted value +[RT #52552]. + +=item * + +In 5.10.0, C and C could produce the fatal error +C when printing UTF-8 strings +[RT #62666]. + +=item * + +In the 5.10.0 release, a dynamically created C method might be +missed (method cache issue) [RT #60220,60232]. + +=item * + +In the 5.10.0 release, a combination of C and C could +cause a memory leak [RT #63110]. + +=item * + +C<-C> on the shebang (C<#!>) line is once more permitted if it is also +specified on the command line. C<-C> on the shebang line used to be a +silent no-op I it was not also on the command line, so perl 5.10.0 +disallowed it, which broke some scripts. Now perl checks whether it is +also on the command line and only dies if it is not [RT #67880]. + +=item * + +In 5.10.0, certain types of re-entrant regular expression could crash, +or cause the following assertion failure [RT #60508]: + + Assertion rx->sublen >= (s - rx->subbeg) + i failed + +=item * + +Previously missing files from Unicode 5.1 Character Database are now included. + +=item * + +C is now honored when opening an anonymous temporary file + +=back + +=head1 Platform Specific Changes + +=head2 New Platforms + +=over + +=item Haiku + +Patches from the Haiku maintainers have been merged in. Perl should now +build on Haiku. + +=item MirOS BSD + +Perl should now build on MirOS BSD. + + +=back + +=head2 Discontinued Platforms + +=over + +=item DomainOS + +Support for Apollo DomainOS was removed in Perl 5.11.0 + +=item MachTen + +Support for Tenon Intersystems MachTen Unix layer for MacOS Classic was +removed in Perl 5.11.0 + +=item MiNT + +Support for Atari MiNT was removed in Perl 5.11.0. + +=back + +=head2 Updated Platforms + +=over 4 + +=item Darwin (Mac OS X) + +=over 4 + +=item * + +Skip testing the be_BY.CP1131 locale on Darwin 10 (Mac OS X 10.6), +as it's still buggy. + +=item * + +Correct infelicities in the regexp used to identify buggy locales +on Darwin 8 and 9 (Mac OS X 10.4 and 10.5, respectively). + +=back + +=item DragonFly BSD + +=over 4 + +=item * + +Fix thread library selection [perl #69686] + +=back + +=item Win32 + +=over 4 + +=item * + +Initial support for mingw64 is now available + +=item * + +Various bits of Perl's build infrastructure are no longer converted to win32 line endings at release time. If this hurts you, please speak up. + +=item * + +Always add a manifest resource to C to specify the C +settings for Windows Vista and later. Without this setting Windows +will treat C as a legacy application and apply various +heuristics like redirecting access to protected file system areas +(like the "Program Files" folder) to the users "VirtualStore" +instead of generating a proper "permission denied" error. + +For VC8 and VC9 this manifest setting is automatically generated by +the compiler/linker (together with the binding information for their +respective runtime libraries); for all other compilers we need to +embed the manifest resource explicitly in the external resource file. + +This change also requests the Microsoft Common-Controls version 6.0 +(themed controls introduced in Windows XP) via the dependency list +in the assembly manifest. For VC8 and VC9 this is specified using the +C linker commandline option instead. + +=item * + +Improved message window handling means that C and C messages +will no longer be dropped under race conditions. + +=back + +=item cygwin + +=over 4 + +=item * + +Enable IPv6 support on cygwin 1.7 and newer + +=back + +=item OpenVMS + +=over 4 + +=item * + +Make -UDEBUGGING the default on VMS for 5.12.0. + +Like it has been everywhere else for ages and ages. Also make +command-line selection of -UDEBUGGING and -DDEBUGGING work in +configure.com; before the only way to turn it off was by saying +no in answer to the interactive question. + +=item * + +The default pipe buffer size on VMS has been updated to 8192 on 64-bit +systems. + +=item * + +Reads from the in-memory temporary files of C used to fail +if C<$/> was set to a numeric reference (to indicate record-style reads). +This is now fixed. + +=item * + +VMS now supports C. + +=item * + +Many improvements and cleanups have been made to the VMS file name handling +and conversion code. + +=item * + +Enabling the C logical name now encodes a POSIX exit +status in a VMS condition value for better interaction with GNV's bash +shell and other utilities that depend on POSIX exit values. See +L for details. + +=item * + +C now detects Unix compatibility mode on VMS. + +=back + +=item AIX + +Removed F for AIX 5L and 6.1. Only C was used from F. + +Removed F for AIX 5L and 6.1. The F is delivered as an +optional package with the AIX Toolbox. Unfortunately the 64 bit version +is broken. + +Hints changes mean that AIX 4.2 should work again. + +=item Cygwin + +On Cygwin we now strip the last number from the DLL. This has been the +behaviour in the cygwin.com build for years. The hints files have been +updated. + + +=item FreeBSD + +The hints files now identify the correct threading libraries on FreeBSD 7 +and later. + +=item Irix + +We now work around a bizarre preprocessor bug in the Irix 6.5 compiler: +C unfortunately goes into K&R mode, but C doesn't. + +=item NetBSD + +Hints now supports versions 5.*. + +=item Stratus VOS + +Various changes from Stratus have been merged in. + +=item Symbian + +There is now support for Symbian S60 3.2 SDK and S60 5.0 SDK. + +=back + +=head1 Known Problems + +This is a list of some significant unfixed bugs, which are regressions +from either 5.10.0 or 5.8.x. + +=over 4 + +=item * + +C misbehaves in the presence of a lexical C<$_> +(typically introduced by C or implicitly by C). The variable +which gets set for each iteration is the package variable C<$_>, not the +lexical C<$_> [RT #67694]. + +A similar issue may occur in other modules that provide functions which +take a block as their first argument, like + + foo { ... $_ ...} list + +=item * + +The C pragma may generate a run-time error when a regex is +interpolated [RT #56444]: + + use charnames ':full'; + my $r1 = qr/\N{THAI CHARACTER SARA I}/; + "foo" =~ $r1; # okay + "foo" =~ /$r1+/; # runtime error + +A workaround is to generate the character outside of the regex: + + my $a = "\N{THAI CHARACTER SARA I}"; + my $r1 = qr/$a/; + +=item * + +Some regexes may run much more slowly when run in a child thread compared +with the thread the pattern was compiled into [RT #55600]. + +=item * + +Perl 5.11.4 is a development release leading up to Perl 5.12.0. +Some notable known problems found in 5.11.4 are listed as dependencies +of RT #69710, the Perl 5 version 12 meta-ticket. + +=item * + +Untriaged test crashes on Windows 2000 + +Several porters have reported mysterious crashes when Perl's entire test suite is run after a build on certain Windows 2000 systems. When run by hand, the individual tests reportedly work fine. + +=item * + +Known test failures on VMS + +Perl 5.11.1 fails a small set of core and CPAN tests as of this release. +With luck, that'll be sorted out for 5.11.2 + +=item * + +Known test failures on VMS + +Perl 5.11.2 fails a small set of core and CPAN tests as of this +release. With luck, that'll be sorted out for 5.11.3. + +=back + +=head1 Acknowledgements + +Perl 5.12.0 represents approximately two years of development since +Perl 5.10.0 and contains __ lines of changes across ___ files +from __ authors and committers: + +XXX TODO LIST + +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 L. There may also be +information at L, the Perl Home Page. + +If you believe you have an unreported bug, please run the B +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, will be sent off to perlbug@perl.org to be +analyzed 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 be 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 only use this address for +security issues in the Perl core, not for modules independently +distributed on CPAN. + +=head1 SEE ALSO + +The F file for an explanation of how to view exhaustive details +on what changed. + +The F file for how to build Perl. + +The F file for general stuff. + +The F and F files for copyright information. + +=cut