This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
import perl5174delta content to perl5180delta
authorRicardo Signes <rjbs@cpan.org>
Mon, 1 Apr 2013 20:49:25 +0000 (16:49 -0400)
committerRicardo Signes <rjbs@cpan.org>
Sun, 5 May 2013 19:32:19 +0000 (15:32 -0400)
Porting/perl5180delta.pod

index 6ae5cfd..389a446 100644 (file)
@@ -18,6 +18,92 @@ XXX Any important notices here
 
 =head1 Core Enhancements
 
+=head2 Latest Unicode 6.2 beta is included
+
+This is supposed to be the final data for 6.2, unless glitches are
+found.  The earlier experimental 6.2 beta data has been reverted, and
+this used instead.  Not all the changes that were proposed for 6.2 and
+that were in the earlier beta versions are actually going into 6.2.  In
+particular, there are no changes from 6.1 in the General_Category of any
+characters.  6.2 does revise the C<\X> handling for the REGIONAL
+INDICATOR characters that were added in Unicode 6.0.  Perl now for the
+first time fully handles this revision.
+
+=head2 New DTrace probes
+
+The following new DTrace probes have been added:
+
+=over 4
+
+=item C<op-entry>
+
+=item C<loading-file>
+
+=item C<loaded-file>
+
+=back
+
+=head2 C<${^LAST_FH}>
+
+This new variable provides access to the filehandle that was last read.
+This is the handle used by C<$.> and by C<tell> and C<eof> without
+arguments.
+
+=head2 Looser here-doc parsing
+
+Here-doc terminators no longer require a terminating newline character when
+they occur at the end of a file.  This was already the case at the end of a
+string eval [perl #65838].
+
+=head2 New mechanism for experimental features
+
+Newly-added experimental features will now require this incantation:
+
+    no warnings "experimental:feature_name";
+    use feature "feature_name";  # would warn without the prev line
+
+There is a new warnings category, called "experimental", containing
+warnings that the L<feature> pragma emits when enabling experimental
+features.
+
+Newly-added experimental features will also be given special warning IDs,
+which consist of "experimental:" followed by the name of the feature.  (The
+plan is to extend this mechanism eventually to all warnings, to allow them
+to be enabled or disabled individually, and not just by category.)
+
+By saying
+
+    no warnings "experimental:feature_name";
+
+you are taking responsibility for any breakage that future changes to, or
+removal of, the feature may cause.
+
+=head2 Lexical subroutines
+
+This new feature is still considered experimental.  To enable it, use the
+mechanism described above:
+
+    use 5.018;
+    no warnings "experimental:lexical_subs";
+    use feature "lexical_subs";
+
+You can now declare subroutines with C<state sub foo>, C<my sub foo>, and
+C<our sub foo>.  (C<state sub> requires that the "state" feature be
+enabled, unless you write it as C<CORE::state sub foo>.)
+
+C<state sub> creates a subroutine visible within the lexical scope in which
+it is declared.  The subroutine is shared between calls to the outer sub.
+
+C<my sub> declares a lexical subroutine that is created each time the
+enclosing block is entered.  C<state sub> is generally slightly faster than
+C<my sub>.
+
+C<our sub> declares a lexical alias to the package subroutine of the same
+name.
+
+See L<perlsub/Lexical Subroutines>.
+
+
 =head2 Computed Labels
 
 The loop controls C<next>, C<last> and C<redo>, and the special C<dump>
@@ -60,6 +146,59 @@ L</Selected Bug Fixes> section.
 
 =head1 Incompatible Changes
 
+=head2 Here-doc parsing
+
+The body of a here-document inside a quote-like operator now always begins
+on the line after the "<<foo" marker.  Previously, it was documented to
+begin on the line following the containing quote-like operator, but that
+was only sometimes the case [perl #114040].
+
+=head2 Stricter parsing of substitution replacement
+
+It is no longer possible to abuse the way the parser parses C<s///e> like
+this:
+
+    %_=(_,"Just another ");
+    $_="Perl hacker,\n";
+    s//_}->{_/e;print
+
+=head2 Interaction of lexical and default warnings
+
+Turning on any lexical warnings used first to disable all default warnings
+if lexical warnings were not already enabled:
+
+    $*; # deprecation warning
+    use warnings "void";
+    $#; # void warning; no deprecation warning
+
+Now, the debugging, deprecated, glob, inplace and malloc warnings
+categories are left on when turning on lexical warnings (unless they are
+turned off by C<no warnings>, of course).
+
+This may cause deprecation warnings to occur in code that used to be free
+of warnings.
+
+Those are the only categories consisting only of default warnings.  Default
+warnings in other categories are still disabled by C<use warnings
+"category">, as we do not yet have the infrastructure for controlling
+individual warnings.
+
+=head2 C<state sub> and C<our sub>
+
+Due to an accident of history, C<state sub> and C<our sub> were equivalent
+to a plain C<sub>, so one could even create an anonymous sub with
+C<our sub { ... }>.  These are now disallowed outside of the "lexical_subs"
+feature.  Under the "lexical_subs" feature they have new meanings described
+in L<perlsub/Lexical Subroutines>.
+
+=head2 C<gv_fetchmeth_*> and SUPER
+
+The various C<gv_fetchmeth_*> XS functions used to treat a package whose
+named ended with ::SUPER specially.  A method lookup on the Foo::SUPER
+package would be treated as a SUPER method lookup on the Foo package.  This
+is no longer the case.  To do a SUPER lookup, pass the Foo stash and the
+GV_SUPER flag.
+
 =head2 Defined values stored in environment are forced to byte strings
 
 A value stored in an environment variable has always been stringified.  In this
@@ -164,6 +303,66 @@ There may well be none in a stable release.
 
 =item *
 
+Speed up in regular expression matching against Unicode properties.  The
+largest gain is for C<\X>, the Unicode "extended grapheme cluster".  The
+gain for it is about 35% - 40%.  Bracketed character classes, e.g.,
+C<[0-9\x{100}]> containing code points above 255 are also now faster.
+
+=item *
+
+On platforms supporting it, several former macros are now implemented as static
+inline functions. This should speed things up slightly on non-GCC platforms.
+
+=item *
+
+Apply the optimisation of hashes in boolean context, such as in C<if> or C<and>,
+to constructs in non-void context.
+
+=item *
+
+Extend the optimisation of hashes in boolean context to C<scalar(%hash)>,
+C<%hash ? ... : ...>, and C<sub { %hash || ... }>.
+
+=item *
+
+When making a copy of the string being matched against (so that $1, $& et al
+continue to show the correct value even if the original string is subsequently
+modified), only copy that substring of the original string needed for the
+capture variables, rather than copying the whole string.
+
+This is a big win for code like
+
+    $&;
+    $_ = 'x' x 1_000_000;
+    1 while /(.)/;
+
+Also, when pessimizing if the code contains C<$`>, C<$&> or C<$'>, record the
+presence of each variable separately, so that the determination of the substring
+range is based on each variable separately. So performance-wise,
+
+   $&; /x/
+
+is now roughly equivalent to
+
+   /(x)/
+
+whereas previously it was like
+
+   /^(.*)(x)(.*)$/
+
+and
+
+   $&; $'; /x/
+
+is now roughly equivalent to
+
+   /(x)(.*)$/
+
+etc.
+
+
+=item *
+
 Filetest ops manage the stack in a fractionally more efficient manner.
 
 =item *
@@ -366,6 +565,78 @@ as an empty string [perl #113576].
 
 =item *
 
+L<Experimental "%s" subs not enabled|perldiag/"Experimental "%s" subs not enabled">
+
+(F) To use lexical subs, you must first enable them:
+
+    no warnings 'experimental:lexical_subs';
+    use feature 'lexical_subs';
+    my sub foo { ... }
+
+=item *
+
+L<Subroutine "&%s" is not available|perldiag/"Subroutine "&%s" is not available">
+
+(W closure) During compilation, an inner named subroutine or eval is
+attempting to capture an outer lexical subroutine that is not currently
+available.  This can happen for one of two reasons.  First, the lexical
+subroutine may be declared in an outer anonymous subroutine that has not
+yet been created.  (Remember that named subs are created at compile time,
+while anonymous subs are created at run-time.)  For example,
+
+    sub { my sub a {...} sub f { \&a } }
+
+At the time that f is created, it can't capture the current the "a" sub,
+since the anonymous subroutine hasn't been created yet.  Conversely, the
+following won't give a warning since the anonymous subroutine has by now
+been created and is live:
+
+    sub { my sub a {...} eval 'sub f { \&a }' }->();
+
+The second situation is caused by an eval accessing a variable that has
+gone out of scope, for example,
+
+    sub f {
+       my sub a {...}
+       sub { eval '\&a' }
+    }
+    f()->();
+
+Here, when the '\&a' in the eval is being compiled, f() is not currently
+being executed, so its &a is not available for capture.
+
+=item *
+
+L<"%s" subroutine &%s masks earlier declaration in same %s|perldiag/"%s" subroutine &%s masks earlier declaration in same %s>
+
+(W misc) A "my" or "state" subroutine has been redeclared in the
+current scope or statement, effectively eliminating all access to
+the previous instance.  This is almost always a typographical error.
+Note that the earlier subroutine will still exist until the end of
+the scope or until all closure references to it are destroyed.
+
+=item *
+
+L<The %s feature is experimental|perldiag/"The %s feature is experimental">
+
+(S experimental) This warning is emitted if you enable an experimental
+feature via C<use feature>.  Simply suppress the warning if you want
+to use the feature, but know that in doing so you are taking the risk
+of using an experimental feature which may change or be removed in a
+future Perl version:
+
+    no warnings "experimental:lexical_subs";
+    use feature "lexical_subs";
+
+=item *
+
+L<sleep(%u) too large|perldiag/"sleep(%u) too large">
+
+(W overflow) You called C<sleep> with a number that was larger than it can
+reliably handle and C<sleep> probably slept for less time than requested.
+
+=item *
+
 L<Wide character in setenv|perldiag/"Wide character in %s">
 
 Attempts to put wide characters into environment variables via C<%ENV> now
@@ -401,6 +672,25 @@ XXX Changes (i.e. rewording) of diagnostic messages go here
 
 =item *
 
+L<vector argument not supported with alpha versions|perldiag/vector argument not supported with alpha versions>
+
+This warning was not suppressable, even with C<no warnings>.  Now it is
+suppressible, and has been moved from the "internal" category to the
+"printf" category.
+
+=item *
+
+C<< Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ >>
+
+This fatal error has been turned into a warning that reads:
+
+L<< Quantifier {n,m} with n > m can't match in regex | perldiag/Quantifier {n,m} with n > m can't match in regex >>
+
+(W regexp) Minima should be less than or equal to maxima.  If you really want
+your regexp to match something 0 times, just put {0}.
+
+=item *
+
 The "Runaway prototype" warning that occurs in bizarre cases has been
 removed as being unhelpful and inconsistent.
 
@@ -458,6 +748,11 @@ L</Platform Support> section, instead.
 
 =item *
 
+F<Configure> will now correctly detect C<isblank()> when compiling with a C++
+compiler.
+
+=item *
+
 The pager detection in F<Configure> has been improved to allow responses which
 specify options after the program name, e.g. B</usr/bin/less -R>, if the user
 accepts the default value.  This helps B<perldoc> when handling ANSI escapes
@@ -519,6 +814,13 @@ version of System V created by Amdahl, subsequently sold to UTS Global.  The
 port has not been touched since before Perl 5.8.0, and UTS Global is now
 defunct.
 
+=item VM/ESA
+
+Support for VM/ESA has been removed. The port was tested on 2.3.0, which
+IBM ended service on in March 2002. 2.4.0 ended service in June 2003, and
+was superseded by Z/VM. The current version of Z/VM is V6.2.0, and scheduled
+for end of service on 2015/04/30.
+
 =back
 
 =head2 Platform-Specific Notes
@@ -542,6 +844,28 @@ mathom functions are now compiled as C<extern "C">, to ensure proper
 binary compatibility.  (However, binary compatibility isn't generally
 guaranteed anyway in the situations where this would matter.)
 
+=item Win32
+
+Fixed a problem where perl could crash while cleaning up threads (including the
+main thread) in threaded debugging builds on Win32 and possibly other platforms
+[perl #114496].
+
+A rare race condition that would lead to L<sleep|perlfunc/sleep> taking more
+time than requested, and possibly even hanging, has been fixed [perl #33096].
+
+=item Solaris
+
+In Configure, avoid running sed commands with flags not supported on Solaris.
+
+=item Darwin
+
+Stop hardcoding an alignment on 8 byte boundaries to fix builds using
+-Dusemorebits.
+
+=item VMS
+
+Fix linking on builds configured with -Dusemymalloc=y.
+
 =item VMS
 
 It should now be possible to compile Perl as C++ on VMS.
@@ -609,6 +933,32 @@ that assume C99 [perl #113778].
 
 =item *
 
+The APIs for accessing lexical pads have changed considerably.
+
+C<PADLIST>s are now longer C<AV>s, but their own type instead. C<PADLIST>s now
+contain a C<PAD> and a C<PADNAMELIST> of C<PADNAME>s, rather than C<AV>s for the
+pad and the list of pad names.  C<PAD>s, C<PADNAMELIST>s, and C<PADNAME>s are to
+be accessed as such through the newly added pad API instead of the plain C<AV>
+and C<SV> APIs.  See L<perlapi> for details.
+
+=item *
+
+In the regex API, the numbered capture callbacks are passed an index
+indicating what match variable is being accessed. There are special
+index values for the C<$`, $&, $&> variables. Previously the same three
+values were used to retrieve C<${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}>
+too, but these have now been assigned three separate values. See
+L<perlreapi/Numbered capture callbacks>.
+
+=item *
+
+C<PL_sawampersand> was previously a boolean indicating that any of
+C<$`, $&, $&> had been seen; it now contains three one-bit flags
+indicating the presence of each of the variables individually.
+
+
+=item *
+
 The C<CV *> typemap entry now supports C<&{}> overloading and typeglobs,
 just like C<&{...}> [perl #96872].
 
@@ -694,6 +1044,134 @@ and PERL_DEBUG_READONLY_OPS, has been retired.
 
 =item *
 
+The error "Can't localize through a reference" had disappeared in 5.16.0
+when C<local %$ref> appeared on the last line of an lvalue subroutine.
+This error disappeared for C<\local %$ref> in perl 5.8.1.  It has now
+been restored.
+
+=item *
+
+The parsing of here-docs has been improved significantly, fixing several
+parsing bugs and crashes and one memory leak, and correcting wrong
+subsequent line numbers under certain conditions.
+
+=item *
+
+Inside an eval, the error message for an unterminated here-doc no longer
+has a newline in the middle of it [perl #70836].
+
+=item *
+
+A substitution inside a substitution pattern (C<s/${s|||}//>) no longer
+confuses the parser.
+
+=item *
+
+It may be an odd place to allow comments, but C<s//"" # hello/e> has
+always worked, I<unless> there happens to be a null character before the
+first #.  Now it works even in the presence of nulls.
+
+=item *
+
+An invalid range in C<tr///> or C<y///> no longer results in a memory leak.
+
+=item *
+
+String eval no longer treats a semicolon-delimited quote-like operator at
+the very end (C<eval 'q;;'>) as a syntax error.
+
+=item *
+
+C<< warn {$_ => 1} + 1 >> is no longer a syntax error.  The parser used to
+get confused with certain list operators followed by an anonymous hash and
+then an infix operator that shares its form with a unary operator.
+
+=item *
+
+C<(caller $n)[6]> (which gives the text of the eval) used to return the
+actual parser buffer.  Modifying it could result in crashes.  Now it always
+returns a copy.  The string returned no longer has "\n;" tacked on to the
+end.  The returned text also includes here-doc bodies, which used to be
+omitted.
+
+=item *
+
+Reset the utf8 position cache when accessing magical variables to avoid the
+string buffer and the utf8 position cache getting out of sync
+[perl #114410].
+
+=item *
+
+Various cases of get magic being called twice for magical utf8 strings have been
+fixed.
+
+=item *
+
+This code (when not in the presence of C<$&> etc)
+
+    $_ = 'x' x 1_000_000;
+    1 while /(.)/;
+
+used to skip the buffer copy for performance reasons, but suffered from C<$1>
+etc changing if the original string changed.  That's now been fixed.
+
+=item *
+
+Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO
+might attempt to allocate more memory.
+
+=item *
+
+In a regular expression, if something is quantified with C<{n,m}>
+where C<S<n E<gt> m>>, it can't possibly match.  Previously this was a fatal error,
+but now is merely a warning (and that something won't match).  [perl #82954].
+
+=item *
+
+It used to be possible for formats defined in subroutines that have
+subsequently been undefined and redefined to close over variables in the
+wrong pad (the newly-defined enclosing sub), resulting in crashes or
+"Bizarre copy" errors.
+
+=item *
+
+Redefinition of XSUBs at run time could produce warnings with the wrong
+line number.
+
+=item *
+
+The %vd sprintf format does not support version objects for alpha versions.
+It used to output the format itself (%vd) when passed an alpha version, and
+also emit an "Invalid conversion in printf" warning.  It no longer does,
+but produces the empty string in the output.  It also no longer leaks
+memory in this case.
+
+=item *
+
+A bug fix in an earlier 5.17.x release caused C<no a a 3> (a syntax error)
+to result in a bad read or assertion failure, because an op was being freed
+twice.
+
+=item *
+
+C<< $obj->SUPER::method >> calls in the main package could fail if the
+SUPER package had already been accessed by other means.
+
+=item *
+
+Stash aliasing (C<*foo:: = *bar::>) no longer causes SUPER calls to ignore
+changes to methods or @ISA or use the wrong package.
+
+=item *
+
+Method calls on packages whose names end in ::SUPER are no longer treated
+as SUPER method calls, resulting in failure to find the method.
+Furthermore, defining subroutines in such packages no longer causes them to
+be found by SUPER method calls on the containing package [perl #114924].
+
+
+=item *
+
 C<\w> now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D
 (ZERO WIDTH JOINER).  C<\W> no longer matches these.  This change is because
 Unicode corrected their definition of what C<\w> should match.