ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 73 - (show annotations)
Sat Feb 24 21:40:30 2007 UTC (14 years ago) by nigel
File size: 55268 byte(s)
Error occurred while calculating annotation data.
Load pcre-4.5 into code/trunk.
1 .TH PCRE 3
3 PCRE - Perl-compatible regular expressions
5 .rs
6 .sp
7 The syntax and semantics of the regular expressions supported by PCRE are
8 described below. Regular expressions are also described in the Perl
9 documentation and in a number of other books, some of which have copious
10 examples. Jeffrey Friedl's "Mastering Regular Expressions", published by
11 O'Reilly, covers them in great detail. The description here is intended as
12 reference documentation.
14 The basic operation of PCRE is on strings of bytes. However, there is also
15 support for UTF-8 character strings. To use this support you must build PCRE to
16 include UTF-8 support, and then call \fBpcre_compile()\fR with the PCRE_UTF8
17 option. How this affects the pattern matching is mentioned in several places
18 below. There is also a summary of UTF-8 features in the
19 .\" HTML <a href="pcre.html#utf8support">
20 .\" </a>
21 section on UTF-8 support
22 .\"
23 in the main
24 .\" HREF
25 \fBpcre\fR
26 .\"
27 page.
29 A regular expression is a pattern that is matched against a subject string from
30 left to right. Most characters stand for themselves in a pattern, and match the
31 corresponding characters in the subject. As a trivial example, the pattern
33 The quick brown fox
35 matches a portion of a subject string that is identical to itself. The power of
36 regular expressions comes from the ability to include alternatives and
37 repetitions in the pattern. These are encoded in the pattern by the use of
38 \fImeta-characters\fR, which do not stand for themselves but instead are
39 interpreted in some special way.
41 There are two different sets of meta-characters: those that are recognized
42 anywhere in the pattern except within square brackets, and those that are
43 recognized in square brackets. Outside square brackets, the meta-characters are
44 as follows:
46 \\ general escape character with several uses
47 ^ assert start of string (or line, in multiline mode)
48 $ assert end of string (or line, in multiline mode)
49 . match any character except newline (by default)
50 [ start character class definition
51 | start of alternative branch
52 ( start subpattern
53 ) end subpattern
54 ? extends the meaning of (
55 also 0 or 1 quantifier
56 also quantifier minimizer
57 * 0 or more quantifier
58 + 1 or more quantifier
59 also "possessive quantifier"
60 { start min/max quantifier
62 Part of a pattern that is in square brackets is called a "character class". In
63 a character class the only meta-characters are:
65 \\ general escape character
66 ^ negate the class, but only if the first character
67 - indicates character range
68 [ POSIX character class (only if followed by POSIX
69 syntax)
70 ] terminates the character class
72 The following sections describe the use of each of the meta-characters.
75 .rs
76 .sp
77 The backslash character has several uses. Firstly, if it is followed by a
78 non-alphameric character, it takes away any special meaning that character may
79 have. This use of backslash as an escape character applies both inside and
80 outside character classes.
82 For example, if you want to match a * character, you write \\* in the pattern.
83 This escaping action applies whether or not the following character would
84 otherwise be interpreted as a meta-character, so it is always safe to precede a
85 non-alphameric with backslash to specify that it stands for itself. In
86 particular, if you want to match a backslash, you write \\\\.
88 If a pattern is compiled with the PCRE_EXTENDED option, whitespace in the
89 pattern (other than in a character class) and characters between a # outside
90 a character class and the next newline character are ignored. An escaping
91 backslash can be used to include a whitespace or # character as part of the
92 pattern.
94 If you want to remove the special meaning from a sequence of characters, you
95 can do so by putting them between \\Q and \\E. This is different from Perl in
96 that $ and @ are handled as literals in \\Q...\\E sequences in PCRE, whereas in
97 Perl, $ and @ cause variable interpolation. Note the following examples:
99 Pattern PCRE matches Perl matches
101 \\Qabc$xyz\\E abc$xyz abc followed by the
102 contents of $xyz
103 \\Qabc\\$xyz\\E abc\\$xyz abc\\$xyz
104 \\Qabc\\E\\$\\Qxyz\\E abc$xyz abc$xyz
106 The \\Q...\\E sequence is recognized both inside and outside character classes.
108 A second use of backslash provides a way of encoding non-printing characters
109 in patterns in a visible manner. There is no restriction on the appearance of
110 non-printing characters, apart from the binary zero that terminates a pattern,
111 but when a pattern is being prepared by text editing, it is usually easier to
112 use one of the following escape sequences than the binary character it
113 represents:
115 \\a alarm, that is, the BEL character (hex 07)
116 \\cx "control-x", where x is any character
117 \\e escape (hex 1B)
118 \\f formfeed (hex 0C)
119 \\n newline (hex 0A)
120 \\r carriage return (hex 0D)
121 \\t tab (hex 09)
122 \\ddd character with octal code ddd, or backreference
123 \\xhh character with hex code hh
124 \\x{hhh..} character with hex code hhh... (UTF-8 mode only)
126 The precise effect of \\cx is as follows: if x is a lower case letter, it
127 is converted to upper case. Then bit 6 of the character (hex 40) is inverted.
128 Thus \\cz becomes hex 1A, but \\c{ becomes hex 3B, while \\c; becomes hex
129 7B.
131 After \\x, from zero to two hexadecimal digits are read (letters can be in
132 upper or lower case). In UTF-8 mode, any number of hexadecimal digits may
133 appear between \\x{ and }, but the value of the character code must be less
134 than 2**31 (that is, the maximum hexadecimal value is 7FFFFFFF). If characters
135 other than hexadecimal digits appear between \\x{ and }, or if there is no
136 terminating }, this form of escape is not recognized. Instead, the initial
137 \\x will be interpreted as a basic hexadecimal escape, with no following
138 digits, giving a byte whose value is zero.
140 Characters whose value is less than 256 can be defined by either of the two
141 syntaxes for \\x when PCRE is in UTF-8 mode. There is no difference in the
142 way they are handled. For example, \\xdc is exactly the same as \\x{dc}.
144 After \\0 up to two further octal digits are read. In both cases, if there
145 are fewer than two digits, just those that are present are used. Thus the
146 sequence \\0\\x\\07 specifies two binary zeros followed by a BEL character
147 (code value 7). Make sure you supply two digits after the initial zero if the
148 character that follows is itself an octal digit.
150 The handling of a backslash followed by a digit other than 0 is complicated.
151 Outside a character class, PCRE reads it and any following digits as a decimal
152 number. If the number is less than 10, or if there have been at least that many
153 previous capturing left parentheses in the expression, the entire sequence is
154 taken as a \fIback reference\fR. A description of how this works is given
155 later, following the discussion of parenthesized subpatterns.
157 Inside a character class, or if the decimal number is greater than 9 and there
158 have not been that many capturing subpatterns, PCRE re-reads up to three octal
159 digits following the backslash, and generates a single byte from the least
160 significant 8 bits of the value. Any subsequent digits stand for themselves.
161 For example:
163 \\040 is another way of writing a space
164 \\40 is the same, provided there are fewer than 40
165 previous capturing subpatterns
166 \\7 is always a back reference
167 \\11 might be a back reference, or another way of
168 writing a tab
169 \\011 is always a tab
170 \\0113 is a tab followed by the character "3"
171 \\113 might be a back reference, otherwise the
172 character with octal code 113
173 \\377 might be a back reference, otherwise
174 the byte consisting entirely of 1 bits
175 \\81 is either a back reference, or a binary zero
176 followed by the two characters "8" and "1"
178 Note that octal values of 100 or greater must not be introduced by a leading
179 zero, because no more than three octal digits are ever read.
181 All the sequences that define a single byte value or a single UTF-8 character
182 (in UTF-8 mode) can be used both inside and outside character classes. In
183 addition, inside a character class, the sequence \\b is interpreted as the
184 backspace character (hex 08). Outside a character class it has a different
185 meaning (see below).
187 The third use of backslash is for specifying generic character types:
189 \\d any decimal digit
190 \\D any character that is not a decimal digit
191 \\s any whitespace character
192 \\S any character that is not a whitespace character
193 \\w any "word" character
194 \\W any "non-word" character
196 Each pair of escape sequences partitions the complete set of characters into
197 two disjoint sets. Any given character matches one, and only one, of each pair.
199 In UTF-8 mode, characters with values greater than 255 never match \\d, \\s, or
200 \\w, and always match \\D, \\S, and \\W.
202 For compatibility with Perl, \\s does not match the VT character (code 11).
203 This makes it different from the the POSIX "space" class. The \\s characters
204 are HT (9), LF (10), FF (12), CR (13), and space (32).
206 A "word" character is any letter or digit or the underscore character, that is,
207 any character which can be part of a Perl "word". The definition of letters and
208 digits is controlled by PCRE's character tables, and may vary if locale-
209 specific matching is taking place (see
210 .\" HTML <a href="pcreapi.html#localesupport">
211 .\" </a>
212 "Locale support"
213 .\"
214 in the
215 .\" HREF
216 \fBpcreapi\fR
217 .\"
218 page). For example, in the "fr" (French) locale, some character codes greater
219 than 128 are used for accented letters, and these are matched by \\w.
221 These character type sequences can appear both inside and outside character
222 classes. They each match one character of the appropriate type. If the current
223 matching point is at the end of the subject string, all of them fail, since
224 there is no character to match.
226 The fourth use of backslash is for certain simple assertions. An assertion
227 specifies a condition that has to be met at a particular point in a match,
228 without consuming any characters from the subject string. The use of
229 subpatterns for more complicated assertions is described below. The backslashed
230 assertions are
232 \\b matches at a word boundary
233 \\B matches when not at a word boundary
234 \\A matches at start of subject
235 \\Z matches at end of subject or before newline at end
236 \\z matches at end of subject
237 \\G matches at first matching position in subject
239 These assertions may not appear in character classes (but note that \\b has a
240 different meaning, namely the backspace character, inside a character class).
242 A word boundary is a position in the subject string where the current character
243 and the previous character do not both match \\w or \\W (i.e. one matches
244 \\w and the other matches \\W), or the start or end of the string if the
245 first or last character matches \\w, respectively.
247 The \\A, \\Z, and \\z assertions differ from the traditional circumflex and
248 dollar (described below) in that they only ever match at the very start and end
249 of the subject string, whatever options are set. Thus, they are independent of
250 multiline mode.
252 They are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options. If the
253 \fIstartoffset\fR argument of \fBpcre_exec()\fR is non-zero, indicating that
254 matching is to start at a point other than the beginning of the subject, \\A
255 can never match. The difference between \\Z and \\z is that \\Z matches before
256 a newline that is the last character of the string as well as at the end of the
257 string, whereas \\z matches only at the end.
259 The \\G assertion is true only when the current matching position is at the
260 start point of the match, as specified by the \fIstartoffset\fR argument of
261 \fBpcre_exec()\fR. It differs from \\A when the value of \fIstartoffset\fR is
262 non-zero. By calling \fBpcre_exec()\fR multiple times with appropriate
263 arguments, you can mimic Perl's /g option, and it is in this kind of
264 implementation where \\G can be useful.
266 Note, however, that PCRE's interpretation of \\G, as the start of the current
267 match, is subtly different from Perl's, which defines it as the end of the
268 previous match. In Perl, these can be different when the previously matched
269 string was empty. Because PCRE does just one match at a time, it cannot
270 reproduce this behaviour.
272 If all the alternatives of a pattern begin with \\G, the expression is anchored
273 to the starting match position, and the "anchored" flag is set in the compiled
274 regular expression.
277 .rs
278 .sp
279 Outside a character class, in the default matching mode, the circumflex
280 character is an assertion which is true only if the current matching point is
281 at the start of the subject string. If the \fIstartoffset\fR argument of
282 \fBpcre_exec()\fR is non-zero, circumflex can never match if the PCRE_MULTILINE
283 option is unset. Inside a character class, circumflex has an entirely different
284 meaning (see below).
286 Circumflex need not be the first character of the pattern if a number of
287 alternatives are involved, but it should be the first thing in each alternative
288 in which it appears if the pattern is ever to match that branch. If all
289 possible alternatives start with a circumflex, that is, if the pattern is
290 constrained to match only at the start of the subject, it is said to be an
291 "anchored" pattern. (There are also other constructs that can cause a pattern
292 to be anchored.)
294 A dollar character is an assertion which is true only if the current matching
295 point is at the end of the subject string, or immediately before a newline
296 character that is the last character in the string (by default). Dollar need
297 not be the last character of the pattern if a number of alternatives are
298 involved, but it should be the last item in any branch in which it appears.
299 Dollar has no special meaning in a character class.
301 The meaning of dollar can be changed so that it matches only at the very end of
302 the string, by setting the PCRE_DOLLAR_ENDONLY option at compile time. This
303 does not affect the \\Z assertion.
305 The meanings of the circumflex and dollar characters are changed if the
306 PCRE_MULTILINE option is set. When this is the case, they match immediately
307 after and immediately before an internal newline character, respectively, in
308 addition to matching at the start and end of the subject string. For example,
309 the pattern /^abc$/ matches the subject string "def\\nabc" in multiline mode,
310 but not otherwise. Consequently, patterns that are anchored in single line mode
311 because all branches start with ^ are not anchored in multiline mode, and a
312 match for circumflex is possible when the \fIstartoffset\fR argument of
313 \fBpcre_exec()\fR is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if
314 PCRE_MULTILINE is set.
316 Note that the sequences \\A, \\Z, and \\z can be used to match the start and
317 end of the subject in both modes, and if all branches of a pattern start with
318 \\A it is always anchored, whether PCRE_MULTILINE is set or not.
321 .rs
322 .sp
323 Outside a character class, a dot in the pattern matches any one character in
324 the subject, including a non-printing character, but not (by default) newline.
325 In UTF-8 mode, a dot matches any UTF-8 character, which might be more than one
326 byte long, except (by default) for newline. If the PCRE_DOTALL option is set,
327 dots match newlines as well. The handling of dot is entirely independent of the
328 handling of circumflex and dollar, the only relationship being that they both
329 involve newline characters. Dot has no special meaning in a character class.
332 .rs
333 .sp
334 Outside a character class, the escape sequence \\C matches any one byte, both
335 in and out of UTF-8 mode. Unlike a dot, it always matches a newline. The
336 feature is provided in Perl in order to match individual bytes in UTF-8 mode.
337 Because it breaks up UTF-8 characters into individual bytes, what remains in
338 the string may be a malformed UTF-8 string. For this reason it is best avoided.
340 PCRE does not allow \\C to appear in lookbehind assertions (see below), because
341 in UTF-8 mode it makes it impossible to calculate the length of the lookbehind.
344 .rs
345 .sp
346 An opening square bracket introduces a character class, terminated by a closing
347 square bracket. A closing square bracket on its own is not special. If a
348 closing square bracket is required as a member of the class, it should be the
349 first data character in the class (after an initial circumflex, if present) or
350 escaped with a backslash.
352 A character class matches a single character in the subject. In UTF-8 mode, the
353 character may occupy more than one byte. A matched character must be in the set
354 of characters defined by the class, unless the first character in the class
355 definition is a circumflex, in which case the subject character must not be in
356 the set defined by the class. If a circumflex is actually required as a member
357 of the class, ensure it is not the first character, or escape it with a
358 backslash.
360 For example, the character class [aeiou] matches any lower case vowel, while
361 [^aeiou] matches any character that is not a lower case vowel. Note that a
362 circumflex is just a convenient notation for specifying the characters which
363 are in the class by enumerating those that are not. It is not an assertion: it
364 still consumes a character from the subject string, and fails if the current
365 pointer is at the end of the string.
367 In UTF-8 mode, characters with values greater than 255 can be included in a
368 class as a literal string of bytes, or by using the \\x{ escaping mechanism.
370 When caseless matching is set, any letters in a class represent both their
371 upper case and lower case versions, so for example, a caseless [aeiou] matches
372 "A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a
373 caseful version would. PCRE does not support the concept of case for characters
374 with values greater than 255.
376 The newline character is never treated in any special way in character classes,
377 whatever the setting of the PCRE_DOTALL or PCRE_MULTILINE options is. A class
378 such as [^a] will always match a newline.
380 The minus (hyphen) character can be used to specify a range of characters in a
381 character class. For example, [d-m] matches any letter between d and m,
382 inclusive. If a minus character is required in a class, it must be escaped with
383 a backslash or appear in a position where it cannot be interpreted as
384 indicating a range, typically as the first or last character in the class.
386 It is not possible to have the literal character "]" as the end character of a
387 range. A pattern such as [W-]46] is interpreted as a class of two characters
388 ("W" and "-") followed by a literal string "46]", so it would match "W46]" or
389 "-46]". However, if the "]" is escaped with a backslash it is interpreted as
390 the end of range, so [W-\\]46] is interpreted as a single class containing a
391 range followed by two separate characters. The octal or hexadecimal
392 representation of "]" can also be used to end a range.
394 Ranges operate in the collating sequence of character values. They can also be
395 used for characters specified numerically, for example [\\000-\\037]. In UTF-8
396 mode, ranges can include characters whose values are greater than 255, for
397 example [\\x{100}-\\x{2ff}].
399 If a range that includes letters is used when caseless matching is set, it
400 matches the letters in either case. For example, [W-c] is equivalent to
401 [][\\^_`wxyzabc], matched caselessly, and if character tables for the "fr"
402 locale are in use, [\\xc8-\\xcb] matches accented E characters in both cases.
404 The character types \\d, \\D, \\s, \\S, \\w, and \\W may also appear in a
405 character class, and add the characters that they match to the class. For
406 example, [\\dABCDEF] matches any hexadecimal digit. A circumflex can
407 conveniently be used with the upper case character types to specify a more
408 restricted set of characters than the matching lower case type. For example,
409 the class [^\\W_] matches any letter or digit, but not underscore.
411 All non-alphameric characters other than \\, -, ^ (at the start) and the
412 terminating ] are non-special in character classes, but it does no harm if they
413 are escaped.
416 .rs
417 .sp
418 Perl supports the POSIX notation for character classes, which uses names
419 enclosed by [: and :] within the enclosing square brackets. PCRE also supports
420 this notation. For example,
422 [01[:alpha:]%]
424 matches "0", "1", any alphabetic character, or "%". The supported class names
425 are
427 alnum letters and digits
428 alpha letters
429 ascii character codes 0 - 127
430 blank space or tab only
431 cntrl control characters
432 digit decimal digits (same as \\d)
433 graph printing characters, excluding space
434 lower lower case letters
435 print printing characters, including space
436 punct printing characters, excluding letters and digits
437 space white space (not quite the same as \\s)
438 upper upper case letters
439 word "word" characters (same as \\w)
440 xdigit hexadecimal digits
442 The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13), and
443 space (32). Notice that this list includes the VT character (code 11). This
444 makes "space" different to \\s, which does not include VT (for Perl
445 compatibility).
447 The name "word" is a Perl extension, and "blank" is a GNU extension from Perl
448 5.8. Another Perl extension is negation, which is indicated by a ^ character
449 after the colon. For example,
451 [12[:^digit:]]
453 matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the POSIX
454 syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not
455 supported, and an error is given if they are encountered.
457 In UTF-8 mode, characters with values greater than 255 do not match any of
458 the POSIX character classes.
461 .rs
462 .sp
463 Vertical bar characters are used to separate alternative patterns. For example,
464 the pattern
466 gilbert|sullivan
468 matches either "gilbert" or "sullivan". Any number of alternatives may appear,
469 and an empty alternative is permitted (matching the empty string).
470 The matching process tries each alternative in turn, from left to right,
471 and the first one that succeeds is used. If the alternatives are within a
472 subpattern (defined below), "succeeds" means matching the rest of the main
473 pattern as well as the alternative in the subpattern.
476 .rs
477 .sp
479 PCRE_EXTENDED options can be changed from within the pattern by a sequence of
480 Perl option letters enclosed between "(?" and ")". The option letters are
484 s for PCRE_DOTALL
487 For example, (?im) sets caseless, multiline matching. It is also possible to
488 unset these options by preceding the letter with a hyphen, and a combined
489 setting and unsetting such as (?im-sx), which sets PCRE_CASELESS and
490 PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED, is also
491 permitted. If a letter appears both before and after the hyphen, the option is
492 unset.
494 When an option change occurs at top level (that is, not inside subpattern
495 parentheses), the change applies to the remainder of the pattern that follows.
496 If the change is placed right at the start of a pattern, PCRE extracts it into
497 the global options (and it will therefore show up in data extracted by the
498 \fBpcre_fullinfo()\fR function).
500 An option change within a subpattern affects only that part of the current
501 pattern that follows it, so
503 (a(?i)b)c
505 matches abc and aBc and no other strings (assuming PCRE_CASELESS is not used).
506 By this means, options can be made to have different settings in different
507 parts of the pattern. Any changes made in one alternative do carry on
508 into subsequent branches within the same subpattern. For example,
510 (a(?i)b|c)
512 matches "ab", "aB", "c", and "C", even though when matching "C" the first
513 branch is abandoned before the option setting. This is because the effects of
514 option settings happen at compile time. There would be some very weird
515 behaviour otherwise.
517 The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed in the
518 same way as the Perl-compatible options by using the characters U and X
519 respectively. The (?X) flag setting is special in that it must always occur
520 earlier in the pattern than any of the additional features it turns on, even
521 when it is at top level. It is best put at the start.
524 .rs
525 .sp
526 Subpatterns are delimited by parentheses (round brackets), which can be nested.
527 Marking part of a pattern as a subpattern does two things:
529 1. It localizes a set of alternatives. For example, the pattern
531 cat(aract|erpillar|)
533 matches one of the words "cat", "cataract", or "caterpillar". Without the
534 parentheses, it would match "cataract", "erpillar" or the empty string.
536 2. It sets up the subpattern as a capturing subpattern (as defined above).
537 When the whole pattern matches, that portion of the subject string that matched
538 the subpattern is passed back to the caller via the \fIovector\fR argument of
539 \fBpcre_exec()\fR. Opening parentheses are counted from left to right (starting
540 from 1) to obtain the numbers of the capturing subpatterns.
542 For example, if the string "the red king" is matched against the pattern
544 the ((red|white) (king|queen))
546 the captured substrings are "red king", "red", and "king", and are numbered 1,
547 2, and 3, respectively.
549 The fact that plain parentheses fulfil two functions is not always helpful.
550 There are often times when a grouping subpattern is required without a
551 capturing requirement. If an opening parenthesis is followed by a question mark
552 and a colon, the subpattern does not do any capturing, and is not counted when
553 computing the number of any subsequent capturing subpatterns. For example, if
554 the string "the white queen" is matched against the pattern
556 the ((?:red|white) (king|queen))
558 the captured substrings are "white queen" and "queen", and are numbered 1 and
559 2. The maximum number of capturing subpatterns is 65535, and the maximum depth
560 of nesting of all subpatterns, both capturing and non-capturing, is 200.
562 As a convenient shorthand, if any option settings are required at the start of
563 a non-capturing subpattern, the option letters may appear between the "?" and
564 the ":". Thus the two patterns
566 (?i:saturday|sunday)
567 (?:(?i)saturday|sunday)
569 match exactly the same set of strings. Because alternative branches are tried
570 from left to right, and options are not reset until the end of the subpattern
571 is reached, an option setting in one branch does affect subsequent branches, so
572 the above patterns match "SUNDAY" as well as "Saturday".
575 .rs
576 .sp
577 Identifying capturing parentheses by number is simple, but it can be very hard
578 to keep track of the numbers in complicated regular expressions. Furthermore,
579 if an expression is modified, the numbers may change. To help with the
580 difficulty, PCRE supports the naming of subpatterns, something that Perl does
581 not provide. The Python syntax (?P<name>...) is used. Names consist of
582 alphanumeric characters and underscores, and must be unique within a pattern.
584 Named capturing parentheses are still allocated numbers as well as names. The
585 PCRE API provides function calls for extracting the name-to-number translation
586 table from a compiled pattern. For further details see the
587 .\" HREF
588 \fBpcreapi\fR
589 .\"
590 documentation.
593 .rs
594 .sp
595 Repetition is specified by quantifiers, which can follow any of the following
596 items:
598 a literal data character
599 the . metacharacter
600 the \\C escape sequence
601 escapes such as \\d that match single characters
602 a character class
603 a back reference (see next section)
604 a parenthesized subpattern (unless it is an assertion)
606 The general repetition quantifier specifies a minimum and maximum number of
607 permitted matches, by giving the two numbers in curly brackets (braces),
608 separated by a comma. The numbers must be less than 65536, and the first must
609 be less than or equal to the second. For example:
611 z{2,4}
613 matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special
614 character. If the second number is omitted, but the comma is present, there is
615 no upper limit; if the second number and the comma are both omitted, the
616 quantifier specifies an exact number of required matches. Thus
618 [aeiou]{3,}
620 matches at least 3 successive vowels, but may match many more, while
622 \\d{8}
624 matches exactly 8 digits. An opening curly bracket that appears in a position
625 where a quantifier is not allowed, or one that does not match the syntax of a
626 quantifier, is taken as a literal character. For example, {,6} is not a
627 quantifier, but a literal string of four characters.
629 In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to individual
630 bytes. Thus, for example, \\x{100}{2} matches two UTF-8 characters, each of
631 which is represented by a two-byte sequence.
633 The quantifier {0} is permitted, causing the expression to behave as if the
634 previous item and the quantifier were not present.
636 For convenience (and historical compatibility) the three most common
637 quantifiers have single-character abbreviations:
639 * is equivalent to {0,}
640 + is equivalent to {1,}
641 ? is equivalent to {0,1}
643 It is possible to construct infinite loops by following a subpattern that can
644 match no characters with a quantifier that has no upper limit, for example:
646 (a?)*
648 Earlier versions of Perl and PCRE used to give an error at compile time for
649 such patterns. However, because there are cases where this can be useful, such
650 patterns are now accepted, but if any repetition of the subpattern does in fact
651 match no characters, the loop is forcibly broken.
653 By default, the quantifiers are "greedy", that is, they match as much as
654 possible (up to the maximum number of permitted times), without causing the
655 rest of the pattern to fail. The classic example of where this gives problems
656 is in trying to match comments in C programs. These appear between the
657 sequences /* and */ and within the sequence, individual * and / characters may
658 appear. An attempt to match C comments by applying the pattern
660 /\\*.*\\*/
662 to the string
664 /* first command */ not comment /* second comment */
666 fails, because it matches the entire string owing to the greediness of the .*
667 item.
669 However, if a quantifier is followed by a question mark, it ceases to be
670 greedy, and instead matches the minimum number of times possible, so the
671 pattern
673 /\\*.*?\\*/
675 does the right thing with the C comments. The meaning of the various
676 quantifiers is not otherwise changed, just the preferred number of matches.
677 Do not confuse this use of question mark with its use as a quantifier in its
678 own right. Because it has two uses, it can sometimes appear doubled, as in
680 \\d??\\d
682 which matches one digit by preference, but can match two if that is the only
683 way the rest of the pattern matches.
685 If the PCRE_UNGREEDY option is set (an option which is not available in Perl),
686 the quantifiers are not greedy by default, but individual ones can be made
687 greedy by following them with a question mark. In other words, it inverts the
688 default behaviour.
690 When a parenthesized subpattern is quantified with a minimum repeat count that
691 is greater than 1 or with a limited maximum, more store is required for the
692 compiled pattern, in proportion to the size of the minimum or maximum.
694 If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent
695 to Perl's /s) is set, thus allowing the . to match newlines, the pattern is
696 implicitly anchored, because whatever follows will be tried against every
697 character position in the subject string, so there is no point in retrying the
698 overall match at any position after the first. PCRE normally treats such a
699 pattern as though it were preceded by \\A.
701 In cases where it is known that the subject string contains no newlines, it is
702 worth setting PCRE_DOTALL in order to obtain this optimization, or
703 alternatively using ^ to indicate anchoring explicitly.
705 However, there is one situation where the optimization cannot be used. When .*
706 is inside capturing parentheses that are the subject of a backreference
707 elsewhere in the pattern, a match at the start may fail, and a later one
708 succeed. Consider, for example:
710 (.*)abc\\1
712 If the subject is "xyz123abc123" the match point is the fourth character. For
713 this reason, such a pattern is not implicitly anchored.
715 When a capturing subpattern is repeated, the value captured is the substring
716 that matched the final iteration. For example, after
718 (tweedle[dume]{3}\\s*)+
720 has matched "tweedledum tweedledee" the value of the captured substring is
721 "tweedledee". However, if there are nested capturing subpatterns, the
722 corresponding captured values may have been set in previous iterations. For
723 example, after
725 /(a|(b))+/
727 matches "aba" the value of the second captured substring is "b".
730 .rs
731 .sp
732 With both maximizing and minimizing repetition, failure of what follows
733 normally causes the repeated item to be re-evaluated to see if a different
734 number of repeats allows the rest of the pattern to match. Sometimes it is
735 useful to prevent this, either to change the nature of the match, or to cause
736 it fail earlier than it otherwise might, when the author of the pattern knows
737 there is no point in carrying on.
739 Consider, for example, the pattern \\d+foo when applied to the subject line
741 123456bar
743 After matching all 6 digits and then failing to match "foo", the normal
744 action of the matcher is to try again with only 5 digits matching the \\d+
745 item, and then with 4, and so on, before ultimately failing. "Atomic grouping"
746 (a term taken from Jeffrey Friedl's book) provides the means for specifying
747 that once a subpattern has matched, it is not to be re-evaluated in this way.
749 If we use atomic grouping for the previous example, the matcher would give up
750 immediately on failing to match "foo" the first time. The notation is a kind of
751 special parenthesis, starting with (?> as in this example:
753 (?>\\d+)foo
755 This kind of parenthesis "locks up" the part of the pattern it contains once
756 it has matched, and a failure further into the pattern is prevented from
757 backtracking into it. Backtracking past it to previous items, however, works as
758 normal.
760 An alternative description is that a subpattern of this type matches the string
761 of characters that an identical standalone pattern would match, if anchored at
762 the current point in the subject string.
764 Atomic grouping subpatterns are not capturing subpatterns. Simple cases such as
765 the above example can be thought of as a maximizing repeat that must swallow
766 everything it can. So, while both \\d+ and \\d+? are prepared to adjust the
767 number of digits they match in order to make the rest of the pattern match,
768 (?>\\d+) can only match an entire sequence of digits.
770 Atomic groups in general can of course contain arbitrarily complicated
771 subpatterns, and can be nested. However, when the subpattern for an atomic
772 group is just a single repeated item, as in the example above, a simpler
773 notation, called a "possessive quantifier" can be used. This consists of an
774 additional + character following a quantifier. Using this notation, the
775 previous example can be rewritten as
777 \\d++bar
779 Possessive quantifiers are always greedy; the setting of the PCRE_UNGREEDY
780 option is ignored. They are a convenient notation for the simpler forms of
781 atomic group. However, there is no difference in the meaning or processing of a
782 possessive quantifier and the equivalent atomic group.
784 The possessive quantifier syntax is an extension to the Perl syntax. It
785 originates in Sun's Java package.
787 When a pattern contains an unlimited repeat inside a subpattern that can itself
788 be repeated an unlimited number of times, the use of an atomic group is the
789 only way to avoid some failing matches taking a very long time indeed. The
790 pattern
792 (\\D+|<\\d+>)*[!?]
794 matches an unlimited number of substrings that either consist of non-digits, or
795 digits enclosed in <>, followed by either ! or ?. When it matches, it runs
796 quickly. However, if it is applied to
798 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
800 it takes a long time before reporting failure. This is because the string can
801 be divided between the two repeats in a large number of ways, and all have to
802 be tried. (The example used [!?] rather than a single character at the end,
803 because both PCRE and Perl have an optimization that allows for fast failure
804 when a single character is used. They remember the last single character that
805 is required for a match, and fail early if it is not present in the string.)
806 If the pattern is changed to
808 ((?>\\D+)|<\\d+>)*[!?]
810 sequences of non-digits cannot be broken, and failure happens quickly.
813 .rs
814 .sp
815 Outside a character class, a backslash followed by a digit greater than 0 (and
816 possibly further digits) is a back reference to a capturing subpattern earlier
817 (that is, to its left) in the pattern, provided there have been that many
818 previous capturing left parentheses.
820 However, if the decimal number following the backslash is less than 10, it is
821 always taken as a back reference, and causes an error only if there are not
822 that many capturing left parentheses in the entire pattern. In other words, the
823 parentheses that are referenced need not be to the left of the reference for
824 numbers less than 10. See the section entitled "Backslash" above for further
825 details of the handling of digits following a backslash.
827 A back reference matches whatever actually matched the capturing subpattern in
828 the current subject string, rather than anything matching the subpattern
829 itself (see
830 .\" HTML <a href="#subpatternsassubroutines">
831 .\" </a>
832 "Subpatterns as subroutines"
833 .\"
834 below for a way of doing that). So the pattern
836 (sens|respons)e and \\1ibility
838 matches "sense and sensibility" and "response and responsibility", but not
839 "sense and responsibility". If caseful matching is in force at the time of the
840 back reference, the case of letters is relevant. For example,
842 ((?i)rah)\\s+\\1
844 matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original
845 capturing subpattern is matched caselessly.
847 Back references to named subpatterns use the Python syntax (?P=name). We could
848 rewrite the above example as follows:
850 (?<p1>(?i)rah)\\s+(?P=p1)
852 There may be more than one back reference to the same subpattern. If a
853 subpattern has not actually been used in a particular match, any back
854 references to it always fail. For example, the pattern
856 (a|(bc))\\2
858 always fails if it starts to match "a" rather than "bc". Because there may be
859 many capturing parentheses in a pattern, all digits following the backslash are
860 taken as part of a potential back reference number. If the pattern continues
861 with a digit character, some delimiter must be used to terminate the back
862 reference. If the PCRE_EXTENDED option is set, this can be whitespace.
863 Otherwise an empty comment can be used.
865 A back reference that occurs inside the parentheses to which it refers fails
866 when the subpattern is first used, so, for example, (a\\1) never matches.
867 However, such references can be useful inside repeated subpatterns. For
868 example, the pattern
870 (a|b\\1)+
872 matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration of
873 the subpattern, the back reference matches the character string corresponding
874 to the previous iteration. In order for this to work, the pattern must be such
875 that the first iteration does not need to match the back reference. This can be
876 done using alternation, as in the example above, or by a quantifier with a
877 minimum of zero.
880 .rs
881 .sp
882 An assertion is a test on the characters following or preceding the current
883 matching point that does not actually consume any characters. The simple
884 assertions coded as \\b, \\B, \\A, \\G, \\Z, \\z, ^ and $ are described above.
885 More complicated assertions are coded as subpatterns. There are two kinds:
886 those that look ahead of the current position in the subject string, and those
887 that look behind it.
889 An assertion subpattern is matched in the normal way, except that it does not
890 cause the current matching position to be changed. Lookahead assertions start
891 with (?= for positive assertions and (?! for negative assertions. For example,
893 \\w+(?=;)
895 matches a word followed by a semicolon, but does not include the semicolon in
896 the match, and
898 foo(?!bar)
900 matches any occurrence of "foo" that is not followed by "bar". Note that the
901 apparently similar pattern
903 (?!foo)bar
905 does not find an occurrence of "bar" that is preceded by something other than
906 "foo"; it finds any occurrence of "bar" whatsoever, because the assertion
907 (?!foo) is always true when the next three characters are "bar". A
908 lookbehind assertion is needed to achieve this effect.
910 If you want to force a matching failure at some point in a pattern, the most
911 convenient way to do it is with (?!) because an empty string always matches, so
912 an assertion that requires there not to be an empty string must always fail.
914 Lookbehind assertions start with (?<= for positive assertions and (?<! for
915 negative assertions. For example,
917 (?<!foo)bar
919 does find an occurrence of "bar" that is not preceded by "foo". The contents of
920 a lookbehind assertion are restricted such that all the strings it matches must
921 have a fixed length. However, if there are several alternatives, they do not
922 all have to have the same fixed length. Thus
924 (?<=bullock|donkey)
926 is permitted, but
928 (?<!dogs?|cats?)
930 causes an error at compile time. Branches that match different length strings
931 are permitted only at the top level of a lookbehind assertion. This is an
932 extension compared with Perl (at least for 5.8), which requires all branches to
933 match the same length of string. An assertion such as
935 (?<=ab(c|de))
937 is not permitted, because its single top-level branch can match two different
938 lengths, but it is acceptable if rewritten to use two top-level branches:
940 (?<=abc|abde)
942 The implementation of lookbehind assertions is, for each alternative, to
943 temporarily move the current position back by the fixed width and then try to
944 match. If there are insufficient characters before the current position, the
945 match is deemed to fail.
947 PCRE does not allow the \\C escape (which matches a single byte in UTF-8 mode)
948 to appear in lookbehind assertions, because it makes it impossible to calculate
949 the length of the lookbehind.
951 Atomic groups can be used in conjunction with lookbehind assertions to specify
952 efficient matching at the end of the subject string. Consider a simple pattern
953 such as
955 abcd$
957 when applied to a long string that does not match. Because matching proceeds
958 from left to right, PCRE will look for each "a" in the subject and then see if
959 what follows matches the rest of the pattern. If the pattern is specified as
961 ^.*abcd$
963 the initial .* matches the entire string at first, but when this fails (because
964 there is no following "a"), it backtracks to match all but the last character,
965 then all but the last two characters, and so on. Once again the search for "a"
966 covers the entire string, from right to left, so we are no better off. However,
967 if the pattern is written as
969 ^(?>.*)(?<=abcd)
971 or, equivalently,
973 ^.*+(?<=abcd)
975 there can be no backtracking for the .* item; it can match only the entire
976 string. The subsequent lookbehind assertion does a single test on the last four
977 characters. If it fails, the match fails immediately. For long strings, this
978 approach makes a significant difference to the processing time.
980 Several assertions (of any sort) may occur in succession. For example,
982 (?<=\\d{3})(?<!999)foo
984 matches "foo" preceded by three digits that are not "999". Notice that each of
985 the assertions is applied independently at the same point in the subject
986 string. First there is a check that the previous three characters are all
987 digits, and then there is a check that the same three characters are not "999".
988 This pattern does \fInot\fR match "foo" preceded by six characters, the first
989 of which are digits and the last three of which are not "999". For example, it
990 doesn't match "123abcfoo". A pattern to do that is
992 (?<=\\d{3}...)(?<!999)foo
994 This time the first assertion looks at the preceding six characters, checking
995 that the first three are digits, and then the second assertion checks that the
996 preceding three characters are not "999".
998 Assertions can be nested in any combination. For example,
1000 (?<=(?<!foo)bar)baz
1002 matches an occurrence of "baz" that is preceded by "bar" which in turn is not
1003 preceded by "foo", while
1005 (?<=\\d{3}(?!999)...)foo
1007 is another pattern which matches "foo" preceded by three digits and any three
1008 characters that are not "999".
1010 Assertion subpatterns are not capturing subpatterns, and may not be repeated,
1011 because it makes no sense to assert the same thing several times. If any kind
1012 of assertion contains capturing subpatterns within it, these are counted for
1013 the purposes of numbering the capturing subpatterns in the whole pattern.
1014 However, substring capturing is carried out only for positive assertions,
1015 because it does not make sense for negative assertions.
1018 .rs
1019 .sp
1020 It is possible to cause the matching process to obey a subpattern
1021 conditionally or to choose between two alternative subpatterns, depending on
1022 the result of an assertion, or whether a previous capturing subpattern matched
1023 or not. The two possible forms of conditional subpattern are
1025 (?(condition)yes-pattern)
1026 (?(condition)yes-pattern|no-pattern)
1028 If the condition is satisfied, the yes-pattern is used; otherwise the
1029 no-pattern (if present) is used. If there are more than two alternatives in the
1030 subpattern, a compile-time error occurs.
1032 There are three kinds of condition. If the text between the parentheses
1033 consists of a sequence of digits, the condition is satisfied if the capturing
1034 subpattern of that number has previously matched. The number must be greater
1035 than zero. Consider the following pattern, which contains non-significant white
1036 space to make it more readable (assume the PCRE_EXTENDED option) and to divide
1037 it into three parts for ease of discussion:
1039 ( \\( )? [^()]+ (?(1) \\) )
1041 The first part matches an optional opening parenthesis, and if that
1042 character is present, sets it as the first captured substring. The second part
1043 matches one or more characters that are not parentheses. The third part is a
1044 conditional subpattern that tests whether the first set of parentheses matched
1045 or not. If they did, that is, if subject started with an opening parenthesis,
1046 the condition is true, and so the yes-pattern is executed and a closing
1047 parenthesis is required. Otherwise, since no-pattern is not present, the
1048 subpattern matches nothing. In other words, this pattern matches a sequence of
1049 non-parentheses, optionally enclosed in parentheses.
1051 If the condition is the string (R), it is satisfied if a recursive call to the
1052 pattern or subpattern has been made. At "top level", the condition is false.
1053 This is a PCRE extension. Recursive patterns are described in the next section.
1055 If the condition is not a sequence of digits or (R), it must be an assertion.
1056 This may be a positive or negative lookahead or lookbehind assertion. Consider
1057 this pattern, again containing non-significant white space, and with the two
1058 alternatives on the second line:
1060 (?(?=[^a-z]*[a-z])
1061 \\d{2}-[a-z]{3}-\\d{2} | \\d{2}-\\d{2}-\\d{2} )
1063 The condition is a positive lookahead assertion that matches an optional
1064 sequence of non-letters followed by a letter. In other words, it tests for the
1065 presence of at least one letter in the subject. If a letter is found, the
1066 subject is matched against the first alternative; otherwise it is matched
1067 against the second. This pattern matches strings in one of the two forms
1068 dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.
1071 .rs
1072 .sp
1073 The sequence (?# marks the start of a comment which continues up to the next
1074 closing parenthesis. Nested parentheses are not permitted. The characters
1075 that make up a comment play no part in the pattern matching at all.
1077 If the PCRE_EXTENDED option is set, an unescaped # character outside a
1078 character class introduces a comment that continues up to the next newline
1079 character in the pattern.
1082 .rs
1083 .sp
1084 Consider the problem of matching a string in parentheses, allowing for
1085 unlimited nested parentheses. Without the use of recursion, the best that can
1086 be done is to use a pattern that matches up to some fixed depth of nesting. It
1087 is not possible to handle an arbitrary nesting depth. Perl has provided an
1088 experimental facility that allows regular expressions to recurse (amongst other
1089 things). It does this by interpolating Perl code in the expression at run time,
1090 and the code can refer to the expression itself. A Perl pattern to solve the
1091 parentheses problem can be created like this:
1093 $re = qr{\\( (?: (?>[^()]+) | (?p{$re}) )* \\)}x;
1095 The (?p{...}) item interpolates Perl code at run time, and in this case refers
1096 recursively to the pattern in which it appears. Obviously, PCRE cannot support
1097 the interpolation of Perl code. Instead, it supports some special syntax for
1098 recursion of the entire pattern, and also for individual subpattern recursion.
1100 The special item that consists of (? followed by a number greater than zero and
1101 a closing parenthesis is a recursive call of the subpattern of the given
1102 number, provided that it occurs inside that subpattern. (If not, it is a
1103 "subroutine" call, which is described in the next section.) The special item
1104 (?R) is a recursive call of the entire regular expression.
1106 For example, this PCRE pattern solves the nested parentheses problem (assume
1107 the PCRE_EXTENDED option is set so that white space is ignored):
1109 \\( ( (?>[^()]+) | (?R) )* \\)
1111 First it matches an opening parenthesis. Then it matches any number of
1112 substrings which can either be a sequence of non-parentheses, or a recursive
1113 match of the pattern itself (that is a correctly parenthesized substring).
1114 Finally there is a closing parenthesis.
1116 If this were part of a larger pattern, you would not want to recurse the entire
1117 pattern, so instead you could use this:
1119 ( \\( ( (?>[^()]+) | (?1) )* \\) )
1121 We have put the pattern into parentheses, and caused the recursion to refer to
1122 them instead of the whole pattern. In a larger pattern, keeping track of
1123 parenthesis numbers can be tricky. It may be more convenient to use named
1124 parentheses instead. For this, PCRE uses (?P>name), which is an extension to
1125 the Python syntax that PCRE uses for named parentheses (Perl does not provide
1126 named parentheses). We could rewrite the above example as follows:
1128 (?P<pn> \\( ( (?>[^()]+) | (?P>pn) )* \\) )
1130 This particular example pattern contains nested unlimited repeats, and so the
1131 use of atomic grouping for matching strings of non-parentheses is important
1132 when applying the pattern to strings that do not match. For example, when this
1133 pattern is applied to
1135 (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
1137 it yields "no match" quickly. However, if atomic grouping is not used,
1138 the match runs for a very long time indeed because there are so many different
1139 ways the + and * repeats can carve up the subject, and all have to be tested
1140 before failure can be reported.
1142 At the end of a match, the values set for any capturing subpatterns are those
1143 from the outermost level of the recursion at which the subpattern value is set.
1144 If you want to obtain intermediate values, a callout function can be used (see
1145 below and the
1146 .\" HREF
1147 \fBpcrecallout\fR
1148 .\"
1149 documentation). If the pattern above is matched against
1151 (ab(cd)ef)
1153 the value for the capturing parentheses is "ef", which is the last value taken
1154 on at the top level. If additional parentheses are added, giving
1156 \\( ( ( (?>[^()]+) | (?R) )* ) \\)
1157 ^ ^
1158 ^ ^
1160 the string they capture is "ab(cd)ef", the contents of the top level
1161 parentheses. If there are more than 15 capturing parentheses in a pattern, PCRE
1162 has to obtain extra memory to store data during a recursion, which it does by
1163 using \fBpcre_malloc\fR, freeing it via \fBpcre_free\fR afterwards. If no
1164 memory can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.
1166 Do not confuse the (?R) item with the condition (R), which tests for recursion.
1167 Consider this pattern, which matches text in angle brackets, allowing for
1168 arbitrary nesting. Only digits are allowed in nested brackets (that is, when
1169 recursing), whereas any characters are permitted at the outer level.
1171 < (?: (?(R) \\d++ | [^<>]*+) | (?R)) * >
1173 In this pattern, (?(R) is the start of a conditional subpattern, with two
1174 different alternatives for the recursive and non-recursive cases. The (?R) item
1175 is the actual recursive call.
1177 .\" HTML <a name="subpatternsassubroutines"></a>
1179 .rs
1180 .sp
1181 If the syntax for a recursive subpattern reference (either by number or by
1182 name) is used outside the parentheses to which it refers, it operates like a
1183 subroutine in a programming language. An earlier example pointed out that the
1184 pattern
1186 (sens|respons)e and \\1ibility
1188 matches "sense and sensibility" and "response and responsibility", but not
1189 "sense and responsibility". If instead the pattern
1191 (sens|respons)e and (?1)ibility
1193 is used, it does match "sense and responsibility" as well as the other two
1194 strings. Such references must, however, follow the subpattern to which they
1195 refer.
1198 .rs
1199 .sp
1200 Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl
1201 code to be obeyed in the middle of matching a regular expression. This makes it
1202 possible, amongst other things, to extract different substrings that match the
1203 same pair of parentheses when there is a repetition.
1205 PCRE provides a similar feature, but of course it cannot obey arbitrary Perl
1206 code. The feature is called "callout". The caller of PCRE provides an external
1207 function by putting its entry point in the global variable \fIpcre_callout\fR.
1208 By default, this variable contains NULL, which disables all calling out.
1210 Within a regular expression, (?C) indicates the points at which the external
1211 function is to be called. If you want to identify different callout points, you
1212 can put a number less than 256 after the letter C. The default value is zero.
1213 For example, this pattern has two callout points:
1215 (?C1)\dabc(?C2)def
1217 During matching, when PCRE reaches a callout point (and \fIpcre_callout\fR is
1218 set), the external function is called. It is provided with the number of the
1219 callout, and, optionally, one item of data originally supplied by the caller of
1220 \fBpcre_exec()\fR. The callout function may cause matching to backtrack, or to
1221 fail altogether. A complete description of the interface to the callout
1222 function is given in the
1223 .\" HREF
1224 \fBpcrecallout\fR
1225 .\"
1226 documentation.
1228 .in 0
1229 Last updated: 03 February 2003
1230 .br
1231 Copyright (c) 1997-2003 University of Cambridge.

  ViewVC Help
Powered by ViewVC 1.1.5