Revert "Update docs to concur with $`,$&,$' changes"
authorDavid Mitchell <davem@iabyn.com>
Mon, 6 May 2013 11:34:59 +0000 (12:34 +0100)
committerDavid Mitchell <davem@iabyn.com>
Mon, 6 May 2013 11:34:59 +0000 (12:34 +0100)
This reverts commit d78f32f607952d58a998c5b7554572320dc57b2a.

Since COW has now not been enabled by default for 5.18, revert the
documentation changes which say that that $' etc no longer have a
performance penalty, etc.

pod/perlre.pod
pod/perlreref.pod
pod/perlretut.pod
pod/perlvar.pod

index ceba169..3be846e 100644 (file)
@@ -91,9 +91,6 @@ X</p> X<regex, preserve> X<regexp, preserve>
 Preserve the string matched such that ${^PREMATCH}, ${^MATCH}, and
 ${^POSTMATCH} are available for use after matching.
 
 Preserve the string matched such that ${^PREMATCH}, ${^MATCH}, and
 ${^POSTMATCH} are available for use after matching.
 
-In Perl 5.18 and higher this is ignored.  ${^PREMATCH}, ${^MATCH}, and
-${^POSTMATCH} will be available after the match regardless of the modifier.
-
 =item g and c
 X</g> X</c>
 
 =item g and c
 X</g> X</c>
 
@@ -875,11 +872,9 @@ B<NOTE>: Failed matches in Perl do not reset the match variables,
 which makes it easier to write code that tests for a series of more
 specific cases and remembers the best match.
 
 which makes it easier to write code that tests for a series of more
 specific cases and remembers the best match.
 
-B<WARNING>: If your code is to run on Perl 5.16 or earlier,
-beware that once Perl sees that you need one of C<$&>, C<$`>, or
+B<WARNING>: Once Perl sees that you need one of C<$&>, C<$`>, or
 C<$'> anywhere in the program, it has to provide them for every
 C<$'> anywhere in the program, it has to provide them for every
-pattern match.  This may substantially slow your program.  (In Perl 5.18 a
-more efficient mechanism is used, eliminating any slowdown.)  Perl
+pattern match.  This may substantially slow your program.  Perl
 uses the same mechanism to produce C<$1>, C<$2>, etc, so you also pay a
 price for each pattern that contains capturing parentheses.  (To
 avoid this cost while retaining the grouping behaviour, use the
 uses the same mechanism to produce C<$1>, C<$2>, etc, so you also pay a
 price for each pattern that contains capturing parentheses.  (To
 avoid this cost while retaining the grouping behaviour, use the
@@ -888,17 +883,19 @@ use C<$&>, C<$`> or C<$'>, then patterns I<without> capturing
 parentheses will not be penalized.  So avoid C<$&>, C<$'>, and C<$`>
 if you can, but if you can't (and some algorithms really appreciate
 them), once you've used them once, use them at will, because you've
 parentheses will not be penalized.  So avoid C<$&>, C<$'>, and C<$`>
 if you can, but if you can't (and some algorithms really appreciate
 them), once you've used them once, use them at will, because you've
-already paid the price. 
+already paid the price.  As of 5.17.4, the presence of each of the three
+variables in a program is recorded separately, and depending on
+circumstances, perl may be able be more efficient knowing that only C<$&>
+rather than all three have been seen, for example.
 X<$&> X<$`> X<$'>
 
 X<$&> X<$`> X<$'>
 
-As a workaround for this problem, Perl 5.10.0 introduced C<${^PREMATCH}>,
+As a workaround for this problem, Perl 5.10.0 introduces C<${^PREMATCH}>,
 C<${^MATCH}> and C<${^POSTMATCH}>, which are equivalent to C<$`>, C<$&>
 and C<$'>, B<except> that they are only guaranteed to be defined after a
 successful match that was executed with the C</p> (preserve) modifier.
 The use of these variables incurs no global performance penalty, unlike
 their punctuation char equivalents, however at the trade-off that you
 C<${^MATCH}> and C<${^POSTMATCH}>, which are equivalent to C<$`>, C<$&>
 and C<$'>, B<except> that they are only guaranteed to be defined after a
 successful match that was executed with the C</p> (preserve) modifier.
 The use of these variables incurs no global performance penalty, unlike
 their punctuation char equivalents, however at the trade-off that you
-have to tell perl when you want to use them.  As of Perl 5.18, these three
-variables are equivalent to C<$`>, C<$&> and C<$'>, and C</p> is ignored.
+have to tell perl when you want to use them.
 X</p> X<p modifier>
 
 =head2 Quoting metacharacters
 X</p> X<p modifier>
 
 =head2 Quoting metacharacters
index eb19e6c..d76b407 100644 (file)
@@ -275,15 +275,13 @@ There is no quantifier C<{,n}>. That's interpreted as a literal string.
    ${^MATCH}      Entire matched string
    ${^POSTMATCH}  Everything after to matched string
 
    ${^MATCH}      Entire matched string
    ${^POSTMATCH}  Everything after to matched string
 
-Note to those still using Perl 5.16 or earlier:
 The use of C<$`>, C<$&> or C<$'> will slow down B<all> regex use
 The use of C<$`>, C<$&> or C<$'> will slow down B<all> regex use
-within your program.  Consult L<perlvar> for C<@->
-to see equivalent expressions that won't cause slowdown.
-See also L<Devel::SawAmpersand>.  Starting with Perl 5.10, you
+within your program. Consult L<perlvar> for C<@->
+to see equivalent expressions that won't cause slow down.
+See also L<Devel::SawAmpersand>. Starting with Perl 5.10, you
 can also use the equivalent variables C<${^PREMATCH}>, C<${^MATCH}>
 and C<${^POSTMATCH}>, but for them to be defined, you have to
 specify the C</p> (preserve) modifier on your regular expression.
 can also use the equivalent variables C<${^PREMATCH}>, C<${^MATCH}>
 and C<${^POSTMATCH}>, but for them to be defined, you have to
 specify the C</p> (preserve) modifier on your regular expression.
-In Perl 5.18, the use of C<$`>, C<$&> and C<$'> makes no speed difference.
 
    $1, $2 ...  hold the Xth captured expr
    $+    Last parenthesized pattern match
 
    $1, $2 ...  hold the Xth captured expr
    $+    Last parenthesized pattern match
index 11ad1f6..bf4ab3b 100644 (file)
@@ -900,10 +900,7 @@ of the string after the match.  An example:
 
 In the second match, C<$`> equals C<''> because the regexp matched at the
 first character position in the string and stopped; it never saw the
 
 In the second match, C<$`> equals C<''> because the regexp matched at the
 first character position in the string and stopped; it never saw the
-second 'the'.
-
-If your code is to run on Perl versions earlier than
-5.18, it is worthwhile to note that using C<$`> and C<$'>
+second 'the'.  It is important to note that using C<$`> and C<$'>
 slows down regexp matching quite a bit, while C<$&> slows it down to a
 lesser extent, because if they are used in one regexp in a program,
 they are generated for I<all> regexps in the program.  So if raw
 slows down regexp matching quite a bit, while C<$&> slows it down to a
 lesser extent, because if they are used in one regexp in a program,
 they are generated for I<all> regexps in the program.  So if raw
@@ -916,11 +913,8 @@ C<@+> instead:
     $' is the same as substr( $x, $+[0] )
 
 As of Perl 5.10, the C<${^PREMATCH}>, C<${^MATCH}> and C<${^POSTMATCH}>
     $' is the same as substr( $x, $+[0] )
 
 As of Perl 5.10, the C<${^PREMATCH}>, C<${^MATCH}> and C<${^POSTMATCH}>
-variables may be used.  These are only set if the C</p> modifier is
-present.  Consequently they do not penalize the rest of the program.  In
-Perl 5.18, C<${^PREMATCH}>, C<${^MATCH}> and C<${^POSTMATCH}> are available
-whether the C</p> has been used or not (the modifier is ignored), and
-C<$`>, C<$'> and C<$&> do not cause any speed difference.
+variables may be used. These are only set if the C</p> modifier is present.
+Consequently they do not penalize the rest of the program.
 
 =head2 Non-capturing groupings
 
 
 =head2 Non-capturing groupings
 
index 286ea26..f471d33 100644 (file)
@@ -783,7 +783,7 @@ we have not made another match:
     $1 is Mutt; $2 is Jeff
     $1 is Wallace; $2 is Grommit
 
     $1 is Mutt; $2 is Jeff
     $1 is Wallace; $2 is Grommit
 
-If you are using Perl v5.16 or earlier, note that C<use
+Due to an unfortunate accident of Perl's implementation, C<use
 English> imposes a considerable performance penalty on all regular
 expression matches in a program because it uses the C<$`>, C<$&>, and
 C<$'>, regardless of whether they occur in the scope of C<use
 English> imposes a considerable performance penalty on all regular
 expression matches in a program because it uses the C<$`>, C<$&>, and
 C<$'>, regardless of whether they occur in the scope of C<use
@@ -800,9 +800,6 @@ Since Perl v5.10.0, you can use the C</p> match operator flag and the
 C<${^PREMATCH}>, C<${^MATCH}>, and C<${^POSTMATCH}> variables instead
 so you only suffer the performance penalties.
 
 C<${^PREMATCH}>, C<${^MATCH}>, and C<${^POSTMATCH}> variables instead
 so you only suffer the performance penalties.
 
-If you are using Perl v5.18.0 or higher, you do not need to worry about
-this, as the three naughty variables are no longer naughty.
-
 =over 8
 
 =item $<I<digits>> ($1, $2, ...)
 =over 8
 
 =item $<I<digits>> ($1, $2, ...)
@@ -825,8 +822,7 @@ The string matched by the last successful pattern match (not counting
 any matches hidden within a BLOCK or C<eval()> enclosed by the current
 BLOCK).
 
 any matches hidden within a BLOCK or C<eval()> enclosed by the current
 BLOCK).
 
-In Perl v5.16 and earlier, the use of this variable
-anywhere in a program imposes a considerable
+The use of this variable anywhere in a program imposes a considerable
 performance penalty on all regular expression matches.  To avoid this
 penalty, you can extract the same substring by using L</@->.  Starting
 with Perl v5.10.0, you can use the C</p> match flag and the C<${^MATCH}>
 performance penalty on all regular expression matches.  To avoid this
 penalty, you can extract the same substring by using L</@->.  Starting
 with Perl v5.10.0, you can use the C</p> match flag and the C<${^MATCH}>
@@ -840,11 +836,9 @@ Mnemonic: like C<&> in some editors.
 X<${^MATCH}>
 
 This is similar to C<$&> (C<$MATCH>) except that it does not incur the
 X<${^MATCH}>
 
 This is similar to C<$&> (C<$MATCH>) except that it does not incur the
-performance penalty associated with that variable.
-In Perl v5.16 and earlier, it is only guaranteed
+performance penalty associated with that variable, and is only guaranteed
 to return a defined value when the pattern was compiled or executed with
 to return a defined value when the pattern was compiled or executed with
-the C</p> modifier.  In Perl v5.18, the C</p> modifier does nothing, so
-C<${^MATCH}> does the same thing as C<$MATCH>.
+the C</p> modifier.
 
 This variable was added in Perl v5.10.0.
 
 
 This variable was added in Perl v5.10.0.
 
@@ -859,8 +853,7 @@ The string preceding whatever was matched by the last successful
 pattern match, not counting any matches hidden within a BLOCK or C<eval>
 enclosed by the current BLOCK.
 
 pattern match, not counting any matches hidden within a BLOCK or C<eval>
 enclosed by the current BLOCK.
 
-In Perl v5.16 and earlier, the use of this variable
-anywhere in a program imposes a considerable
+The use of this variable anywhere in a program imposes a considerable
 performance penalty on all regular expression matches.  To avoid this
 penalty, you can extract the same substring by using L</@->.  Starting
 with Perl v5.10.0, you can use the C</p> match flag and the
 performance penalty on all regular expression matches.  To avoid this
 penalty, you can extract the same substring by using L</@->.  Starting
 with Perl v5.10.0, you can use the C</p> match flag and the
@@ -875,11 +868,9 @@ Mnemonic: C<`> often precedes a quoted string.
 X<$`> X<${^PREMATCH}>
 
 This is similar to C<$`> ($PREMATCH) except that it does not incur the
 X<$`> X<${^PREMATCH}>
 
 This is similar to C<$`> ($PREMATCH) except that it does not incur the
-performance penalty associated with that variable. 
-In Perl v5.16 and earlier, it is only guaranteed
+performance penalty associated with that variable, and is only guaranteed
 to return a defined value when the pattern was compiled or executed with
 to return a defined value when the pattern was compiled or executed with
-the C</p> modifier.  In Perl v5.18, the C</p> modifier does nothing, so
-C<${^PREMATCH}> does the same thing as C<$PREMATCH>.
+the C</p> modifier.
 
 This variable was added in Perl v5.10.0
 
 
 This variable was added in Perl v5.10.0
 
@@ -898,8 +889,7 @@ enclosed by the current BLOCK).  Example:
     /def/;
     print "$`:$&:$'\n";        # prints abc:def:ghi
 
     /def/;
     print "$`:$&:$'\n";        # prints abc:def:ghi
 
-In Perl v5.16 and earlier, the use of this variable
-anywhere in a program imposes a considerable
+The use of this variable anywhere in a program imposes a considerable
 performance penalty on all regular expression matches.
 To avoid this penalty, you can extract the same substring by
 using L</@->.  Starting with Perl v5.10.0, you can use the C</p> match flag
 performance penalty on all regular expression matches.
 To avoid this penalty, you can extract the same substring by
 using L</@->.  Starting with Perl v5.10.0, you can use the C</p> match flag
@@ -914,11 +904,9 @@ Mnemonic: C<'> often follows a quoted string.
 X<${^POSTMATCH}> X<$'> X<$POSTMATCH>
 
 This is similar to C<$'> (C<$POSTMATCH>) except that it does not incur the
 X<${^POSTMATCH}> X<$'> X<$POSTMATCH>
 
 This is similar to C<$'> (C<$POSTMATCH>) except that it does not incur the
-performance penalty associated with that variable.
-In Perl v5.16 and earlier, it is only guaranteed
+performance penalty associated with that variable, and is only guaranteed
 to return a defined value when the pattern was compiled or executed with
 to return a defined value when the pattern was compiled or executed with
-the C</p> modifier.  In Perl v5.18, the C</p> modifier does nothing, so
-C<${^POSTMATCH}> does the same thing as C<$POSTMATCH>.
+the C</p> modifier.
 
 This variable was added in Perl v5.10.0.
 
 
 This variable was added in Perl v5.10.0.