In perl.git, the branch rjbs/perldelta has been updated <http://perl5.git.perl.org/perl.git/commitdiff/854d109c16e4a94f23c420ba8bc726d7bf50cdf4?hp=2cc7a9de9a35af7974207265a04e4329606c9395>
- Log ----------------------------------------------------------------- commit 854d109c16e4a94f23c420ba8bc726d7bf50cdf4 Author: Ricardo Signes <[email protected]> Date: Sun Apr 26 18:24:56 2015 -0400 perldelta: import changes from perl52111delta M Porting/perl5220delta.pod commit e15cf5405e31ab58421ec473d0fb722cedca416e Author: Ricardo Signes <[email protected]> Date: Sun Apr 26 18:21:47 2015 -0400 perldelta: import changes from perl52110delta M Porting/perl5220delta.pod commit b376ac77ca06d3934473706939bea9fbb35b7479 Author: Ricardo Signes <[email protected]> Date: Sun Apr 26 18:12:35 2015 -0400 perldelta group core enhancements by topic area M Porting/perl5220delta.pod ----------------------------------------------------------------------- Summary of changes: Porting/perl5220delta.pod | 574 +++++++++++++++++++++++++++++++++++++--------- 1 file changed, 463 insertions(+), 111 deletions(-) diff --git a/Porting/perl5220delta.pod b/Porting/perl5220delta.pod index 767512c..8181d1c 100644 --- a/Porting/perl5220delta.pod +++ b/Porting/perl5220delta.pod @@ -18,7 +18,27 @@ XXX Any important notices here =head1 Core Enhancements -=head2 qr/\b{gcb}/ is now handled in regular expressions +=head2 New bitwise operators + +A new experimental facility has been added that makes the four standard +bitwise operators (C<& | ^ ~>) treat their operands consistently as +numbers, and introduces four new dotted operators (C<&. |. ^. ~.>) that +treat their operands consistently as strings. The same applies to the +assignment variants (C<&= |= ^= &.= |.= ^.=>). + +To use this, enable the "bitwise" feature and disable the +"experimental::bitwise" warnings category. See L<perlop/Bitwise String +Operators> for details. [rt.perl.org #123466] + +=head2 New double-diamond operator + +C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open +each file in @ARGV. So each element of @ARGV is an actual file name, and +"|foo" won't be treated as a pipe open. + +=head2 New \b boundaries in regular expressions + +=head3 qr/\b{gcb}/ C<gcb> stands for Grapheme Cluster Boundary. It is a Unicode property that finds the boundary between sequences of characters that look like a @@ -27,7 +47,7 @@ the ability to deal with these through the C<\X> regular escape sequence. Now, there is an alternative way of handling these. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. -=head2 qr/\b{wb}/ is now handled in regular expressions +=head3 qr/\b{wb}/ C<wb> stands for Word Boundary. It is a Unicode property that finds the boundary between words. This is similar to the plain @@ -35,24 +55,12 @@ C<\b> (without braces) but is more suitable for natural language processing. It knows, for example that apostrophes can occur in the middle of words. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. -=head2 qr/\b{sb}/ is now handled in regular expressions +=head3 qr/\b{sb}/ C<sb> stands for Sentence Boundary. It is a Unicode property to aid in parsing natural language sentences. See L<perlrebackslash/\b{}, \b, \B{}, \B> for details. -=head2 New bitwise operators - -A new experimental facility has been added that makes the four standard -bitwise operators (C<& | ^ ~>) treat their operands consistently as -numbers, and introduces four new dotted operators (C<&. |. ^. ~.>) that -treat their operands consistently as strings. The same applies to the -assignment variants (C<&= |= ^= &.= |.= ^.=>). - -To use this, enable the "bitwise" feature and disable the -"experimental::bitwise" warnings category. See L<perlop/Bitwise String -Operators> for details. [rt.perl.org #123466] - =head2 C<no re> covers more and is lexical Previously running C<no re> would only turn off a few things. Now it @@ -70,10 +78,6 @@ This is equivalent to putting C<?:> at the beginning of every capturing group. See L<perlre/"n"> for more information. -=head2 C<prototype> with no arguments - -C<prototype()> with no arguments now infers C<$_>. [perl #123514] - =head2 C<use re 'strict'> This applies stricter syntax rules to regular expression patterns @@ -85,6 +89,74 @@ experience, using this pragma will raise a category C<experimental:re_strict> warning. See L<'strict' in re|re/'strict' mode>. +=head2 C<qr/foo/x> now ignores any Unicode pattern white space + +The C</x> regular expression modifier allows the pattern to contain +white space and comments, both of which are ignored, for improved +readability. Until now, not all the white space characters that Unicode +designates for this purpose were handled. The additional ones now +recognized are +U+0085 NEXT LINE, +U+200E LEFT-TO-RIGHT MARK, +U+200F RIGHT-TO-LEFT MARK, +U+2028 LINE SEPARATOR, +and +U+2029 PARAGRAPH SEPARATOR. + +=head2 Unicode 7.0 is now supported + +For details on what is in this release, see +L<http://www.unicode.org/versions/Unicode7.0.0/>. + +=head2 S<C<use locale>> can restrict which locale categories are affected + +It is now possible to pass a parameter to S<C<use locale>> to specify +a subset of locale categories to be locale-aware, with the remaining +ones unaffected. See L<perllocale/The "use locale" pragma> for details. + +=head2 Perl now supports POSIX 2008 locale currency additions. + +On platforms that are able to handle POSIX.1-2008, the +hash returned by +L<C<POSIX::localeconv()>|perllocale/The localeconv function> +includes the international currency fields added by that version of the +POSIX standard. These are +C<int_n_cs_precedes>, +C<int_n_sep_by_space>, +C<int_n_sign_posn>, +C<int_p_cs_precedes>, +C<int_p_sep_by_space>, +and +C<int_p_sign_posn>. + +=head2 Better heuristics on older platforms for determining locale UTF8ness + +On platforms that implement neither the C99 standard nor the POSIX 2001 +standard, determining if the current locale is UTF8 or not depends on +heuristics. These are improved in this release. + +=head2 Aliasing via reference + +Variables and subroutines can now be aliased by assigning to a reference: + + \$c = \$d; + \&x = \&y; + +Or by using a backslash before a C<foreach> iterator variable, which is +perhaps the most useful idiom this feature provides: + + foreach \%hash (@array_of_hash_refs) { ... } + +This feature is experimental and must be enabled via C<use feature +'refaliasing'>. It will warn unless the C<experimental::refaliasing> +warnings category is disabled. + +See L<perlref/Assigning to References> + +=head2 C<prototype> with no arguments + +C<prototype()> with no arguments now infers C<$_>. [perl #123514] + =head2 New "const" subroutine attribute The "const" attribute can be applied to an anonymous subroutine. It causes @@ -104,17 +176,6 @@ indicate that the operation is not supported. Currently, this uses either a C<dd_fd> member in the OS C<DIR> structure, or a dirfd(3) function as specified by POSIX.1-2008. -=head2 Unicode 7.0 is now supported - -For details on what is in this release, see -L<http://www.unicode.org/versions/Unicode7.0.0/>. - -=head2 Better heuristics on older platforms for determining locale UTF8ness - -On platforms that implement neither the C99 standard nor the POSIX 2001 -standard, determining if the current locale is UTF8 or not depends on -heuristics. These are improved in this release. - =head2 List form of pipe open implemented for Win32 The list form of pipe: @@ -125,12 +186,6 @@ is now implemented on Win32. It has the same limitations as C<system LIST> on Win32, since the Win32 API doesn't accept program arguments as a list. -=head2 Assignment to list repetition - -C<(...) x ...> can now be used within a list that is assigned to, as long -as the left-hand side is a valid lvalue. This allows C<(undef,undef,$foo) -= that_function()> to be written as C<((undef)x2, $foo) = that_function()>. - =head2 C<close> now sets C<$!> When an I/O error occurs, the fact that there has been an error is recorded @@ -139,6 +194,11 @@ value of C<$!> would be untouched by C<close>, so the common convention of writing C<close $fh or die $!> did not work reliably. Now the handle records the value of C<$!>, too, and C<close> restores it. +=head2 Assignment to list repetition + +C<(...) x ...> can now be used within a list that is assigned to, as long +as the left-hand side is a valid lvalue. This allows C<(undef,undef,$foo) += that_function()> to be written as C<((undef)x2, $foo) = that_function()>. =head2 Infinity and NaN (not-a-number) handling improved @@ -157,6 +217,16 @@ As a completely new feature, hexadecimal floating point literals (like 0x1.23p-4) are now supported, and they can be output with C<printf %a>. +=head2 Packing infinity or not-a-number into a character is now fatal + +Before, when trying to pack infinity or not-a-number into a +(signed) character, Perl would warn, and assumed you tried to +pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>, +C<< U+FFFD >> was returned. + +But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>) +result in a fatal error. + =head2 Experimental C Backtrace API Starting from Perl 5.21.1, on some platforms Perl supports retrieving @@ -175,80 +245,6 @@ Also included is a C API to retrieve backtraces. See L<perlhacktips/"C backtrace"> for more information. -=head2 C<qr/foo/x> now ignores any Unicode pattern white space - -The C</x> regular expression modifier allows the pattern to contain -white space and comments, both of which are ignored, for improved -readability. Until now, not all the white space characters that Unicode -designates for this purpose were handled. The additional ones now -recognized are -U+0085 NEXT LINE, -U+200E LEFT-TO-RIGHT MARK, -U+200F RIGHT-TO-LEFT MARK, -U+2028 LINE SEPARATOR, -and -U+2029 PARAGRAPH SEPARATOR. - -=head2 S<C<use locale>> can restrict which locale categories are affected - -It is now possible to pass a parameter to S<C<use locale>> to specify -a subset of locale categories to be locale-aware, with the remaining -ones unaffected. See L<perllocale/The "use locale" pragma> for details. - -=head2 New double-diamond operator - -C<<< <<>> >>> is like C<< <> >> but uses three-argument C<open> to open -each file in @ARGV. So each element of @ARGV is an actual file name, and -"|foo" won't be treated as a pipe open. - -=head2 Aliasing via reference - -Variables and subroutines can now be aliased by assigning to a reference: - - \$c = \$d; - \&x = \&y; - -Or by using a backslash before a C<foreach> iterator variable, which is -perhaps the most useful idiom this feature provides: - - foreach \%hash (@array_of_hash_refs) { ... } - -This feature is experimental and must be enabled via C<use feature -'refaliasing'>. It will warn unless the C<experimental::refaliasing> -warnings category is disabled. - -See L<perlref/Assigning to References> - -=head2 Perl now supports POSIX 2008 locale currency additions. - -On platforms that are able to handle POSIX.1-2008, the -hash returned by -L<C<POSIX::localeconv()>|perllocale/The localeconv function> -includes the international currency fields added by that version of the -POSIX standard. These are -C<int_n_cs_precedes>, -C<int_n_sep_by_space>, -C<int_n_sign_posn>, -C<int_p_cs_precedes>, -C<int_p_sep_by_space>, -and -C<int_p_sign_posn>. - -=head2 Packing infinity or not-a-number into a character is now fatal - -Before, when trying to pack infinity or not-a-number into a -(signed) character, Perl would warn, and assumed you tried to -pack C<< 0xFF >>; if you gave it as an argument to C<< chr >>, -C<< U+FFFD >> was returned. - -But now, all such actions (C<< pack >>, C<< chr >>, and C<< print '%c' >>) -result in a fatal error. - -=head2 Inf and NaN - -Many small improvements, bug fixes and added test cases for dealing -with math related to infinity and not-a-number. - =head1 Security =head2 Perl is now compiled with -fstack-protector-strong if available @@ -343,6 +339,15 @@ consistency, this is now changed to match what terminates comment lines outside S<C<(?[ ])>>, namely a C<\n> (even if escaped), which is the same as what terminates a heredoc string and formats. +=head2 C<(?[...])> operators now follow standard Perl precedence + +This experimental feature allows set operations in regular expression patterns. +Prior to this, the intersection operator had the same precedence as the other +binary operators. Now it has higher precedence. This could lead to different +outcomes than existing code expects (though the documentation has always noted +that this change might happen, recommending fully parenthesizing the +expressions). See L<perlrecharclass/Extended Bracketed Character Classes>. + =head2 Omitting % and @ on hash and array names is no longer permitted Really old Perl let you omit the @ on array names and the % on hash @@ -507,6 +512,12 @@ brackets C<"[{]">, or by using C<\Q>; otherwise a deprecation warning will be raised. This was first announced as forthcoming in the v5.16 release; it will allow future extensions to the language to happen. +=head2 Making all warnings fatal is discouraged + +The documentation for L<fatal warnings|warnings/Fatal Warnings> notes that +C<< use warnings FATAL => 'all' >> is discouraged and provides stronger +language about the risks of fatal warnings in general. + =head2 Module removals XXX Remove this section if inapplicable. @@ -674,6 +685,14 @@ optimization does not currently apply to XSUBs or exported subroutines, and method calls will undo it, since they cache things in typeglobs. L<[perl #120441]|https://rt.perl.org/Ticket/Display.html?id=120441> +=item * + +The functions C<utf8::native_to_unicode()> and C<utf8::unicode_to_native()> +(see L<utf8>) are now optimized out on ASCII platforms. There is now not even +a minimal performance hit in writing code portable between ASCII and EBCDIC +platforms. + + =back =head1 Modules and Pragmata @@ -727,6 +746,83 @@ Perl. =head2 Changes to Existing Documentation +=head3 L<perlebcdic> + +=over 4 + +=item * + +This document has been significantly updated in the light of recent +improvements to EBCDIC support. + +=back + +=head3 L<perlfunc> + +=over 4 + +=item * + +Mention that C<study()> is currently a no-op. + +=back + +=head3 L<perlguts> + +=over 4 + +=item * + +The OOK example has been updated to account for COW changes and a change in the +storage of the offset. + +=back + +=head3 L<perlhacktips> + +=over 4 + +=item * + +Documentation has been added illustrating the perils of assuming the contents +of static memory pointed to by the return values of Perl wrappers for C library +functions doesn't change. + +=back + +=head3 L<perlport> + +=over 4 + +=item * + +Out-of-date VMS-specific information has been fixed/simplified. + +=back + +=head3 L<perluniintro> + +=over 4 + +=item * + +Advice for how to make sure your strings and regular expression patterns are +interpreted as Unicode has been revised to account for the new Perl 5.22 EBCDIC +handling. + +=back + +=head3 L<perlvms> + +=over 4 + +=item * + +Out-of-date and/or incorrect material has been removed. + +=back + + =head3 L<perlunicode> =over 4 @@ -792,6 +888,8 @@ Further clarify version number representations and usage. Instead of pointing to the module list, we are now pointing to L<PrePAN|http://prepan.org/>. +=back + =head3 L<perlrebackslash> =over 4 @@ -1082,6 +1180,15 @@ diagnostic messages, see L<perldiag>. =item * +L<Invalid quantifier in {,} in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Invalid quantifier in {,} in regex; marked by <-- HERE in m/%s/"> + +(F) The pattern looks like a {min,max} quantifier, but the min or max could not +be parsed as a valid number - either it has leading zeroes, or it represents +too big a number to cope with. The S<<-- HERE> shows where in the regular +expression the problem was discovered. See L<perlre>. + +=item * + L<Bad symbol for scalar|perldiag/"Bad symbol for scalar"> (P) An internal request asked to add a scalar entry to something that @@ -1815,6 +1922,17 @@ see the discussion below at L<< /Internal Changes >>. =item * +F<t/porting/re_context.t> has been added to test that L<utf8> and its +dependencies only use the subset of the C<$1..$n> capture vars that +Perl_save_re_context() is hard-coded to localize, because that function has no +efficient way of determining at runtime what vars to localize. + +=item * + +Tests for performance issues have been added in the file F<t/perf/taint.t>. + +=item * + Some regular expression tests are written in such a way that they will run very slowly if certain optimizations break. These tests have been moved into new files, F<< t/re/speed.t >> and F<< t/re/speed_thr.t >>, @@ -1836,9 +1954,26 @@ working correctly. See L</Infinity and NaN (not-a-number) handling improved>. =head2 Regained Platforms -IRIX and Tru64 platforms are working again. +=over 4 + +=item IRIX and Tru64 platforms are working again. + (Some C<make test> failures remain.) +=item z/OS running EBCDIC Code Page 1047 + +Core perl now works on this EBCDIC platform. Earlier perls also worked, but, +even though support wasn't officially withdrawn, recent perls would not compile +and run well. Perl 5.20 would work, but had many bugs which have now been +fixed. Many CPAN modules that ship with Perl still fail tests, including +Pod::Simple. However the version of Pod::Simple currently on CPAN should work; +it was fixed too late to include in Perl 5.22. Work is under way to fix many +of the still-broken CPAN modules, which likely will be installed on CPAN when +completed, so that you may not have to wait until Perl 5.24 to get a working +version. + +=back + =head2 Discontinued Platforms =over 4 @@ -1866,6 +2001,10 @@ invoked if any of the C<\N{...}> forms for specifying a character by name or Unicode code point is used instead of a literal. See L<perlrecharclass/Character Ranges>. +=item HP-UX + +The archname now distinguishes use64bitint from use64bitall. + =item Android Build support has been improved for cross-compiling in general and for @@ -1898,6 +2037,17 @@ a fix for legacy feature checking status. =item * +F<miniperl.exe> is now built with C<-fno-strict-aliasing>, allowing 64-bit +builds to complete on GCC 4.8. +L<[perl #123976]|https://rt.perl.org/Ticket/Display.html?id=123976> + +=item * + +C<test-prep> again depends on C<test-prep-gcc> for GCC builds. +L<[perl #124221]|https://rt.perl.org/Ticket/Display.html?id=124221> + +=item * + Perl can now be built in C++ mode on Windows by setting the makefile macro C<USE_CPLUSPLUS> to the value "define". @@ -2001,6 +2151,68 @@ as well as C<SUNWspro>, and support for native C<setenv> has been added. =item * +Perl 5.21.2 introduced a new build option, C<-DPERL_OP_PARENT>, which causes +the last C<op_sibling> pointer to refer back to the parent rather than being +C<NULL>, and where instead a new flag indicates the end of the chain. In this +release, the new implementation has been revised; in particular: + +=over 4 + +=item * + +On C<PERL_OP_PARENT> builds, the C<op_sibling> field has been renamed +C<op_sibparent> to reflect its new dual purpose. Since the intention is that +this field should primarily be accessed via macros, this change should be +transparent for code written to work under C<PERL_OP_PARENT>. + +=item * + +The newly-introduced C<op_lastsib> flag bit has been renamed C<op_moresib> and +its logic inverted; i.e. it is initialised to zero in a new op, and is changed +to 1 when an op gains a sibling. + +=item * + +The function C<Perl_op_parent> is now only available on C<PERL_OP_PARENT> +builds. Using it on a plain build will be a compile-timer error. + +=item * + +Three new macros, C<OpMORESIB_set>, C<OpLASTSIB_set>, C<OpMAYBESIB_set> have +been added, which are intended to be a low-level portable way to set +C<op_sibling> / C<op_sibparent> while also updating C<op_moresib>. The first +sets the sibling pointer to a new sibling, the second makes the op the last +sibling, and the third conditionally does the first or second action. The +C<op_sibling_splice()> function is retained as a higher-level interface that +can also maintain consistency in the parent at the same time (e.g. by updating +C<op_first> and C<op_last> where appropriate). + +=item * + +The macro C<OpSIBLING_set>, added in Perl 5.21.2, has been removed. It didn't +manipulate C<op_moresib> and has been superseded by C<OpMORESIB_set> et al. + +=item * + +The C<op_sibling_splice> function now accepts a null C<parent> argument where +the splicing doesn't affect the first or last ops in the sibling chain, and +thus where the parent doesn't need to be updated accordingly. + +=back + + +=item * + +Macros have been created to allow XS code to better manipulate the POSIX locale +category C<LC_NUMERIC>. See L<perlapi/Locale-related functions and macros>. + +=item * + +The previous C<atoi> et al replacement function, C<grok_atou>, has now been +superseded by C<grok_atoUV>. See L<perlclib> for details. + +=item * + Added Perl_sv_get_backrefs() to determine if an SV is a weak-referent. Function either returns an SV * of type AV, which contains the set of @@ -2245,6 +2457,119 @@ index is still done using C<aelemfast>. =item * +C<pack("D", $x)> and C<pack("F", $x)> now zero the padding on x86 long double +builds. GCC 4.8 and later, under some build options, would either overwrite +the zero-initialized padding, or bypass the initialized buffer entirely. This +caused F<op/pack.t> to fail. +L<[perl #123971]|https://rt.perl.org/Ticket/Display.html?id=123971> + +=item * + +Extending an array cloned from a parent thread could result in "Modification of +a read-only value attempted" errors when attempting to modify the new elements. +L<[perl #124127]|https://rt.perl.org/Ticket/Display.html?id=124127> + +=item * + +An assertion failure and subsequent crash with C<< *x=<y> >> has been fixed. +L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790> + +=item * + +An optimization for state variable initialization introduced in Perl 5.21.6 has +been reverted because it was found to exacerbate some other existing buggy +behaviour. +L<[perl #124160]|https://rt.perl.org/Ticket/Display.html?id=124160> + +=item * + +The extension of another optimization to cover more ops in Perl 5.21 has also +been reverted to its Perl 5.20 state as a temporary fix for regression issues +that it caused. +L<[perl #123790]|https://rt.perl.org/Ticket/Display.html?id=123790> + +=item * + +New bitwise ops added in Perl 5.21.9 accidentally caused C<$^H |= 0x1c020000> +to enable all features. This has now been fixed. + +=item * + +A possible crashing/looping bug has been fixed. +L<[perl #124099]|https://rt.perl.org/Ticket/Display.html?id=124099> + +=item * + +UTF-8 variable names used in array indexes, unquoted UTF-8 HERE-document +terminators and UTF-8 function names all now work correctly. +L<[perl #124113]|https://rt.perl.org/Ticket/Display.html?id=124113> + + +=item * + +Repeated global pattern matches in scalar context on large tainted strings were +exponentially slow depending on the current match position in the string. +L<[perl #123202]|https://rt.perl.org/Ticket/Display.html?id=123202> + +=item * + +Various crashes due to the parser getting confused by syntax errors have been +fixed. +L<[perl #123801]|https://rt.perl.org/Ticket/Display.html?id=123801> +L<[perl #123802]|https://rt.perl.org/Ticket/Display.html?id=123802> +L<[perl #123955]|https://rt.perl.org/Ticket/Display.html?id=123955> +L<[perl #123995]|https://rt.perl.org/Ticket/Display.html?id=123995> + +=item * + +C<split> in the scope of lexical $_ has been fixed not to fail assertions. +L<[perl #123763]|https://rt.perl.org/Ticket/Display.html?id=123763> + +=item * + +C<my $x : attr> syntax inside various list operators no longer fails +assertions. +L<[perl #123817]|https://rt.perl.org/Ticket/Display.html?id=123817> + +=item * + +An @ sign in quotes followed by a non-ASCII digit (which is not a valid +identifier) would cause the parser to crash, instead of simply trying the @ as +literal. This has been fixed. +L<[perl #123963]|https://rt.perl.org/Ticket/Display.html?id=123963> + +=item * + +C<*bar::=*foo::=*glob_with_hash> has been crashing since Perl 5.14, but no +longer does. +L<[perl #123847]|https://rt.perl.org/Ticket/Display.html?id=123847> + +=item * + +C<foreach> in scalar context was not pushing an item on to the stack, resulting +in bugs. (C<print 4, scalar do { foreach(@x){} } + 1> would print 5.) It has +been fixed to return C<undef>. +L<[perl #124004]|https://rt.perl.org/Ticket/Display.html?id=124004> + +=item * + +A memory leak introduced in Perl 5.21.6 has been fixed. +L<[perl #123922]|https://rt.perl.org/Ticket/Display.html?id=123922> + +=item * + +A regression in the behaviour of the C<readline> built-in function, caused by +the introduction of the C<< <<>> >> operator, has been fixed. +L<[perl #123990]|https://rt.perl.org/Ticket/Display.html?id=123990> + +=item * + +Several cases of data used to store environment variable contents in core C +code being potentially overwritten before being used have been fixed. +L<[perl #123748]|https://rt.perl.org/Ticket/Display.html?id=123748> + +=item * + Patterns starting with C</.*/> are now fast again. [rt.perl.org #123743] =item * @@ -3018,6 +3343,33 @@ platform specific bugs also go here. =item * +A goal is for Perl to be able to be recompiled to work reasonably well on any +Unicode version. In Perl 5.22, though, the earliest such version is Unicode +5.1 (current is 7.0). + +=item * + +EBCDIC platforms + +=over 4 + +=item * + +Encode and encoding are mostly broken. + +=item * + +Many cpan modules that are shipped with core show failing tests. + +=item * + +C<pack>/C<unpack> with C<"U0"> format may not work properly. + +=back + + +=item * + XXX Check this list before the release of 5.22.0 for modules that have been fixed. -- Perl5 Master Repository
