/[pcre]/code/trunk/doc/html/pcrepattern.html

Diff of /code/trunk/doc/html/pcrepattern.html

Parent Directory | Revision Log | View Patch Patch

-revision 171 by ph10,
Tue Apr 24 13:36:11 2007 UTC
+revision 172 by ph10,
Tue Jun  5 10:40:13 2007 UTC
 Line 63 
 The remainder of this document discusses
  PCRE when its main matching function, <b>pcre_exec()</b>, is used.
  From release 6.0, PCRE offers a second matching function,
  <b>pcre_dfa_exec()</b>, which matches using a different algorithm that is not
- Perl-compatible. The advantages and disadvantages of the alternative function,
+ Perl-compatible. Some of the features discussed below are not available when
- and how it differs from the normal function, are discussed in the
+ <b>pcre_dfa_exec()</b> is used. The advantages and disadvantages of the
+ alternative function, and how it differs from the normal function, are
+ discussed in the
  <a href="pcrematching.html"><b>pcrematching</b></a>
  page.
  </P>
-Line 253 
 Absolute and relative back references
+Line 255 
 Absolute and relative back references
  </b><br>
  <P>
  The sequence \g followed by a positive or negative number, optionally enclosed
- in braces, is an absolute or relative back reference. Back references are
+ in braces, is an absolute or relative back reference. A named back reference
- discussed
+ can be coded as \g{name}. Back references are discussed
  <a href="#backreferences">later,</a>
  following the discussion of
  <a href="#subpattern">parenthesized subpatterns.</a>
-Line 528 
 Matching characters by Unicode property
+Line 530 
 Matching characters by Unicode property
  a structure that contains data for over fifteen thousand characters. That is
  why the traditional escape sequences such as \d and \w do not use Unicode
  properties in PCRE.
+ <a name="resetmatchstart"></a></P>
+ <br><b>
+ Resetting the match start
+ </b><br>
+ <P>
+ The escape sequence \K, which is a Perl 5.10 feature, causes any previously
+ matched characters not to be included in the final matched sequence. For
+ example, the pattern:
+ <pre>
+   foo\Kbar
+ </pre>
+ matches "foobar", but reports that it has matched "bar". This feature is
+ similar to a lookbehind assertion
+ <a href="#lookbehind">(described below).</a>
+ However, in this case, the part of the subject before the real match does not
+ have to be of fixed length, as lookbehind assertions do. The use of \K does
+ not interfere with the setting of
+ <a href="#subpattern">captured substrings.</a>
+ For example, when the pattern
+ <pre>
+   (foo)\Kbar
+ </pre>
+ matches "foobar", the first substring is still set to "foo".
  <a name="smallassertions"></a></P>
  <br><b>
  Simple assertions
-Line 1309 
 matches "rah rah" and "RAH RAH", but not
+Line 1334 
 matches "rah rah" and "RAH RAH", but not
  capturing subpattern is matched caselessly.
  </P>
  <P>
- Back references to named subpatterns use the Perl syntax \k&#60;name&#62; or \k'name'
+ There are several different ways of writing back references to named
- or the Python syntax (?P=name). We could rewrite the above example in either of
+ subpatterns. The .NET syntax \k{name} and the Perl syntax \k&#60;name&#62; or
+ \k'name' are supported, as is the Python syntax (?P=name). Perl 5.10's unified
+ back reference syntax, in which \g can be used for both numeric and named
+ references, is also supported. We could rewrite the above example in any of
  the following ways:
  <pre>
    (?&#60;p1&#62;(?i)rah)\s+\k&#60;p1&#62;
+   (?'p1'(?i)rah)\s+\k{p1}
    (?P&#60;p1&#62;(?i)rah)\s+(?P=p1)
+   (?&#60;p1&#62;(?i)rah)\s+\g{p1}
  </pre>
  A subpattern that is referenced by name may appear in the pattern before or
  after the reference.
-Line 1432 
 lengths, but it is acceptable if rewritt
+Line 1462 
 lengths, but it is acceptable if rewritt
  <pre>
    (?&#60;=abc|abde)
  </pre>
+ In some cases, the Perl 5.10 escape sequence \K
+ <a href="#resetmatchstart">(see above)</a>
+ can be used instead of a lookbehind assertion; this is not restricted to a
+ fixed-length.
+ </P>
+ <P>
  The implementation of lookbehind assertions is, for each alternative, to
  temporarily move the current position back by the fixed length and then try to
  match. If there are insufficient characters before the current position, the
-Line 1528 
 Checking for a used subpattern by number
+Line 1564 
 Checking for a used subpattern by number
  <P>
  If the text between the parentheses consists of a sequence of digits, the
  condition is true if the capturing subpattern of that number has previously
- matched.
+ matched. An alternative notation is to precede the digits with a plus or minus
+ sign. In this case, the subpattern number is relative rather than absolute.
+ The most recently opened parentheses can be referenced by (?(-1), the next most
+ recent by (?(-2), and so on. In looping constructs it can also make sense to
+ refer to subsequent groups with constructs such as (?(+2).
  </P>
  <P>
  Consider the following pattern, which contains non-significant white space to
-Line 1547 
 parenthesis is required. Otherwise, sinc
+Line 1587 
 parenthesis is required. Otherwise, sinc
  subpattern matches nothing. In other words, this pattern matches a sequence of
  non-parentheses, optionally enclosed in parentheses.
  </P>
+ <P>
+ If you were embedding this pattern in a larger one, you could use a relative
+ reference:
+ <pre>
+   ...other stuff... ( \( )?    [^()]+    (?(-1) \) ) ...
+ </pre>
+ This makes the fragment independent of the parentheses in the larger pattern.
+ </P>
  <br><b>
  Checking for a used subpattern by name
  </b><br>
-Line 1697 
 pattern, so instead you could use this:
+Line 1745 
 pattern, so instead you could use this:
    ( \( ( (?&#62;[^()]+) | (?1) )* \) )
  </pre>
  We have put the pattern into parentheses, and caused the recursion to refer to
- them instead of the whole pattern. In a larger pattern, keeping track of
+ them instead of the whole pattern.
- parenthesis numbers can be tricky. It may be more convenient to use named
+ </P>
- parentheses instead. The Perl syntax for this is (?&name); PCRE's earlier
+ <P>
- syntax (?P&#62;name) is also supported. We could rewrite the above example as
+ In a larger pattern, keeping track of parenthesis numbers can be tricky. This
- follows:
+ is made easier by the use of relative references. (A Perl 5.10 feature.)
+ Instead of (?1) in the pattern above you can write (?-2) to refer to the second
+ most recently opened parentheses preceding the recursion. In other words, a
+ negative number counts capturing parentheses leftwards from the point at which
+ it is encountered.
+ </P>
+ <P>
+ It is also possible to refer to subsequently opened parentheses, by writing
+ references such as (?+2). However, these cannot be recursive because the
+ reference is not inside the parentheses that are referenced. They are always
+ "subroutine" calls, as described in the next section.
+ </P>
+ <P>
+ An alternative approach is to use named parentheses instead. The Perl syntax
+ for this is (?&name); PCRE's earlier syntax (?P&#62;name) is also supported. We
+ could rewrite the above example as follows:
  <pre>
    (?&#60;pn&#62; \( ( (?&#62;[^()]+) | (?&pn) )* \) )
  </pre>
  If there is more than one subpattern with the same name, the earliest one is
- used. This particular example pattern contains nested unlimited repeats, and so
+ used.
- the use of atomic grouping for matching strings of non-parentheses is important
+ </P>
- when applying the pattern to strings that do not match. For example, when this
+ <P>
- pattern is applied to
+ This particular example pattern that we have been looking at contains nested
+ unlimited repeats, and so the use of atomic grouping for matching strings of
+ non-parentheses is important when applying the pattern to strings that do not
+ match. For example, when this pattern is applied to
  <pre>
    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
  </pre>
-Line 1758 
 is the actual recursive call.
+Line 1824 
 is the actual recursive call.
  If the syntax for a recursive subpattern reference (either by number or by
  name) is used outside the parentheses to which it refers, it operates like a
  subroutine in a programming language. The "called" subpattern may be defined
- before or after the reference. An earlier example pointed out that the pattern
+ before or after the reference. A numbered reference can be absolute or
+ relative, as in these examples:
+ <pre>
+   (...(absolute)...)...(?2)...
+   (...(relative)...)...(?-1)...
+   (...(?+1)...(relative)...
+ </pre>
+ An earlier example pointed out that the pattern
  <pre>
    (sens|respons)e and \1ibility
  </pre>
-Line 1781 
 When a subpattern is used as a subroutin
+Line 1854 
 When a subpattern is used as a subroutin
  case-independence are fixed when the subpattern is defined. They cannot be
  changed for different calls. For example, consider this pattern:
  <pre>
-   (abc)(?i:(?1))
+   (abc)(?i:(?-1))
  </pre>
  It matches "abcabc". It does not match "abcABC" because the change of
  processing option does not affect the called subpattern.
-Line 1836 
 Cambridge CB2 3QH, England.
+Line 1909 
 Cambridge CB2 3QH, England.
  </P>
  <br><a name="SEC24" href="#TOC1">REVISION</a><br>
  <P>
- Last updated: 06 March 2007
+ Last updated: 29 May 2007
  <br>
  Copyright &copy; 1997-2007 University of Cambridge.
  <br>

 Legend:



Removed from v.171
 


changed lines


 
Added in v.172
 Legend:



Removed from v.171
 


changed lines


 
Added in v.172
-Removed from v.171
+Added in v.172

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12