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

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

Parent Directory | Revision Log | View Patch Patch

-revision 96 by nigel,
Fri Mar  2 13:10:43 2007 UTC
+revision 167 by ph10,
Wed May  9 15:53:54 2007 UTC
 Line 291 
 in the
  .\" HREF
  \fBpcreapi\fP
  .\"
- page). For example, in the "fr_FR" (French) locale, some character codes
+ page). For example, in a French locale such as "fr_FR" in Unix-like systems,
- greater than 128 are used for accented letters, and these are matched by \ew.
+ or "french" in Windows, some character codes greater than 128 are used for
+ accented letters, and these are matched by \ew.
  .P
  In UTF-8 mode, characters with values greater than 128 never match \ed, \es, or
  \ew, and always match \eD, \eS, and \eW. This is true even when Unicode
-Line 740 
 example [\ex{100}-\ex{2ff}].
+Line 741 
 example [\ex{100}-\ex{2ff}].
  If a range that includes letters is used when caseless matching is set, it
  matches the letters in either case. For example, [W-c] is equivalent to
  [][\e\e^_`wxyzabc], matched caselessly, and in non-UTF-8 mode, if character
- tables for the "fr_FR" locale are in use, [\exc8-\excb] matches accented E
+ tables for a French locale are in use, [\exc8-\excb] matches accented E
  characters in both cases. In UTF-8 mode, PCRE supports the concept of case for
  characters with values greater than 128 only when it is compiled with Unicode
  property support.
-Line 1514 
 recursion, a pseudo-condition called DEF
+Line 1515 
 recursion, a pseudo-condition called DEF
  .sp
  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
  Consider the following pattern, which contains non-significant white space to
  make it more readable (assume the PCRE_EXTENDED option) and to divide it into
-Line 1531 
 the condition is true, and so the yes-pa
+Line 1536 
 the condition is true, and so the yes-pa
  parenthesis is required. Otherwise, since no-pattern is not present, the
  subpattern matches nothing. In other words, this pattern matches a sequence of
  non-parentheses, optionally enclosed in parentheses.
+ .P
+ If you were embedding this pattern in a larger one, you could use a relative
+ reference:
+ .sp
+   ...other stuff... ( \e( )?    [^()]+    (?(-1) \e) ) ...
+ .sp
+ This makes the fragment independent of the parentheses in the larger pattern.
  .
  .SS "Checking for a used subpattern by name"
  .rs
-Line 1673 
 pattern, so instead you could use this:
+Line 1685 
 pattern, so instead you could use this:
    ( \e( ( (?>[^()]+) | (?1) )* \e) )
  .sp
  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
+ In a larger pattern, keeping track of parenthesis numbers can be tricky. This
- syntax (?P>name) is also supported. We could rewrite the above example as
+ is made easier by the use of relative references. (A Perl 5.10 feature.)
- follows:
+ 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
+ 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
+ An alternative approach is to use named parentheses instead. The Perl syntax
+ for this is (?&name); PCRE's earlier syntax (?P>name) is also supported. We
+ could rewrite the above example as follows:
  .sp
    (?<pn> \e( ( (?>[^()]+) | (?&pn) )* \e) )
  .sp
  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
+ This particular example pattern that we have been looking at contains nested
- pattern is applied to
+ 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
  .sp
    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
  .sp
-Line 1737 
 is the actual recursive call.
+Line 1763 
 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:
+ .sp
+   (...(absolute)...)...(?2)...
+   (...(relative)...)...(?-1)...
+   (...(?+1)...(relative)...
+ .sp
+ An earlier example pointed out that the pattern
  .sp
    (sens|respons)e and \e1ibility
  .sp
-Line 1758 
 When a subpattern is used as a subroutin
+Line 1791 
 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:
  .sp
-   (abc)(?i:(?1))
+   (abc)(?i:(?-1))
  .sp
  It matches "abcabc". It does not match "abcABC" because the change of
  processing option does not affect the called subpattern.
-Line 1782 
 function is to be called. If you want to
+Line 1815 
 function is to be called. If you want to
  can put a number less than 256 after the letter C. The default value is zero.
  For example, this pattern has two callout points:
  .sp
-   (?C1)\dabc(?C2)def
+   (?C1)abc(?C2)def
  .sp
  If the PCRE_AUTO_CALLOUT flag is passed to \fBpcre_compile()\fP, callouts are
  automatically installed before each item in the pattern. They are all numbered
-Line 1804 
 documentation.
+Line 1837 
 documentation.
  .rs
  .sp
  \fBpcreapi\fP(3), \fBpcrecallout\fP(3), \fBpcrematching\fP(3), \fBpcre\fP(3).
- .P
+ .
- .in 0
+ .
- Last updated: 06 December 2006
+ .SH AUTHOR
- .br
+ .rs
- Copyright (c) 1997-2006 University of Cambridge.
+ .sp
+ .nf
+ Philip Hazel
+ University Computing Service
+ Cambridge CB2 3QH, England.
+ .fi
+ .
+ .
+ .SH REVISION
+ .rs
+ .sp
+ .nf
+ Last updated: 09 May 2007
+ Copyright (c) 1997-2007 University of Cambridge.
+ .fi

 Legend:



Removed from v.96
 


changed lines


 
Added in v.167
 Legend:



Removed from v.96
 


changed lines


 
Added in v.167
-Removed from v.96
+Added in v.167

	ViewVC Help
Powered by ViewVC 1.1.5